@reckona/mreact-router 0.0.158 → 0.0.160

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reckona/mreact-router",
-  "version": "0.0.158",
+  "version": "0.0.160",
   "description": "File-system app router, SSR, actions, and deployment adapters for mreact.",
   "keywords": [
     "jsx",
@@ -105,20 +105,20 @@
   },
   "dependencies": {
     "typescript": "^6.0.3",
-    "@reckona/mreact": "0.0.158",
-    "@reckona/mreact-compiler": "0.0.158",
-    "@reckona/mreact-compat": "0.0.158",
-    "@reckona/mreact-query": "0.0.158",
-    "@reckona/mreact-devtools": "0.0.158",
-    "@reckona/mreact-reactive-core": "0.0.158",
-    "@reckona/mreact-reactive-dom": "0.0.158",
-    "@reckona/mreact-server": "0.0.158",
-    "@reckona/mreact-shared": "0.0.158"
+    "@reckona/mreact": "0.0.160",
+    "@reckona/mreact-compat": "0.0.160",
+    "@reckona/mreact-devtools": "0.0.160",
+    "@reckona/mreact-query": "0.0.160",
+    "@reckona/mreact-compiler": "0.0.160",
+    "@reckona/mreact-reactive-core": "0.0.160",
+    "@reckona/mreact-reactive-dom": "0.0.160",
+    "@reckona/mreact-server": "0.0.160",
+    "@reckona/mreact-shared": "0.0.160"
   },
   "peerDependencies": {
     "vite": ">=8 <9"
   },
   "optionalDependencies": {
-    "@reckona/mreact-router-native": "0.0.158"
+    "@reckona/mreact-router-native": "0.0.160"
   }
 }

package/src/build.ts

@@ -85,6 +85,7 @@ import {
   bundleRouterModules,
   type RouterCompatPlugin,
   type RouterBundleChunkOutput,
+  type RouterBundleModulesOutput,
   type RouterBundleOutput,
 } from "./bundle-pipeline.js";
 import { collectRouteCssFilesFromSources, collectSpecialBoundaryFiles } from "./route-styles.js";
@@ -485,7 +486,7 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
       .filter(([, references]) => references.length > 0)
       .map(([file]) => file),
   );
-  const serverModules = await (
+  const { artifacts: serverModules, sharedChunks: serverModuleSharedChunks } = await (
     shouldTrackBuildPhases === false
       ? buildServerModuleArtifacts({
           actionRenderBundleExcludedFiles,
@@ -530,12 +531,14 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
           serverDir,
           serverModules,
           generatedImportPolicy.runtimePackages,
+          serverModuleSharedChunks,
         )
       : timeBuildPhase(timingSink, progressSink, "serverModuleArtifacts", () =>
           writeServerModuleArtifactFiles(
             serverDir,
             serverModules,
             generatedImportPolicy.runtimePackages,
+            serverModuleSharedChunks,
           ),
         ),
     shouldTrackBuildPhases === false
@@ -1054,6 +1057,7 @@ async function writeServerModuleArtifactFiles(
   serverDir: string,
   serverModules: Record<string, BuiltServerModuleArtifact>,
   portableRuntimePackages: readonly string[] = [],
+  sharedChunks: readonly SharedServerModuleChunk[] = [],
 ): Promise<{
   files: Record<string, string>;
   renderFiles: Record<string, string>;
@@ -1075,6 +1079,22 @@ async function writeServerModuleArtifactFiles(
     mkdir(join(modulesDir, "render"), { recursive: true }),
   ]);
 
+  if (sharedChunks.length > 0) {
+    // Shared request chunks are referenced from externalized module code via
+    // "./chunks/..." imports, so they live next to server-modules/code files.
+    await mkdir(join(modulesDir, "code", "chunks"), { recursive: true });
+    await Promise.all(
+      sharedChunks.map((chunk) =>
+        writeFile(
+          join(modulesDir, "code", chunk.fileName),
+          rewriteCompatVendorPlaceholderImports(
+            rewritePortableRuntimePackageImports(chunk.code, portableRuntimePackages),
+          ),
+        ),
+      ),
+    );
+  }
+
   const usedCompatVendorEntries = collectCompatVendorEntryUsage(artifactEntries);
 
   if (usedCompatVendorEntries.size > 0) {
@@ -2018,7 +2038,10 @@ async function buildServerModuleArtifacts(options: {
   sourceAnalysis: BuildSourceAnalysisScope;
   serverTransformCache: ServerTransformCache;
   vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<Record<string, BuiltServerModuleArtifact>> {
+}): Promise<{
+  artifacts: Record<string, BuiltServerModuleArtifact>;
+  sharedChunks: readonly SharedServerModuleChunk[];
+}> {
   const routeByFile = new Map(
     options.routes.map((route) => [relative(options.projectRoot, route.file), route]),
   );
@@ -2082,9 +2105,22 @@ async function buildServerModuleArtifacts(options: {
       });
     }
 
+    if (isMiddlewareFile(options.project.routesDir, absoluteFile)) {
+      // Middleware joins the batch when runtime packages are bundled so the
+      // auth/control dependency graph is shared with route loader artifacts.
+      if (options.bundleRequestRuntimePackages) {
+        requestBatchEntries.push({
+          code: source,
+          filename: absoluteFile,
+          key: routeRequestArtifactBatchKey(file, "request"),
+          label: "Middleware",
+        });
+      }
+      continue;
+    }
+
     if (
       requestArtifactFiles.has(file) &&
-      !isMiddlewareFile(options.project.routesDir, absoluteFile) &&
       route?.kind !== "server" &&
       route?.kind !== "metadata"
     ) {
@@ -2097,19 +2133,20 @@ async function buildServerModuleArtifacts(options: {
     }
   }
 
-  const requestBatchOutputs =
-    requestBatchEntries.length >= 3
+  const { codeByKey: requestBatchOutputs, sharedChunks } =
+    requestBatchEntries.length >= (options.bundleRequestRuntimePackages ? 2 : 3)
       ? await bundleRouteRequestModuleBatchCode({
           appDir: options.project.routesDir,
           bundleCache: options.bundleCache,
           cacheDir: options.cacheDir,
+          emitSharedChunks: options.bundleRequestRuntimePackages,
           entries: requestBatchEntries,
           externalizeAllowedPackages: !options.bundleRequestRuntimePackages,
           importPolicy: requestModuleImportPolicy,
           define: options.define,
           vitePlugins: options.vitePlugins,
         })
-      : new Map<string, string>();
+      : { codeByKey: new Map<string, string>(), sharedChunks: [] };
 
   const artifactEntries = await mapWithBuildConcurrency(
     Object.entries(options.files),
@@ -2334,7 +2371,7 @@ async function buildServerModuleArtifacts(options: {
     }
   }
 
-  return artifacts;
+  return { artifacts, sharedChunks };
 }
 
 async function buildServerComponentBundleArtifactCode(options: {
@@ -2563,38 +2600,42 @@ async function bundleRouteRequestModuleBatchCode(options: {
   bundleCache?: Map<string, Promise<RouterBundleOutput>> | undefined;
   cacheDir?: string | undefined;
   define?: UserConfig["define"] | undefined;
+  emitSharedChunks?: boolean | undefined;
   entries: readonly RouteRequestModuleBatchEntry[];
   externalizeAllowedPackages?: boolean | undefined;
   importPolicy?: AppRouterImportPolicy | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<Map<string, string>> {
+}): Promise<RouteRequestModuleBatchOutput> {
   if (options.entries.length === 0) {
-    return new Map();
+    return { codeByKey: new Map(), sharedChunks: [] };
   }
 
   if (options.entries.length === 1) {
     const entry = options.entries[0];
     if (entry === undefined) {
-      return new Map();
+      return { codeByKey: new Map(), sharedChunks: [] };
     }
 
-    return new Map([
-      [
-        entry.key,
-        await bundleRouteRequestModuleCode({
-          appDir: options.appDir,
-          bundleCache: options.bundleCache,
-          cacheDir: options.cacheDir,
-          code: entry.code,
-          define: options.define,
-          externalizeAllowedPackages: options.externalizeAllowedPackages,
-          filename: entry.filename,
-          importPolicy: options.importPolicy,
-          label: entry.label,
-          vitePlugins: options.vitePlugins,
-        }),
-      ],
-    ]);
+    return {
+      codeByKey: new Map([
+        [
+          entry.key,
+          await bundleRouteRequestModuleCode({
+            appDir: options.appDir,
+            bundleCache: options.bundleCache,
+            cacheDir: options.cacheDir,
+            code: entry.code,
+            define: options.define,
+            externalizeAllowedPackages: options.externalizeAllowedPackages,
+            filename: entry.filename,
+            importPolicy: options.importPolicy,
+            label: entry.label,
+            vitePlugins: options.vitePlugins,
+          }),
+        ],
+      ]),
+      sharedChunks: [],
+    };
   }
 
   const namesByKey = new Map(
@@ -2605,13 +2646,15 @@ async function bundleRouteRequestModuleBatchCode(options: {
   );
   const output = await bundleRouterModules({
     cacheDir: options.cacheDir,
-    chunkFileNames: "request/chunks/[name].[hash].js",
+    // Externalized module code lives flat in server-modules/code, so shared
+    // chunks must be importable as "./chunks/..." from any entry file there.
+    chunkFileNames: "chunks/request.[hash].mjs",
     entries: options.entries.map((entry) => ({
       code: entry.code,
       filename: entry.filename,
       name: namesByKey.get(entry.key) ?? hashText(entry.key).slice(0, 8),
     })),
-    entryFileNames: "request/[name].js",
+    entryFileNames: "[name].mjs",
     define: options.define,
     platform: "node",
     plugins: [
@@ -2627,8 +2670,9 @@ async function bundleRouteRequestModuleBatchCode(options: {
       options.importPolicy?.projectRoot ?? dirname(options.entries[0]?.filename ?? options.appDir),
     vitePlugins: options.vitePlugins,
   });
+  const sharedChunks = output.chunks.filter((chunk) => !chunk.isEntry);
 
-  if (output.chunks.some((chunk) => !chunk.isEntry)) {
+  if (sharedChunks.length > 0 && !canEmitSharedRequestChunks(options.emitSharedChunks, output)) {
     const fallbackEntries = await mapWithBuildConcurrency(
       options.entries,
       async (entry) =>
@@ -2648,21 +2692,46 @@ async function bundleRouteRequestModuleBatchCode(options: {
           }),
         ] as const,
     );
-    return new Map(fallbackEntries);
+    return { codeByKey: new Map(fallbackEntries), sharedChunks: [] };
   }
 
   const chunksByName = new Map(output.chunks.map((chunk) => [chunk.name, chunk]));
-  return new Map(
-    options.entries.map((entry) => {
-      const name = namesByKey.get(entry.key);
-      const chunk = name === undefined ? undefined : chunksByName.get(name);
+  return {
+    codeByKey: new Map(
+      options.entries.map((entry) => {
+        const name = namesByKey.get(entry.key);
+        const chunk = name === undefined ? undefined : chunksByName.get(name);
 
-      if (chunk === undefined) {
-        throw new Error(`Failed to compile request artifact for ${entry.filename}.`);
-      }
+        if (chunk === undefined) {
+          throw new Error(`Failed to compile request artifact for ${entry.filename}.`);
+        }
 
-      return [entry.key, chunk.code] as const;
-    }),
+        return [entry.key, chunk.code] as const;
+      }),
+    ),
+    sharedChunks: sharedChunks.map((chunk) => ({ code: chunk.code, fileName: chunk.fileName })),
+  };
+}
+
+function canEmitSharedRequestChunks(
+  emitSharedChunks: boolean | undefined,
+  output: RouterBundleModulesOutput,
+): boolean {
+  if (emitSharedChunks !== true) {
+    return false;
+  }
+
+  if (output.assets !== undefined && output.assets.length > 0) {
+    return false;
+  }
+
+  // Entry code is rewritten into content-addressed module files, so emitted
+  // imports may only target shared chunk files or external specifiers.
+  const entryFileNames = new Set(
+    output.chunks.filter((chunk) => chunk.isEntry).map((chunk) => chunk.fileName),
+  );
+  return output.chunks.every((chunk) =>
+    chunk.imports.every((specifier) => !entryFileNames.has(specifier)),
   );
 }
 
@@ -2676,15 +2745,17 @@ export async function __bundleRouteRequestModuleBatchForTests(options: {
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<Record<string, string>> {
   return Object.fromEntries(
-    await bundleRouteRequestModuleBatchCode({
-      appDir: options.appDir,
-      cacheDir: options.cacheDir,
-      define: options.define,
-      entries: options.entries,
-      externalizeAllowedPackages: options.externalizeAllowedPackages,
-      importPolicy: options.importPolicy,
-      vitePlugins: options.vitePlugins,
-    }),
+    (
+      await bundleRouteRequestModuleBatchCode({
+        appDir: options.appDir,
+        cacheDir: options.cacheDir,
+        define: options.define,
+        entries: options.entries,
+        externalizeAllowedPackages: options.externalizeAllowedPackages,
+        importPolicy: options.importPolicy,
+        vitePlugins: options.vitePlugins,
+      })
+    ).codeByKey,
   );
 }
 
@@ -2697,7 +2768,7 @@ async function bundleRouteRequestModuleCode(options: {
   externalizeAllowedPackages?: boolean | undefined;
   filename: string;
   importPolicy?: AppRouterImportPolicy | undefined;
-  label: "Loader" | "Metadata";
+  label: RouteRequestModuleBundleLabel;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const output = await bundleRouterModule({
@@ -2736,7 +2807,7 @@ function routeRequestBundleCacheKey(options: {
   externalizeAllowedPackages?: boolean | undefined;
   filename: string;
   importPolicy?: AppRouterImportPolicy | undefined;
-  label: "Loader" | "Metadata";
+  label: RouteRequestModuleBundleLabel;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): string {
   return stableCacheKey({
@@ -2836,7 +2907,19 @@ interface RouteRequestModuleBatchEntry {
   code: string;
   filename: string;
   key: string;
-  label: "Loader" | "Metadata";
+  label: RouteRequestModuleBundleLabel;
+}
+
+type RouteRequestModuleBundleLabel = "Loader" | "Metadata" | "Middleware";
+
+interface SharedServerModuleChunk {
+  code: string;
+  fileName: string;
+}
+
+interface RouteRequestModuleBatchOutput {
+  codeByKey: Map<string, string>;
+  sharedChunks: readonly SharedServerModuleChunk[];
 }
 
 async function writeCloudflareRouteModules(options: {