diff --git a/crates/parcel-resolver/src/package_json.rs b/crates/parcel-resolver/src/package_json.rs
index f3b63f22a71..0b507e57e25 100644
--- a/crates/parcel-resolver/src/package_json.rs
+++ b/crates/parcel-resolver/src/package_json.rs
@@ -584,9 +584,7 @@ impl PackageJson {
         for (key, value) in target {
           let matches = match key {
             ExportsKey::Condition(key) => {
-              *key == ExportsCondition::SOURCE
-                || *key == ExportsCondition::DEFAULT
-                || conditions.contains(*key)
+              *key == ExportsCondition::DEFAULT || conditions.contains(*key)
             }
             ExportsKey::CustomCondition(key) => custom_conditions.iter().any(|k| k == key),
             _ => false,
diff --git a/packages/configs/default/index.json b/packages/configs/default/index.json
index de133550b75..8c49b485d01 100644
--- a/packages/configs/default/index.json
+++ b/packages/configs/default/index.json
@@ -48,6 +48,7 @@
   },
   "namers": ["@parcel/namer-default"],
   "runtimes": [
+    "@parcel/runtime-rsc",
     "@parcel/runtime-js",
     "@parcel/runtime-browser-hmr",
     "@parcel/runtime-service-worker"
diff --git a/packages/configs/default/package.json b/packages/configs/default/package.json
index a933aeaf0c4..686f6484360 100644
--- a/packages/configs/default/package.json
+++ b/packages/configs/default/package.json
@@ -36,6 +36,7 @@
     "@parcel/resolver-default": "2.13.3",
     "@parcel/runtime-browser-hmr": "2.13.3",
     "@parcel/runtime-js": "2.13.3",
+    "@parcel/runtime-rsc": "2.13.3",
     "@parcel/runtime-service-worker": "2.13.3",
     "@parcel/transformer-babel": "2.13.3",
     "@parcel/transformer-css": "2.13.3",
diff --git a/packages/configs/react-static/index.json b/packages/configs/react-static/index.json
new file mode 100644
index 00000000000..7181328f5ad
--- /dev/null
+++ b/packages/configs/react-static/index.json
@@ -0,0 +1,7 @@
+{
+  "extends": "@parcel/config-default",
+  "namers": ["@parcel/namer-static", "..."],
+  "packagers": {
+    "*.html": "@parcel/packager-react-static"
+  }
+}
diff --git a/packages/configs/react-static/package.json b/packages/configs/react-static/package.json
new file mode 100644
index 00000000000..0261a83aba7
--- /dev/null
+++ b/packages/configs/react-static/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "@parcel/config-react-static",
+  "version": "2.13.3",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/parcel.git"
+  },
+  "main": "index.json",
+  "dependencies": {
+    "@parcel/config-default": "2.13.3",
+    "@parcel/namer-static": "2.13.3",
+    "@parcel/packager-react-static": "2.13.3"
+  }
+}
diff --git a/packages/core/core/src/PackagerRunner.js b/packages/core/core/src/PackagerRunner.js
index a7dc9ac27fe..87d7a8be08e 100644
--- a/packages/core/core/src/PackagerRunner.js
+++ b/packages/core/core/src/PackagerRunner.js
@@ -72,7 +72,7 @@ type Opts = {|
 |};
 
 export type RunPackagerRunnerResult = {|
-  bundleInfo: BundleInfo,
+  bundleInfo: BundleInfo[],
   configRequests: Array<ConfigRequest>,
   devDepRequests: Array<DevDepRequest>,
   invalidations: Array<RequestInvalidation>,
@@ -91,7 +91,6 @@ export type BundleInfo = {|
 type CacheKeyMap = {|
   content: string,
   map: string,
-  info: string,
 |};
 
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
@@ -146,14 +145,21 @@ export default class PackagerRunner {
     invalidateDevDeps(invalidDevDeps, this.options, this.config);
 
     let {configs, bundleConfigs} = await this.loadConfigs(bundleGraph, bundle);
-    let bundleInfo =
-      (await this.getBundleInfoFromCache(
-        bundleGraph,
+    let bundleInfo = await this.getBundleInfoFromCache(
+      bundleGraph,
+      bundle,
+      configs,
+      bundleConfigs,
+    );
+
+    if (bundleInfo.length === 0) {
+      bundleInfo = await this.getBundleInfo(
         bundle,
+        bundleGraph,
         configs,
         bundleConfigs,
-      )) ??
-      (await this.getBundleInfo(bundle, bundleGraph, configs, bundleConfigs));
+      );
+    }
 
     let configRequests = getConfigRequests([
       ...configs.values(),
@@ -287,9 +293,9 @@ export default class PackagerRunner {
     bundle: InternalBundle,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
-  ): Async<?BundleInfo> {
+  ): Promise<BundleInfo[]> {
     if (this.options.shouldDisableCache) {
-      return;
+      return [];
     }
 
     let cacheKey = await this.getCacheKey(
@@ -300,7 +306,8 @@ export default class PackagerRunner {
       this.previousInvalidations,
     );
     let infoKey = PackagerRunner.getInfoKey(cacheKey);
-    return this.options.cache.get<BundleInfo>(infoKey);
+    let res = await this.options.cache.get<BundleInfo[]>(infoKey);
+    return res ?? [];
   }
 
   async getBundleInfo(
@@ -308,8 +315,8 @@ export default class PackagerRunner {
     bundleGraph: InternalBundleGraph,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
-  ): Promise<BundleInfo> {
-    let {type, contents, map} = await this.getBundleResult(
+  ): Promise<BundleInfo[]> {
+    let results = await this.getBundleResult(
       bundle,
       bundleGraph,
       configs,
@@ -324,13 +331,8 @@ export default class PackagerRunner {
       bundleConfigs,
       [...this.invalidations.values()],
     );
-    let cacheKeys = {
-      content: PackagerRunner.getContentKey(cacheKey),
-      map: PackagerRunner.getMapKey(cacheKey),
-      info: PackagerRunner.getInfoKey(cacheKey),
-    };
 
-    return this.writeToCache(cacheKeys, type, contents, map);
+    return this.writeToCache(cacheKey, results);
   }
 
   async getBundleResult(
@@ -338,35 +340,43 @@ export default class PackagerRunner {
     bundleGraph: InternalBundleGraph,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
-  ): Promise<{|
-    type: string,
-    contents: Blob,
-    map: ?string,
-  |}> {
-    let packaged = await this.package(
+  ): Promise<
+    {|
+      type: string,
+      contents: Blob,
+      map: ?string,
+    |}[],
+  > {
+    let packagedResults = await this.package(
       bundle,
       bundleGraph,
       configs,
       bundleConfigs,
     );
-    let type = packaged.type ?? bundle.type;
-    let res = await this.optimize(
-      bundle,
-      bundleGraph,
-      type,
-      packaged.contents,
-      packaged.map,
-      configs,
-      bundleConfigs,
-    );
+    return Promise.all(
+      packagedResults.map(async packaged => {
+        let type = packaged.type ?? bundle.type;
+        let res = await this.optimize(
+          bundle,
+          bundleGraph,
+          type,
+          packaged.contents,
+          packaged.map,
+          configs,
+          bundleConfigs,
+        );
 
-    let map =
-      res.map != null ? await this.generateSourceMap(bundle, res.map) : null;
-    return {
-      type: res.type ?? type,
-      contents: res.contents,
-      map,
-    };
+        let map =
+          res.map != null
+            ? await this.generateSourceMap(bundle, res.map)
+            : null;
+        return {
+          type: res.type ?? type,
+          contents: res.contents,
+          map,
+        };
+      }),
+    );
   }
 
   getSourceMapReference(bundle: NamedBundle, map: ?SourceMap): Async<?string> {
@@ -386,7 +396,7 @@ export default class PackagerRunner {
     bundleGraph: InternalBundleGraph,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
-  ): Promise<BundleResult> {
+  ): Promise<BundleResult[]> {
     let bundle = NamedBundle.get(internalBundle, bundleGraph, this.options);
     this.report({
       type: 'buildProgress',
@@ -401,7 +411,7 @@ export default class PackagerRunner {
       measurement = tracer.createMeasurement(name, 'packaging', bundle.name, {
         type: bundle.type,
       });
-      return await plugin.package({
+      let res = await plugin.package({
         config: configs.get(name)?.result,
         bundleConfig: bundleConfigs.get(name)?.result,
         bundle,
@@ -434,9 +444,13 @@ export default class PackagerRunner {
             bundleConfigs,
           );
 
-          return {contents: res.contents};
+          return {contents: res[0].contents};
         },
       });
+      if (Array.isArray(res)) {
+        return res;
+      }
+      return [res];
     } catch (e) {
       throw new ThrowableDiagnostic({
         diagnostic: errorToDiagnostic(e, {
@@ -482,12 +496,16 @@ export default class PackagerRunner {
       NamedBundle.get.bind(NamedBundle),
       this.options,
     );
+    let name = bundle.name;
+    if (type !== bundle.type) {
+      name = name.slice(0, -path.extname(name).length) + '.' + type;
+    }
     let optimizers = await this.config.getOptimizers(
-      bundle.name,
+      name,
       internalBundle.pipeline,
     );
     if (!optimizers.length) {
-      return {type: bundle.type, contents, map};
+      return {type, contents, map};
     }
 
     this.report({
@@ -691,97 +709,82 @@ export default class PackagerRunner {
     return devDepHashes;
   }
 
-  async readFromCache(cacheKey: string): Promise<?{|
-    contents: Readable,
-    map: ?Readable,
-  |}> {
-    let contentKey = PackagerRunner.getContentKey(cacheKey);
-    let mapKey = PackagerRunner.getMapKey(cacheKey);
-
-    let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists =
-      isLargeBlob || (await this.options.cache.has(contentKey));
-    if (!contentExists) {
-      return null;
-    }
-
-    let mapExists = await this.options.cache.has(mapKey);
-
-    return {
-      contents: isLargeBlob
-        ? this.options.cache.getStream(contentKey)
-        : blobToStream(await this.options.cache.getBlob(contentKey)),
-      map: mapExists
-        ? blobToStream(await this.options.cache.getBlob(mapKey))
-        : null,
-    };
-  }
-
   async writeToCache(
-    cacheKeys: CacheKeyMap,
-    type: string,
-    contents: Blob,
-    map: ?string,
-  ): Promise<BundleInfo> {
-    let size = 0;
-    let hash;
-    let hashReferences = [];
-    let isLargeBlob = false;
-
-    // TODO: don't replace hash references in binary files??
-    if (contents instanceof Readable) {
-      isLargeBlob = true;
-      let boundaryStr = '';
-      let h = new Hash();
-      await this.options.cache.setStream(
-        cacheKeys.content,
-        blobToStream(contents).pipe(
-          new TapStream(buf => {
-            let str = boundaryStr + buf.toString();
-            hashReferences = hashReferences.concat(
-              str.match(HASH_REF_REGEX) ?? [],
-            );
-            size += buf.length;
-            h.writeBuffer(buf);
-            boundaryStr = str.slice(str.length - BOUNDARY_LENGTH);
-          }),
-        ),
-      );
-      hash = h.finish();
-    } else if (typeof contents === 'string') {
-      let buffer = Buffer.from(contents);
-      size = buffer.byteLength;
-      hash = hashBuffer(buffer);
-      hashReferences = contents.match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
-    } else {
-      size = contents.length;
-      hash = hashBuffer(contents);
-      hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
-    }
+    cacheKey: string,
+    results: Array<{|
+      contents: Blob,
+      map: ?string,
+      type: string,
+    |}>,
+  ): Promise<BundleInfo[]> {
+    let info = await Promise.all(
+      results.map(async ({contents, map, type}, index) => {
+        let size = 0;
+        let hash;
+        let hashReferences = [];
+        let isLargeBlob = false;
+        let cacheKeys = {
+          content: PackagerRunner.getContentKey(cacheKey, index),
+          map: PackagerRunner.getMapKey(cacheKey, index),
+        };
 
-    if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
-    }
-    let info = {
-      type,
-      size,
-      hash,
-      hashReferences,
-      cacheKeys,
-      isLargeBlob,
-    };
-    await this.options.cache.set(cacheKeys.info, info);
+        // TODO: don't replace hash references in binary files??
+        if (contents instanceof Readable) {
+          isLargeBlob = true;
+          let boundaryStr = '';
+          let h = new Hash();
+          await this.options.cache.setStream(
+            cacheKeys.content,
+            blobToStream(contents).pipe(
+              new TapStream(buf => {
+                let str = boundaryStr + buf.toString();
+                hashReferences = hashReferences.concat(
+                  str.match(HASH_REF_REGEX) ?? [],
+                );
+                size += buf.length;
+                h.writeBuffer(buf);
+                boundaryStr = str.slice(str.length - BOUNDARY_LENGTH);
+              }),
+            ),
+          );
+          hash = h.finish();
+        } else if (typeof contents === 'string') {
+          let buffer = Buffer.from(contents);
+          size = buffer.byteLength;
+          hash = hashBuffer(buffer);
+          hashReferences = contents.match(HASH_REF_REGEX) ?? [];
+          await this.options.cache.setBlob(cacheKeys.content, buffer);
+        } else {
+          size = contents.length;
+          hash = hashBuffer(contents);
+          hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
+          await this.options.cache.setBlob(cacheKeys.content, contents);
+        }
+
+        if (map != null) {
+          await this.options.cache.setBlob(cacheKeys.map, map);
+        }
+        let info: BundleInfo = {
+          type,
+          size,
+          hash,
+          hashReferences,
+          cacheKeys,
+          isLargeBlob,
+        };
+        return info;
+      }),
+    );
+    await this.options.cache.set(PackagerRunner.getInfoKey(cacheKey), info);
     return info;
   }
 
-  static getContentKey(cacheKey: string): string {
-    return hashString(`${cacheKey}:content`);
+  static getContentKey(cacheKey: string, index: number): string {
+    return hashString(`${cacheKey}:${index}:content`);
   }
 
-  static getMapKey(cacheKey: string): string {
-    return hashString(`${cacheKey}:map`);
+  static getMapKey(cacheKey: string, index: number): string {
+    return hashString(`${cacheKey}:${index}:map`);
   }
 
   static getInfoKey(cacheKey: string): string {
diff --git a/packages/core/core/src/public/Bundle.js b/packages/core/core/src/public/Bundle.js
index 9e9b29dac91..6e1fda606d8 100644
--- a/packages/core/core/src/public/Bundle.js
+++ b/packages/core/core/src/public/Bundle.js
@@ -17,6 +17,7 @@ import type {
   Stats,
   Target as ITarget,
   BundleBehavior,
+  PackagedBundleFile,
 } from '@parcel/types';
 import type BundleGraph from '../BundleGraph';
 
@@ -263,7 +264,7 @@ export class PackagedBundle extends NamedBundle implements IPackagedBundle {
   #bundle /*: InternalBundle */;
   #bundleGraph /*: BundleGraph */;
   #options /*: ParcelOptions */;
-  #bundleInfo /*: ?PackagedBundleInfo */;
+  #bundleInfo /*: ?PackagedBundleInfo[] */;
 
   constructor(
     sentinel: mixed,
@@ -307,7 +308,7 @@ export class PackagedBundle extends NamedBundle implements IPackagedBundle {
     internalBundle: InternalBundle,
     bundleGraph: BundleGraph,
     options: ParcelOptions,
-    bundleInfo: ?PackagedBundleInfo,
+    bundleInfo: ?(PackagedBundleInfo[]),
   ): PackagedBundle {
     let packagedBundle = PackagedBundle.get(
       internalBundle,
@@ -321,17 +322,26 @@ export class PackagedBundle extends NamedBundle implements IPackagedBundle {
   get filePath(): string {
     return fromProjectPath(
       this.#options.projectRoot,
-      nullthrows(this.#bundleInfo).filePath,
+      nullthrows(this.#bundleInfo)[0].filePath,
     );
   }
 
   get type(): string {
     // The bundle type may be overridden in the packager.
     // However, inline bundles will not have a bundleInfo here since they are not written to the filesystem.
-    return this.#bundleInfo ? this.#bundleInfo.type : this.#bundle.type;
+    return this.#bundleInfo ? this.#bundleInfo[0].type : this.#bundle.type;
   }
 
   get stats(): Stats {
-    return nullthrows(this.#bundleInfo).stats;
+    return nullthrows(this.#bundleInfo)[0].stats;
+  }
+
+  get files(): PackagedBundleFile[] {
+    return this.#bundleInfo
+      ? this.#bundleInfo.map(i => ({
+          filePath: fromProjectPath(this.#options.projectRoot, i.filePath),
+          stats: i.stats,
+        }))
+      : [];
   }
 }
diff --git a/packages/core/core/src/requests/PackageRequest.js b/packages/core/core/src/requests/PackageRequest.js
index 666298cb780..2169a809bf0 100644
--- a/packages/core/core/src/requests/PackageRequest.js
+++ b/packages/core/core/src/requests/PackageRequest.js
@@ -24,7 +24,7 @@ type PackageRequestInput = {|
   useMainThread?: boolean,
 |};
 
-export type PackageRequestResult = BundleInfo;
+export type PackageRequestResult = BundleInfo[];
 
 type RunInput<TResult> = {|
   input: PackageRequestInput,
@@ -34,7 +34,7 @@ type RunInput<TResult> = {|
 export type PackageRequest = {|
   id: ContentKey,
   +type: typeof requestTypes.package_request,
-  run: (RunInput<BundleInfo>) => Async<BundleInfo>,
+  run: (RunInput<BundleInfo[]>) => Async<BundleInfo[]>,
   input: PackageRequestInput,
 |};
 
@@ -95,8 +95,10 @@ async function run({input, api, farm}) {
     }
   }
 
-  // $FlowFixMe[cannot-write] time is marked read-only, but this is the exception
-  bundleInfo.time = Date.now() - start;
+  for (let info of bundleInfo) {
+    // $FlowFixMe[cannot-write] time is marked read-only, but this is the exception
+    info.time = Date.now() - start;
+  }
 
   api.storeResult(bundleInfo);
   return bundleInfo;
diff --git a/packages/core/core/src/requests/ParcelBuildRequest.js b/packages/core/core/src/requests/ParcelBuildRequest.js
index a3bb384c9ec..b80e584ecb4 100644
--- a/packages/core/core/src/requests/ParcelBuildRequest.js
+++ b/packages/core/core/src/requests/ParcelBuildRequest.js
@@ -31,7 +31,7 @@ type ParcelBuildRequestInput = {|
 
 export type ParcelBuildRequestResult = {|
   bundleGraph: BundleGraph,
-  bundleInfo: Map<string, PackagedBundleInfo>,
+  bundleInfo: Map<string, PackagedBundleInfo[]>,
   changedAssets: Map<string, Asset>,
   assetRequests: Array<AssetGroup>,
 |};
diff --git a/packages/core/core/src/requests/WriteBundleRequest.js b/packages/core/core/src/requests/WriteBundleRequest.js
index d6c7fe1d733..836fa5640ec 100644
--- a/packages/core/core/src/requests/WriteBundleRequest.js
+++ b/packages/core/core/src/requests/WriteBundleRequest.js
@@ -2,7 +2,7 @@
 
 import type {FileSystem, FileOptions} from '@parcel/fs';
 import type {ContentKey} from '@parcel/graph';
-import type {Async, FilePath, Compressor} from '@parcel/types';
+import type {Async, Compressor} from '@parcel/types';
 
 import type {RunAPI, StaticRunOpts} from '../RequestTracker';
 import type {Bundle, PackagedBundleInfo, ParcelOptions} from '../types';
@@ -51,7 +51,7 @@ type WriteBundleRequestInput = {|
   hashRefToNameHash: Map<string, string>,
 |};
 
-export type WriteBundleRequestResult = PackagedBundleInfo;
+export type WriteBundleRequestResult = PackagedBundleInfo[];
 
 type RunInput<TResult> = {|
   input: WriteBundleRequestInput,
@@ -61,7 +61,7 @@ type RunInput<TResult> = {|
 export type WriteBundleRequest = {|
   id: ContentKey,
   +type: typeof requestTypes.write_bundle_request,
-  run: (RunInput<PackagedBundleInfo>) => Async<PackagedBundleInfo>,
+  run: (RunInput<PackagedBundleInfo[]>) => Async<PackagedBundleInfo[]>,
   input: WriteBundleRequestInput,
 |};
 
@@ -137,12 +137,6 @@ async function run({input, options, api}) {
       await options.cache.getBlob(cacheKeys.content),
     );
   }
-  let size = 0;
-  contentStream = contentStream.pipe(
-    new TapStream(buf => {
-      size += buf.length;
-    }),
-  );
 
   let configResult = nullthrows(
     await api.runRequest<null, ConfigAndCachePath>(createParcelConfigRequest()),
@@ -152,7 +146,7 @@ async function run({input, options, api}) {
   let {devDeps, invalidDevDeps} = await getDevDepRequests(api);
   invalidateDevDeps(invalidDevDeps, options, config);
 
-  await writeFiles(
+  let files = await writeFiles(
     contentStream,
     info,
     hashRefToNameHash,
@@ -171,7 +165,7 @@ async function run({input, options, api}) {
     !bundle.env.sourceMap.inline &&
     (await options.cache.has(mapKey))
   ) {
-    await writeFiles(
+    let mapFiles = await writeFiles(
       blobToStream(await options.cache.getBlob(mapKey)),
       info,
       hashRefToNameHash,
@@ -183,19 +177,11 @@ async function run({input, options, api}) {
       devDeps,
       api,
     );
+    files.push(...mapFiles);
   }
 
-  let res = {
-    filePath,
-    type: info.type,
-    stats: {
-      size,
-      time: info.time ?? 0,
-    },
-  };
-
-  api.storeResult(res);
-  return res;
+  api.storeResult(files);
+  return files;
 }
 
 async function writeFiles(
@@ -208,12 +194,11 @@ async function writeFiles(
   filePath: ProjectPath,
   writeOptions: ?FileOptions,
   devDeps: Map<string, string>,
-  api: RunAPI<PackagedBundleInfo>,
-) {
+  api: RunAPI<PackagedBundleInfo[]>,
+): Promise<PackagedBundleInfo[]> {
   let compressors = await config.getCompressors(
     fromProjectPathRelative(filePath),
   );
-  let fullPath = fromProjectPath(options.projectRoot, filePath);
 
   let stream = info.hashReferences.length
     ? inputStream.pipe(replaceStream(hashRefToNameHash))
@@ -224,10 +209,11 @@ async function writeFiles(
     promises.push(
       runCompressor(
         compressor,
+        info,
         cloneStream(stream),
         options,
         outputFS,
-        fullPath,
+        filePath,
         writeOptions,
         devDeps,
         api,
@@ -235,25 +221,27 @@ async function writeFiles(
     );
   }
 
-  await Promise.all(promises);
+  let results = await Promise.all(promises);
+  return results.filter(Boolean);
 }
 
 async function runCompressor(
   compressor: LoadedPlugin<Compressor>,
+  info: BundleInfo,
   stream: stream$Readable,
   options: ParcelOptions,
   outputFS: FileSystem,
-  filePath: FilePath,
+  inputFilePath: ProjectPath,
   writeOptions: ?FileOptions,
   devDeps: Map<string, string>,
-  api: RunAPI<PackagedBundleInfo>,
-) {
+  api: RunAPI<PackagedBundleInfo[]>,
+): Promise<PackagedBundleInfo | null> {
   let measurement;
   try {
     measurement = tracer.createMeasurement(
       compressor.name,
       'compress',
-      path.relative(options.projectRoot, filePath),
+      fromProjectPathRelative(inputFilePath),
     );
     let res = await compressor.plugin.compress({
       stream,
@@ -262,21 +250,45 @@ async function runCompressor(
       tracer: new PluginTracer({origin: compressor.name, category: 'compress'}),
     });
 
+    let filePath = inputFilePath;
     if (res != null) {
+      if (res.type != null) {
+        let type = res.type;
+        filePath = toProjectPathUnsafe(
+          fromProjectPathRelative(filePath) + '.' + type,
+        );
+      }
+
+      let size = 0;
+      let stream = res.stream.pipe(
+        new TapStream(buf => {
+          size += buf.length;
+        }),
+      );
+
+      let fullPath = fromProjectPath(options.projectRoot, filePath);
       await new Promise((resolve, reject) =>
         pipeline(
-          res.stream,
-          outputFS.createWriteStream(
-            filePath + (res.type != null ? '.' + res.type : ''),
-            writeOptions,
-          ),
+          stream,
+          outputFS.createWriteStream(fullPath, writeOptions),
           err => {
             if (err) reject(err);
             else resolve();
           },
         ),
       );
+
+      return {
+        filePath,
+        type: info.type,
+        stats: {
+          size,
+          time: info.time ?? 0,
+        },
+      };
     }
+
+    return null;
   } catch (err) {
     throw new ThrowableDiagnostic({
       diagnostic: errorToDiagnostic(err, {
diff --git a/packages/core/core/src/requests/WriteBundlesRequest.js b/packages/core/core/src/requests/WriteBundlesRequest.js
index 8a50b04e349..2da496e4a84 100644
--- a/packages/core/core/src/requests/WriteBundlesRequest.js
+++ b/packages/core/core/src/requests/WriteBundlesRequest.js
@@ -21,7 +21,7 @@ type WriteBundlesRequestInput = {|
   optionsRef: SharedReference,
 |};
 
-export type WriteBundlesRequestResult = Map<string, PackagedBundleInfo>;
+export type WriteBundlesRequestResult = Map<string, PackagedBundleInfo[]>;
 
 type RunInput<TResult> = {|
   input: WriteBundlesRequestInput,
@@ -59,9 +59,9 @@ async function run({input, api, farm, options}) {
 
   let res = new Map();
   let bundleInfoMap: {|
-    [string]: BundleInfo,
+    [string]: BundleInfo[],
   |} = {};
-  let writeEarlyPromises = {};
+  let writeEarlyPromises: {[string]: Promise<PackagedBundleInfo[]>} = {};
   let hashRefToNameHash = new Map();
   let bundles = bundleGraph.getBundles().filter(bundle => {
     // Do not package and write placeholder bundles to disk. We just
@@ -73,14 +73,16 @@ async function run({input, api, farm, options}) {
         bundle.name,
         `Expected ${bundle.type} bundle to have a name`,
       ).replace(bundle.hashReference, hash);
-      res.set(bundle.id, {
-        filePath: joinProjectPath(bundle.target.distDir, name),
-        type: bundle.type, // FIXME: this is wrong if the packager changes the type...
-        stats: {
-          time: 0,
-          size: 0,
+      res.set(bundle.id, [
+        {
+          filePath: joinProjectPath(bundle.target.distDir, name),
+          type: bundle.type, // FIXME: this is wrong if the packager changes the type...
+          stats: {
+            time: 0,
+            size: 0,
+          },
         },
-      });
+      ]);
       return false;
     }
 
@@ -105,7 +107,7 @@ async function run({input, api, farm, options}) {
           useMainThread,
         });
 
-        let info = await api.runRequest(request);
+        let infos = await api.runRequest(request);
 
         if (!useMainThread) {
           // Force a refresh of the cache to avoid a race condition
@@ -119,42 +121,51 @@ async function run({input, api, farm, options}) {
           options.cache.refresh();
         }
 
-        bundleInfoMap[bundle.id] = info;
-        if (!info.hashReferences.length) {
+        bundleInfoMap[bundle.id] = infos;
+        if (infos.every(info => info.hashReferences.length === 0)) {
           hashRefToNameHash.set(
             bundle.hashReference,
             options.shouldContentHash
-              ? info.hash.slice(-8)
+              ? infos.length === 1
+                ? infos[0].hash.slice(-8)
+                : hashString(infos.map(i => i.hash).join(':')).slice(-8)
               : bundle.id.slice(-8),
           );
-          let writeBundleRequest = createWriteBundleRequest({
-            bundle,
-            info,
-            hashRefToNameHash,
-            bundleGraph,
-          });
-          let promise = api.runRequest(writeBundleRequest);
-          // If the promise rejects before we await it (below), we don't want to crash the build.
-          promise.catch(() => {});
-          writeEarlyPromises[bundle.id] = promise;
+          for (let info of infos) {
+            let writeBundleRequest = createWriteBundleRequest({
+              bundle,
+              info,
+              hashRefToNameHash,
+              bundleGraph,
+            });
+            let promise = api.runRequest(writeBundleRequest);
+            // If the promise rejects before we await it (below), we don't want to crash the build.
+            promise.catch(() => {});
+            writeEarlyPromises[info.cacheKeys.content] = promise;
+          }
         }
       }),
     );
     assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
     await Promise.all(
       bundles.map(bundle => {
-        let promise =
-          writeEarlyPromises[bundle.id] ??
-          api.runRequest(
-            createWriteBundleRequest({
-              bundle,
-              info: bundleInfoMap[bundle.id],
-              hashRefToNameHash,
-              bundleGraph,
-            }),
-          );
-
-        return promise.then(r => res.set(bundle.id, r));
+        let promise = Promise.all(
+          bundleInfoMap[bundle.id].map(info => {
+            return (
+              writeEarlyPromises[info.cacheKeys.content] ??
+              api.runRequest(
+                createWriteBundleRequest({
+                  bundle,
+                  info,
+                  hashRefToNameHash,
+                  bundleGraph,
+                }),
+              )
+            );
+          }),
+        );
+
+        return promise.then(r => res.set(bundle.id, r.flat()));
       }),
     );
 
@@ -180,7 +191,7 @@ function assignComplexNameHashes(
       options.shouldContentHash
         ? hashString(
             [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-              .map(bundleId => bundleInfoMap[bundleId].hash)
+              .flatMap(bundleId => bundleInfoMap[bundleId].map(i => i.hash))
               .join(':'),
           ).slice(-8)
         : bundle.id.slice(-8),
@@ -194,10 +205,12 @@ function getBundlesIncludedInHash(
   included = new Set(),
 ) {
   included.add(bundleId);
-  for (let hashRef of bundleInfoMap[bundleId].hashReferences) {
-    let referencedId = getIdFromHashRef(hashRef);
-    if (!included.has(referencedId)) {
-      getBundlesIncludedInHash(referencedId, bundleInfoMap, included);
+  for (let info of bundleInfoMap[bundleId]) {
+    for (let hashRef of info.hashReferences) {
+      let referencedId = getIdFromHashRef(hashRef);
+      if (!included.has(referencedId)) {
+        getBundlesIncludedInHash(referencedId, bundleInfoMap, included);
+      }
     }
   }
 
diff --git a/packages/core/integration-tests/test/react-server.js b/packages/core/integration-tests/test/react-server.js
index b27193f4637..eeb73b119c5 100644
--- a/packages/core/integration-tests/test/react-server.js
+++ b/packages/core/integration-tests/test/react-server.js
@@ -43,14 +43,6 @@ describe('react server components', function () {
             }),
           );
 
-          await overlayFS.writeFile(
-            path.join(dir, '.parcelrc'),
-            JSON.stringify({
-              extends: '@parcel/config-default',
-              runtimes: ['@parcel/runtime-rsc', '...'],
-            }),
-          );
-
           await overlayFS.writeFile(path.join(dir, 'yarn.lock'), '');
         });
 
diff --git a/packages/core/integration-tests/test/react-ssg.js b/packages/core/integration-tests/test/react-ssg.js
new file mode 100644
index 00000000000..95e1bea1815
--- /dev/null
+++ b/packages/core/integration-tests/test/react-ssg.js
@@ -0,0 +1,193 @@
+// @flow
+import assert from 'assert';
+import path from 'path';
+import {bundle, overlayFS, fsFixture, assertBundles} from '@parcel/test-utils';
+
+describe('react static', function () {
+  let count = 0;
+  let dir;
+  beforeEach(async () => {
+    dir = path.join(__dirname, 'react-static', '' + ++count);
+    await overlayFS.mkdirp(dir);
+    await overlayFS.writeFile(
+      path.join(dir, 'package.json'),
+      JSON.stringify({
+        name: 'react-static-test',
+        dependencies: {
+          react: '^19',
+        },
+        targets: {
+          default: {
+            context: 'react-server',
+            scopeHoist: false,
+          },
+        },
+      }),
+    );
+
+    await overlayFS.writeFile(
+      path.join(dir, '.parcelrc'),
+      JSON.stringify({
+        extends: '@parcel/config-react-static',
+      }),
+    );
+
+    await overlayFS.writeFile(path.join(dir, 'yarn.lock'), '');
+  });
+
+  after(async () => {
+    await overlayFS.rimraf(path.join(__dirname, 'react-static'));
+  });
+
+  it('should render to HTML', async function () {
+    await fsFixture(overlayFS, dir)`
+    index.jsx:
+      import {Client} from './client';
+      import {Resources} from "@parcel/runtime-rsc";
+      import './bootstrap';
+
+      export default function Index() {
+        return (
+          <html>
+            <head>
+              <title>Static RSC</title>
+              <Resources />
+            </head>
+            <body>
+              <h1>This is an RSC!</h1>
+              <Client />
+            </body>
+          </html>
+        );
+      }
+
+    client.jsx:
+      "use client";
+      export function Client() {
+        return <p>Client</p>;
+      }
+
+    bootstrap.js:
+      "use client-entry";
+    `;
+
+    let b = await bundle(path.join(dir, '/index.jsx'), {
+      inputFS: overlayFS,
+      targets: ['default'],
+      mode: 'production',
+      env: {
+        NODE_ENV: 'production',
+      },
+    });
+
+    assertBundles(
+      b,
+      [
+        {
+          name: 'index.html',
+          assets: ['index.jsx', 'resources.js'],
+        },
+        {
+          assets: ['client.jsx', 'bootstrap.js'],
+        },
+      ],
+      {skipNodeModules: true},
+    );
+
+    let files = b.getBundles()[0].files;
+    assert.equal(files.length, 2);
+    assert.equal(path.basename(files[0].filePath), 'index.html');
+    assert.equal(path.basename(files[1].filePath), 'index.rsc');
+
+    let output = await overlayFS.readFile(files[0].filePath, 'utf8');
+    assert(output.includes('<h1>This is an RSC!</h1><p>Client</p>'));
+    assert(output.includes('<script type="module">import '));
+
+    let rsc = await overlayFS.readFile(files[1].filePath, 'utf8');
+    assert(rsc.includes('{"children":"This is an RSC!"}'));
+  });
+
+  it('should render a list of pages', async function () {
+    await fsFixture(overlayFS, dir)`
+    index.jsx:
+      import {Nav} from './Nav';
+      export default function Index(props) {
+        return (
+          <html>
+            <body>
+              <h1>Home</h1>
+              <Nav {...props} />
+            </body>
+          </html>
+        );
+      }
+
+    other.jsx:
+      import {Nav} from './Nav';
+      export default function Other(props) {
+        return (
+          <html>
+            <body>
+              <h1>Other</h1>
+              <Nav {...props} />
+            </body>
+          </html>
+        );
+      }
+
+    Nav.jsx:
+      export function Nav({pages, currentPage}) {
+        return (
+          <nav>
+            <ul>
+              {pages.map(page => (
+                <li key={page.url}>
+                  <a href={page.url} aria-current={page.url === currentPage.url ? 'page' : undefined}>
+                    {page.name.replace('.html', '')}
+                  </a>
+                </li>
+              ))}
+            </ul>
+          </nav>
+        );
+      }
+    `;
+
+    let b = await bundle(
+      [path.join(dir, '/index.jsx'), path.join(dir, '/other.jsx')],
+      {
+        inputFS: overlayFS,
+        targets: ['default'],
+      },
+    );
+
+    assertBundles(
+      b,
+      [
+        {
+          name: 'index.html',
+          assets: ['index.jsx', 'Nav.jsx'],
+        },
+        {
+          name: 'other.html',
+          assets: ['other.jsx', 'Nav.jsx'],
+        },
+      ],
+      {skipNodeModules: true},
+    );
+
+    let output = await overlayFS.readFile(b.getBundles()[0].filePath, 'utf8');
+    assert(
+      output.includes(
+        '<h1>Home</h1><nav><ul><li><a href="/index.html" aria-current="page">index</a></li><li><a href="/other.html">other</a></li></ul></nav>',
+      ),
+    );
+
+    output = await overlayFS.readFile(b.getBundles()[1].filePath, 'utf8');
+    assert(
+      output.includes(
+        '<h1>Other</h1><nav><ul><li><a href="/index.html">index</a></li><li><a href="/other.html" aria-current="page">other</a></li></ul></nav>',
+      ),
+    );
+  });
+});
diff --git a/packages/core/package-manager/src/NodePackageManager.js b/packages/core/package-manager/src/NodePackageManager.js
index 1efcebf57e1..0d7562292b5 100644
--- a/packages/core/package-manager/src/NodePackageManager.js
+++ b/packages/core/package-manager/src/NodePackageManager.js
@@ -36,6 +36,8 @@ import {transformSync} from '@swc/core';
 // Package.json fields. Must match package_json.rs.
 const MAIN = 1 << 0;
 const SOURCE = 1 << 2;
+const NODE_CONDITION = 1 << 3;
+const SOURCE_CONDITION = 1 << 17;
 const ENTRIES =
   MAIN |
   (process.env.PARCEL_BUILD_ENV !== 'production' ||
@@ -43,6 +45,11 @@ const ENTRIES =
     ? SOURCE
     : 0);
 
+const CONDITIONS =
+  process.env.PARCEL_BUILD_ENV !== 'production' || process.env.PARCEL_SELF_BUILD
+    ? NODE_CONDITION | SOURCE_CONDITION
+    : NODE_CONDITION;
+
 const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
 
 const IS_FILE = 1 << 0;
@@ -111,6 +118,7 @@ export class NodePackageManager implements PackageManager {
             },
       mode: 2,
       entries: ENTRIES,
+      conditions: CONDITIONS,
       packageExports: true,
       moduleDirResolver:
         process.versions.pnp != null
diff --git a/packages/core/types-internal/src/index.js b/packages/core/types-internal/src/index.js
index b0329f89a9e..cfb82d6a8fa 100644
--- a/packages/core/types-internal/src/index.js
+++ b/packages/core/types-internal/src/index.js
@@ -1448,6 +1448,15 @@ export interface PackagedBundle extends NamedBundle {
   +filePath: FilePath;
   /** Statistics about the bundle. */
   +stats: Stats;
+  /** A list of all of the files written for this bundle. */
+  +files: Array<PackagedBundleFile>;
+}
+
+export interface PackagedBundleFile {
+  /** The absolute file path of the written file, including the final content hash if any. */
+  +filePath: FilePath;
+  /** Statistics about the file. */
+  +stats: Stats;
 }
 
 /**
@@ -1781,7 +1790,7 @@ export type Packager<ConfigType, BundleConfigType> = {|
       BundleGraph<NamedBundle>,
     ) => Async<{|contents: Blob|}>,
     getSourceMapReference: (map: ?SourceMap) => Async<?string>,
-  |}): Async<BundleResult>,
+  |}): Async<BundleResult | BundleResult[]>,
 |};
 
 /**
diff --git a/packages/dev/babel-register/babel-plugin-module-translate.js b/packages/dev/babel-register/babel-plugin-module-translate.js
index df5da1e1e59..c4b9d18db36 100644
--- a/packages/dev/babel-register/babel-plugin-module-translate.js
+++ b/packages/dev/babel-register/babel-plugin-module-translate.js
@@ -9,6 +9,9 @@ function resolveSource(specifier, from) {
         if (pkg.source) {
           pkg.main = pkg.source;
         }
+        if (pkg.exports?.source) {
+          pkg.main = pkg.exports.source;
+        }
       }
       return pkg;
     },
diff --git a/packages/dev/query/src/cli.js b/packages/dev/query/src/cli.js
index be15625fb87..faa4f50fded 100644
--- a/packages/dev/query/src/cli.js
+++ b/packages/dev/query/src/cli.js
@@ -81,7 +81,9 @@ export async function run(input: string[]) {
       return;
     }
     invariant(bundleInfo != null);
-    return fromProjectPathRelative(nullthrows(bundleInfo.get(id)?.filePath));
+    return fromProjectPathRelative(
+      nullthrows(bundleInfo.get(id)?.[0].filePath),
+    );
   }
 
   function parseAssetLocator(v: string) {
diff --git a/packages/dev/query/src/index.js b/packages/dev/query/src/index.js
index 61065989a0c..590e8ded9bd 100644
--- a/packages/dev/query/src/index.js
+++ b/packages/dev/query/src/index.js
@@ -24,7 +24,7 @@ export async function loadGraphs(cacheDir: string): Promise<{|
   assetGraph: ?AssetGraph,
   bundleGraph: ?BundleGraph,
   requestTracker: ?RequestTracker,
-  bundleInfo: ?Map<ContentKey, PackagedBundleInfo>,
+  bundleInfo: ?Map<ContentKey, PackagedBundleInfo[]>,
   cacheInfo: ?Map<string, Array<string | number>>,
 |}> {
   function getMostRecentCacheBlobs() {
@@ -164,7 +164,7 @@ export async function loadGraphs(cacheDir: string): Promise<{|
       // $FlowFixMe[incompatible-cast]
       bundleInfo = (nullthrows(writeBundlesRequest.result): Map<
         ContentKey,
-        PackagedBundleInfo,
+        PackagedBundleInfo[],
       >);
     }
   } catch (e) {
diff --git a/packages/examples/react-server-components/.parcelrc b/packages/examples/react-server-components/.parcelrc
deleted file mode 100644
index 972851df59b..00000000000
--- a/packages/examples/react-server-components/.parcelrc
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@parcel/config-default",
-  "runtimes": ["@parcel/runtime-rsc", "..."]
-}
diff --git a/packages/examples/react-static/.parcelrc b/packages/examples/react-static/.parcelrc
new file mode 100644
index 00000000000..65b0a28ce99
--- /dev/null
+++ b/packages/examples/react-static/.parcelrc
@@ -0,0 +1,3 @@
+{
+  "extends": "@parcel/config-react-static"
+}
diff --git a/packages/examples/react-static/components/Counter.tsx b/packages/examples/react-static/components/Counter.tsx
new file mode 100644
index 00000000000..bcae16a0148
--- /dev/null
+++ b/packages/examples/react-static/components/Counter.tsx
@@ -0,0 +1,8 @@
+"use client";
+
+import { useState } from "react";
+
+export function Counter() {
+  let [count, setCount] = useState(0);
+  return <button onClick={() => setCount(count + 1)}>Count: {count}</button>;
+}
diff --git a/packages/examples/react-static/components/Nav.tsx b/packages/examples/react-static/components/Nav.tsx
new file mode 100644
index 00000000000..1c351d48ffe
--- /dev/null
+++ b/packages/examples/react-static/components/Nav.tsx
@@ -0,0 +1,17 @@
+import type { PageProps } from "../types";
+
+export function Nav({pages, currentPage}: PageProps) {
+  return (
+    <nav>
+      <ul>
+        {pages.map(page => (
+          <li key={page.url}>
+            <a href={page.url} aria-current={page.url === currentPage.url ? 'page' : undefined}>
+              {page.name.replace('.html', '')}
+            </a>
+          </li>
+        ))}
+      </ul>
+    </nav>
+  );
+}
diff --git a/packages/examples/react-static/components/client.tsx b/packages/examples/react-static/components/client.tsx
new file mode 100644
index 00000000000..b084d089203
--- /dev/null
+++ b/packages/examples/react-static/components/client.tsx
@@ -0,0 +1,73 @@
+"use client-entry";
+
+import {useState, use, startTransition, useInsertionEffect, ReactElement} from 'react';
+import ReactDOM from 'react-dom/client';
+import {createFromReadableStream, createFromFetch} from 'react-server-dom-parcel/client';
+import {rscStream} from 'rsc-html-stream/client';
+
+// Stream in initial RSC payload embedded in the HTML.
+let initialRSCPayload = createFromReadableStream<ReactElement>(rscStream);
+let updateRoot: ((root: ReactElement, cb?: (() => void) | null) => void) | null = null;
+
+function Content() {
+  // Store the current root element in state, along with a callback
+  // to call once rendering is complete.
+  let [[root, cb], setRoot] = useState<[ReactElement, (() => void) | null]>([use(initialRSCPayload), null]);
+  updateRoot = (root, cb) => setRoot([root, cb ?? null]);
+  useInsertionEffect(() => cb?.());
+  return root;
+}
+
+// Hydrate initial page content.
+startTransition(() => {
+  ReactDOM.hydrateRoot(document, <Content />);
+});
+
+// A very simple router. When we navigate, we'll fetch a new RSC payload from the server,
+// and in a React transition, stream in the new page. Once complete, we'll pushState to 
+// update the URL in the browser.
+async function navigate(pathname: string, push = false) {
+  let res = fetch(pathname.replace(/\.html$/, '.rsc'));
+  let root = await createFromFetch<ReactElement>(res);
+  startTransition(() => {
+    updateRoot!(root, () => {
+      if (push) {
+        history.pushState(null, '', pathname);
+        push = false;
+      }
+    });
+  });
+}
+
+// Intercept link clicks to perform RSC navigation.
+document.addEventListener('click', e => {
+  let link = (e.target as Element).closest('a');
+  if (
+    link &&
+    link instanceof HTMLAnchorElement &&
+    link.href &&
+    (!link.target || link.target === '_self') &&
+    link.origin === location.origin &&
+    !link.hasAttribute('download') &&
+    e.button === 0 && // left clicks only
+    !e.metaKey && // open in new tab (mac)
+    !e.ctrlKey && // open in new tab (windows)
+    !e.altKey && // download
+    !e.shiftKey &&
+    !e.defaultPrevented
+  ) {
+    e.preventDefault();
+    navigate(link.pathname, true);
+  }
+});
+
+// When the user clicks the back button, navigate with RSC.
+window.addEventListener('popstate', e => {
+  navigate(location.pathname);
+});
+
+// Intercept HMR window reloads, and do it with RSC instead.
+window.addEventListener('parcelhmrreload', e => {
+  e.preventDefault();
+  navigate(location.pathname);
+});
diff --git a/packages/examples/react-static/components/style.css b/packages/examples/react-static/components/style.css
new file mode 100644
index 00000000000..4dc2d9f5f51
--- /dev/null
+++ b/packages/examples/react-static/components/style.css
@@ -0,0 +1,8 @@
+h1 {
+  font-family: system-ui;
+}
+
+nav a[aria-current] {
+  background: black;
+  color: white
+}
diff --git a/packages/examples/react-static/package.json b/packages/examples/react-static/package.json
new file mode 100644
index 00000000000..6c4005dd1c0
--- /dev/null
+++ b/packages/examples/react-static/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "parcel-rsc-static-example",
+  "version": "0.0.0",
+  "private": true,
+  "source": "pages/*.tsx",
+  "targets": {
+    "default": {
+      "context": "react-server",
+      "scopeHoist": false
+    }
+  },
+  "scripts": {
+    "start": "parcel --config .parcelrc",
+    "build": "parcel build"
+  },
+  "dependencies": {
+    "react": "^19",
+    "react-dom": "^19",
+    "react-server-dom-parcel": "^0.0.1",
+    "rsc-html-stream": "^0.0.4"
+  }
+}
diff --git a/packages/examples/react-static/pages/Index.tsx b/packages/examples/react-static/pages/Index.tsx
new file mode 100644
index 00000000000..99585b27f6a
--- /dev/null
+++ b/packages/examples/react-static/pages/Index.tsx
@@ -0,0 +1,22 @@
+import type { PageProps } from "../types";
+import { Resources } from "@parcel/runtime-rsc";
+import { Counter } from "../components/Counter";
+import { Nav } from '../components/Nav';
+import '../components/style.css';
+import '../components/client';
+
+export default function Index({pages, currentPage}: PageProps) {
+  return (
+    <html>
+      <head>
+        <title>Static RSC</title>
+        <Resources />
+      </head>
+      <body>
+        <h1>This is an RSC!</h1>
+        <Nav pages={pages} currentPage={currentPage} />
+        <Counter />
+      </body>
+    </html>
+  );
+}
diff --git a/packages/examples/react-static/pages/Other.tsx b/packages/examples/react-static/pages/Other.tsx
new file mode 100644
index 00000000000..b60dcd62efa
--- /dev/null
+++ b/packages/examples/react-static/pages/Other.tsx
@@ -0,0 +1,20 @@
+import type { PageProps } from "../types";
+import { Resources } from "@parcel/runtime-rsc";
+import {Nav} from '../components/Nav';
+import '../components/style.css';
+import '../components/client';
+
+export default function Index({pages, currentPage}: PageProps) {
+  return (
+    <html>
+      <head>
+        <title>Static RSC</title>
+        <Resources />
+      </head>
+      <body>
+        <h1>This is another RSC!</h1>
+        <Nav pages={pages} currentPage={currentPage} />
+      </body>
+    </html>
+  );
+}
diff --git a/packages/examples/react-static/yarn.lock b/packages/examples/react-static/yarn.lock
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/packages/namers/static/package.json b/packages/namers/static/package.json
new file mode 100644
index 00000000000..5b8833c35ff
--- /dev/null
+++ b/packages/namers/static/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "@parcel/namer-static",
+  "version": "2.13.3",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/parcel.git"
+  },
+  "main": "lib/StaticNamer.js",
+  "source": "src/StaticNamer.js",
+  "engines": {
+    "node": ">= 16.0.0",
+    "parcel": "^2.13.3"
+  },
+  "dependencies": {
+    "@parcel/diagnostic": "2.13.3",
+    "@parcel/plugin": "2.13.3",
+    "nullthrows": "^1.1.1"
+  }
+}
diff --git a/packages/namers/static/src/StaticNamer.js b/packages/namers/static/src/StaticNamer.js
new file mode 100644
index 00000000000..6e0ae0367e9
--- /dev/null
+++ b/packages/namers/static/src/StaticNamer.js
@@ -0,0 +1,19 @@
+import {Namer} from '@parcel/plugin';
+import path from 'path';
+
+export default new Namer({
+  name({bundle, bundleGraph}) {
+    let bundleGroup = bundleGraph.getBundleGroupsContainingBundle(bundle)[0];
+    let isEntry = bundleGraph.isEntryBundleGroup(bundleGroup);
+    let main = bundle.getMainEntry();
+    if (isEntry && main) {
+      // Rename entry bundles to use the HTML extension, which will be true after they are executed during the build.
+      let entryRoot = bundleGraph.getEntryRoot(bundle.target);
+      let name =
+        path.basename(main.filePath, path.extname(main.filePath)) + '.html';
+      return path
+        .join(path.relative(entryRoot, path.dirname(main.filePath)), name)
+        .replace(/\.\.(\/|\\)/g, 'up_$1');
+    }
+  },
+});
diff --git a/packages/optimizers/htmlnano/src/HTMLNanoOptimizer.js b/packages/optimizers/htmlnano/src/HTMLNanoOptimizer.js
index ba31322ad29..971f56fe46b 100644
--- a/packages/optimizers/htmlnano/src/HTMLNanoOptimizer.js
+++ b/packages/optimizers/htmlnano/src/HTMLNanoOptimizer.js
@@ -8,7 +8,7 @@ import {
   errorToDiagnostic,
 } from '@parcel/diagnostic';
 import {Optimizer} from '@parcel/plugin';
-import {detectSVGOVersion} from '@parcel/utils';
+import {detectSVGOVersion, blobToString} from '@parcel/utils';
 import posthtml from 'posthtml';
 import path from 'path';
 import {SVG_ATTRS, SVG_TAG_NAMES} from './svgMappings';
@@ -102,12 +102,7 @@ export default (new Optimizer({
       return {contents, map};
     }
 
-    if (typeof contents !== 'string') {
-      throw new Error(
-        'HTMLNanoOptimizer: Only string contents are currently supported',
-      );
-    }
-
+    let code = await blobToString(contents);
     const clonedConfig = config.contents || {};
 
     // $FlowFixMe
@@ -150,7 +145,7 @@ export default (new Optimizer({
 
     return {
       contents: (
-        await posthtml(plugins).process(contents, {
+        await posthtml(plugins).process(code, {
           xmlMode: bundle.type === 'xhtml',
           closingSingleTag: bundle.type === 'xhtml' ? 'slash' : undefined,
         })
diff --git a/packages/packagers/react-static/package.json b/packages/packagers/react-static/package.json
new file mode 100644
index 00000000000..d0b477a7072
--- /dev/null
+++ b/packages/packagers/react-static/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "@parcel/packager-react-static",
+  "version": "2.13.3",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/parcel.git"
+  },
+  "main": "lib/ReactStaticPackager.js",
+  "source": "src/ReactStaticPackager.js",
+  "engines": {
+    "node": ">= 16.0.0",
+    "parcel": "^2.13.3"
+  },
+  "dependencies": {
+    "@parcel/node-resolver-core": "3.4.3",
+    "@parcel/plugin": "2.13.3",
+    "@parcel/types": "2.13.3",
+    "@parcel/utils": "2.13.3",
+    "rsc-html-stream": "^0.0.4",
+    "nullthrows": "^1.1.1"
+  }
+}
diff --git a/packages/packagers/react-static/src/ReactStaticPackager.js b/packages/packagers/react-static/src/ReactStaticPackager.js
new file mode 100644
index 00000000000..9155b4a926b
--- /dev/null
+++ b/packages/packagers/react-static/src/ReactStaticPackager.js
@@ -0,0 +1,407 @@
+// @flow
+import type {
+  Asset,
+  Async,
+  Blob,
+  BundleGraph,
+  Dependency,
+  NamedBundle,
+  Meta,
+  JSONObject,
+} from '@parcel/types';
+import {blobToString, PromiseQueue, urlJoin} from '@parcel/utils';
+import fs from 'fs';
+import Module from 'module';
+import {Packager} from '@parcel/plugin';
+import path from 'path';
+import {ResolverBase} from '@parcel/node-resolver-core';
+import vm from 'vm';
+import nullthrows from 'nullthrows';
+import {Readable} from 'stream';
+
+export interface Page {
+  url: string;
+  name: string;
+  meta: any;
+}
+
+export interface PageProps {
+  pages: Page[];
+  currentPage: Page;
+}
+
+interface ParcelModule {
+  exports: any;
+  children: ParcelModule[];
+  filename: string;
+  id: string;
+  path: string;
+}
+
+let clientResolver: ResolverBase;
+let serverResolver: ResolverBase;
+let packagingBundles = new Map<NamedBundle, Async<{|contents: Blob|}>>();
+let moduleCache = new Map<string, ParcelModule>();
+let loadedBundles = new Map<NamedBundle, any>();
+
+export default (new Packager({
+  loadConfig({options, config}) {
+    config.invalidateOnBuild();
+    packagingBundles.clear();
+    moduleCache.clear();
+    loadedBundles.clear();
+    clientResolver = new ResolverBase(options.projectRoot, {
+      mode: 2,
+      packageExports: true,
+    });
+
+    serverResolver = new ResolverBase(options.projectRoot, {
+      mode: 2,
+      packageExports: true,
+      conditions: 1 << 16, // "react-server"
+    });
+  },
+  async package({bundle, bundleGraph, getInlineBundleContents}) {
+    if (bundle.env.shouldScopeHoist) {
+      throw new Error('Scope hoisting is not supported with SSG');
+    }
+
+    let {load, loadModule} = await loadBundle(
+      bundle,
+      bundleGraph,
+      getInlineBundleContents,
+    );
+
+    let Component = load(nullthrows(bundle.getMainEntry()).id).default;
+    let {renderToReadableStream} = loadModule(
+      'react-server-dom-parcel/server.edge',
+      __filename,
+      'react-server',
+    );
+    let {prerender} = loadModule(
+      'react-dom/static.edge',
+      __filename,
+      'react-client',
+    );
+    let React = loadModule('react', __filename, 'react-client');
+    let {createFromReadableStream} = loadModule(
+      'react-server-dom-parcel/client.edge',
+      __filename,
+      'react-client',
+    );
+    let {injectRSCPayload} = await import('rsc-html-stream/server');
+
+    let pages: Page[] = [];
+    for (let b of bundleGraph.getEntryBundles()) {
+      let main = b.getMainEntry();
+      if (main && b.type === 'js' && b.needsStableName) {
+        pages.push({
+          url: urlJoin(b.target.publicUrl, b.name),
+          name: b.name,
+          meta: pageMeta(main.meta),
+        });
+      }
+    }
+
+    let props: PageProps = {
+      pages,
+      currentPage: {
+        url: urlJoin(bundle.target.publicUrl, bundle.name),
+        name: bundle.name,
+        meta: pageMeta(nullthrows(bundle.getMainEntry()).meta),
+      },
+    };
+
+    let stream = renderToReadableStream(React.createElement(Component, props));
+    let [s1, renderStream] = stream.tee();
+    let [injectStream, rscStream] = s1.tee();
+    let data = createFromReadableStream(renderStream);
+    function Content() {
+      return React.use(data);
+    }
+
+    let {prelude} = await prerender(React.createElement(Content));
+    let response = prelude.pipeThrough(injectRSCPayload(injectStream));
+
+    return [
+      {
+        type: 'html',
+        contents: Readable.from(response),
+      },
+      {
+        type: 'rsc',
+        contents: Readable.from(rscStream),
+      },
+    ];
+  },
+}): Packager);
+
+function loadBundle(
+  bundle: NamedBundle,
+  bundleGraph: BundleGraph<NamedBundle>,
+  getInlineBundleContents: (
+    bundle: NamedBundle,
+    bundleGraph: BundleGraph<NamedBundle>,
+  ) => Async<{|contents: Blob|}>,
+) {
+  let cached = loadedBundles.get(bundle);
+  if (!cached) {
+    cached = loadBundleUncached(bundle, bundleGraph, getInlineBundleContents);
+    loadedBundles.set(bundle, cached);
+  }
+
+  return cached;
+}
+
+async function loadBundleUncached(
+  bundle: NamedBundle,
+  bundleGraph: BundleGraph<NamedBundle>,
+  getInlineBundleContents: (
+    bundle: NamedBundle,
+    bundleGraph: BundleGraph<NamedBundle>,
+  ) => Async<{|contents: Blob|}>,
+) {
+  // Load all asset contents.
+  let queue = new PromiseQueue({maxConcurrent: 32});
+  bundle.traverse(node => {
+    if (node.type === 'dependency') {
+      let dep = node.value;
+      let entryBundle = bundleGraph.getReferencedBundle(dep, bundle);
+      if (entryBundle?.bundleBehavior === 'inline') {
+        queue.add(async () => {
+          if (!packagingBundles.has(entryBundle)) {
+            packagingBundles.set(
+              entryBundle,
+              getInlineBundleContents(entryBundle, bundleGraph),
+            );
+          }
+
+          let packagedBundle = await nullthrows(
+            packagingBundles.get(entryBundle),
+          );
+          let contents = await blobToString(packagedBundle.contents);
+          contents = `module.exports = ${contents}`;
+          return [
+            entryBundle.id,
+            [nullthrows(entryBundle.getMainEntry()), contents],
+          ];
+        });
+      }
+    } else if (node.type === 'asset') {
+      let asset = node.value;
+      queue.add(async () => [asset.id, [asset, await asset.getCode()]]);
+    }
+  });
+
+  let assets = new Map<string, [Asset, string]>(await queue.run());
+  let assetsByFilePath = new Map<string, string>();
+  let assetsByPublicId = new Map<string, string>();
+  for (let [asset] of assets.values()) {
+    assetsByFilePath.set(getCacheKey(asset), asset.id);
+    assetsByPublicId.set(bundleGraph.getAssetPublicId(asset), asset.id);
+  }
+
+  // Load an asset into the module system by id.
+  let loadAsset = (id: string) => {
+    let [asset, code] = nullthrows(assets.get(id));
+    let cacheKey = getCacheKey(asset);
+    let cachedModule = moduleCache.get(cacheKey);
+    if (cachedModule) {
+      return cachedModule.exports;
+    }
+
+    // Build a mapping of dependencies to their resolved assets.
+    let deps = new Map();
+    for (let dep of bundleGraph.getDependencies(asset)) {
+      if (bundleGraph.isDependencySkipped(dep)) {
+        deps.set(getSpecifier(dep), {skipped: true});
+        continue;
+      }
+
+      let entryBundle = bundleGraph.getReferencedBundle(dep, bundle);
+      if (entryBundle?.bundleBehavior === 'inline') {
+        deps.set(getSpecifier(dep), {id: entryBundle.id});
+        continue;
+      }
+
+      let resolved = bundleGraph.getResolvedAsset(dep, bundle);
+      if (resolved) {
+        if (resolved.type !== 'js') {
+          deps.set(getSpecifier(dep), {skipped: true});
+        } else {
+          deps.set(getSpecifier(dep), {id: resolved.id});
+        }
+      } else {
+        deps.set(getSpecifier(dep), {specifier: dep.specifier});
+      }
+    }
+
+    let defaultRequire = Module.createRequire(asset.filePath);
+    let require = (id: string) => {
+      let resolution = deps.get(id);
+      if (resolution?.skipped) {
+        return {};
+      }
+
+      if (resolution?.id) {
+        return loadAsset(resolution.id);
+      }
+
+      if (resolution?.specifier) {
+        id = resolution.specifier;
+      }
+
+      return defaultRequire(id);
+    };
+
+    // @ts-ignore
+    require.resolve = defaultRequire.resolve;
+
+    return runModule(code, asset.filePath, cacheKey, require, parcelRequire);
+  };
+
+  let parcelRequire = (publicId: string) => {
+    return loadAsset(nullthrows(assetsByPublicId.get(publicId)));
+  };
+
+  // @ts-ignore
+  parcelRequire.meta = {
+    distDir: bundle.target.distDir,
+    publicUrl: bundle.target.publicUrl,
+  };
+
+  // @ts-ignore
+  parcelRequire.load = async (filePath: string) => {
+    let bundle = bundleGraph.getBundles().find(b => b.name === filePath);
+    if (bundle) {
+      let {assets: subAssets} = await loadBundle(
+        bundle,
+        bundleGraph,
+        getInlineBundleContents,
+      );
+      for (let [id, [asset, code]] of subAssets) {
+        if (!assets.has(id)) {
+          assets.set(id, [asset, code]);
+          assetsByFilePath.set(getCacheKey(asset), asset.id);
+          assetsByPublicId.set(bundleGraph.getAssetPublicId(asset), asset.id);
+        }
+      }
+    } else {
+      throw new Error('Bundle not found');
+    }
+  };
+
+  // Resolve and load a module by specifier.
+  let loadModule = (id: string, from: string, env = 'react-client') => {
+    let resolver = env === 'react-server' ? serverResolver : clientResolver;
+    let res = resolver.resolve({
+      filename: id,
+      specifierType: 'commonjs',
+      parent: from,
+    });
+
+    if (res.error) {
+      throw new Error(`Could not resolve module "${id}" from "${from}"`);
+    }
+
+    let defaultRequire = Module.createRequire(from);
+    if (res.resolution.type === 'Builtin') {
+      return defaultRequire(res.resolution.value);
+    }
+
+    if (res.resolution.type === 'Path') {
+      let cacheKey = res.resolution.value + '#' + env;
+      const cachedModule = moduleCache.get(cacheKey);
+      if (cachedModule) {
+        return cachedModule.exports;
+      }
+
+      let assetId = assetsByFilePath.get(cacheKey);
+      if (assetId) {
+        return loadAsset(assetId);
+      }
+
+      let filePath = nullthrows(res.resolution.value);
+      let code = fs.readFileSync(filePath, 'utf8');
+      let require = (id: string) => {
+        return loadModule(id, filePath, env);
+      };
+
+      // @ts-ignore
+      require.resolve = defaultRequire.resolve;
+
+      return runModule(code, filePath, cacheKey, require, parcelRequire);
+    }
+
+    throw new Error('Unknown resolution');
+  };
+
+  return {load: loadAsset, loadModule, assets};
+}
+
+function runModule(
+  code: string,
+  filename: string,
+  id: string,
+  require: (id: string) => any,
+  parcelRequire: (id: string) => any,
+) {
+  let moduleFunction = vm.compileFunction(
+    code,
+    [
+      'exports',
+      'require',
+      'module',
+      '__dirname',
+      '__filename',
+      'parcelRequire',
+    ],
+    {
+      filename,
+    },
+  );
+
+  let dirname = path.dirname(filename);
+  let module = {
+    exports: {},
+    require,
+    children: [],
+    filename,
+    id,
+    path: dirname,
+  };
+
+  moduleCache.set(id, module);
+  moduleFunction(
+    module.exports,
+    require,
+    module,
+    dirname,
+    filename,
+    parcelRequire,
+  );
+  return module.exports;
+}
+
+function getCacheKey(asset: Asset) {
+  return asset.filePath + '#' + asset.env.context;
+}
+
+function getSpecifier(dep: Dependency) {
+  if (typeof dep.meta.placeholder === 'string') {
+    return dep.meta.placeholder;
+  }
+
+  return dep.specifier;
+}
+
+function pageMeta(meta: Meta): JSONObject {
+  if (
+    meta.ssgMeta &&
+    typeof meta?.ssgMeta === 'object' &&
+    !Array.isArray(meta.ssgMeta)
+  ) {
+    return meta.ssgMeta;
+  }
+  return {};
+}
diff --git a/packages/reporters/cli/src/CLIReporter.js b/packages/reporters/cli/src/CLIReporter.js
index 6293b54e0e7..724b9dec109 100644
--- a/packages/reporters/cli/src/CLIReporter.js
+++ b/packages/reporters/cli/src/CLIReporter.js
@@ -111,7 +111,9 @@ export async function _report(
 
       if (
         options.serveOptions &&
-        event.bundleGraph.getEntryBundles().some(b => b.env.isBrowser())
+        event.bundleGraph
+          .getEntryBundles()
+          .some(b => b.env.isBrowser() || b.type === 'html')
       ) {
         persistMessage(
           chalk.blue.bold(
diff --git a/packages/runtimes/rsc/package.json b/packages/runtimes/rsc/package.json
index da47ee4bdc2..dbc589ceae9 100644
--- a/packages/runtimes/rsc/package.json
+++ b/packages/runtimes/rsc/package.json
@@ -13,6 +13,7 @@
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
   },
+  "main": "lib/RSCRuntime.js",
   "exports": {
     ".": {
       "react-server": "./resources.js",
diff --git a/packages/utils/node-resolver-core/src/Wrapper.js b/packages/utils/node-resolver-core/src/Wrapper.js
index a8adfd85af0..da424864cba 100644
--- a/packages/utils/node-resolver-core/src/Wrapper.js
+++ b/packages/utils/node-resolver-core/src/Wrapper.js
@@ -783,8 +783,9 @@ function environmentToExportsConditions(
   const DEVELOPMENT = 1 << 8;
   const PRODUCTION = 1 << 9;
   const REACT_SERVER = 1 << 16;
+  const SOURCE = 1 << 17;
 
-  let conditions = 0;
+  let conditions = SOURCE;
   if (env.isBrowser()) {
     conditions |= BROWSER;
   }