@reckona/mreact-router 0.0.157 → 0.0.159

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reckona/mreact-router",
-  "version": "0.0.157",
+  "version": "0.0.159",
   "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-compat": "0.0.157",
-    "@reckona/mreact-devtools": "0.0.157",
-    "@reckona/mreact-query": "0.0.157",
-    "@reckona/mreact-reactive-core": "0.0.157",
-    "@reckona/mreact-compiler": "0.0.157",
-    "@reckona/mreact": "0.0.157",
-    "@reckona/mreact-reactive-dom": "0.0.157",
-    "@reckona/mreact-server": "0.0.157",
-    "@reckona/mreact-shared": "0.0.157"
+    "@reckona/mreact": "0.0.159",
+    "@reckona/mreact-compat": "0.0.159",
+    "@reckona/mreact-compiler": "0.0.159",
+    "@reckona/mreact-query": "0.0.159",
+    "@reckona/mreact-reactive-core": "0.0.159",
+    "@reckona/mreact-devtools": "0.0.159",
+    "@reckona/mreact-reactive-dom": "0.0.159",
+    "@reckona/mreact-server": "0.0.159",
+    "@reckona/mreact-shared": "0.0.159"
   },
   "peerDependencies": {
     "vite": ">=8 <9"
   },
   "optionalDependencies": {
-    "@reckona/mreact-router-native": "0.0.157"
+    "@reckona/mreact-router-native": "0.0.159"
   }
 }

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";
@@ -448,7 +449,7 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
         );
 
   const clientRouteInferenceCache = createClientRouteInferenceCache();
-  const [serverActionManifest, serverModules, generatedImportPolicy] = await Promise.all([
+  const [serverActionManifest, generatedImportPolicy] = await Promise.all([
     shouldTrackBuildPhases === false
       ? collectBuildServerActionManifest({
           files,
@@ -464,8 +465,32 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
             routesDir: project.routesDir,
           }),
         ),
+    shouldTrackBuildPhases === false
+      ? buildGeneratedImportPolicy({
+          files,
+          projectRoot: project.projectRoot,
+          routes,
+          routesDir: project.routesDir,
+        })
+      : timeBuildPhase(timingSink, progressSink, "importPolicy", () =>
+          buildGeneratedImportPolicy({
+            files,
+            projectRoot: project.projectRoot,
+            routes,
+            routesDir: project.routesDir,
+          }),
+        ),
+  ]);
+  const actionRenderBundleExcludedFiles = new Set(
+    [...serverActionManifest.routeReferences.entries()]
+      .filter(([, references]) => references.length > 0)
+      .map(([file]) => file),
+  );
+  const { artifacts: serverModules, sharedChunks: serverModuleSharedChunks } = await (
     shouldTrackBuildPhases === false
       ? buildServerModuleArtifacts({
+          actionRenderBundleExcludedFiles,
+          bundleRequestRuntimePackages: shouldBuildAwsLambda,
           bundleCache: new Map(),
           clientRouteInferenceCache: serverClientRouteInferenceCache,
           define: viteDefine,
@@ -480,6 +505,8 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
         })
       : timeBuildPhase(timingSink, progressSink, "serverModules", () =>
           buildServerModuleArtifacts({
+            actionRenderBundleExcludedFiles,
+            bundleRequestRuntimePackages: shouldBuildAwsLambda,
             bundleCache: new Map(),
             clientRouteInferenceCache: serverClientRouteInferenceCache,
             define: viteDefine,
@@ -492,23 +519,8 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
             serverTransformCache,
             vitePlugins,
           }),
-        ),
-    shouldTrackBuildPhases === false
-      ? buildGeneratedImportPolicy({
-          files,
-          projectRoot: project.projectRoot,
-          routes,
-          routesDir: project.routesDir,
-        })
-      : timeBuildPhase(timingSink, progressSink, "importPolicy", () =>
-          buildGeneratedImportPolicy({
-            files,
-            projectRoot: project.projectRoot,
-            routes,
-            routesDir: project.routesDir,
-          }),
-        ),
-  ]);
+        )
+  );
   const serverRoutes = routes.map((route) => ({
     ...route,
     file: relative(project.projectRoot, route.file),
@@ -519,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
@@ -1043,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>;
@@ -1064,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) {
@@ -1993,6 +2024,8 @@ function routePathFromParams(route: AppRoute, params: StaticParams): string {
 }
 
 async function buildServerModuleArtifacts(options: {
+  actionRenderBundleExcludedFiles?: ReadonlySet<string> | undefined;
+  bundleRequestRuntimePackages: boolean;
   bundleCache: Map<string, Promise<RouterBundleOutput>>;
   cacheDir?: string | undefined;
   clientRouteInferenceCache: ClientRouteInferenceCache;
@@ -2005,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]),
   );
@@ -2069,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"
     ) {
@@ -2084,18 +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),
@@ -2119,6 +2170,7 @@ async function buildServerModuleArtifacts(options: {
               cacheDir: options.cacheDir,
               code: stripRouteLoaderOnlyExports(source, absoluteFile),
               filename: absoluteFile,
+              externalizeAllowedPackages: !options.bundleRequestRuntimePackages,
               importPolicy: requestModuleImportPolicy,
               define: options.define,
               vitePlugins: options.vitePlugins,
@@ -2138,6 +2190,7 @@ async function buildServerModuleArtifacts(options: {
               cacheDir: options.cacheDir,
               code: stripRouteMetadataOnlyExports(source, absoluteFile),
               filename: absoluteFile,
+              externalizeAllowedPackages: !options.bundleRequestRuntimePackages,
               importPolicy: requestModuleImportPolicy,
               label: "Metadata",
               define: options.define,
@@ -2161,6 +2214,7 @@ async function buildServerModuleArtifacts(options: {
                 bundleCache: options.bundleCache,
                 cacheDir: options.cacheDir,
                 filename: absoluteFile,
+                externalizeAllowedPackages: !options.bundleRequestRuntimePackages,
                 importPolicy: requestModuleImportPolicy,
                 define: options.define,
                 routeKind: route?.kind,
@@ -2273,23 +2327,26 @@ async function buildServerModuleArtifacts(options: {
             return undefined;
           }
 
+          const shouldWriteRenderBundle =
+            options.prebundleServerComponents &&
+            options.actionRenderBundleExcludedFiles?.has(file) !== true;
+          const bundleCode = shouldWriteRenderBundle
+            ? await buildServerComponentBundleArtifactCode({
+                clientRouteInferenceCache: options.clientRouteInferenceCache,
+                code: output.code,
+                externalizeCompatVendor,
+                filename: absoluteFile,
+                define: options.define,
+                root: options.projectRoot,
+                serverOutput,
+                vitePlugins: options.vitePlugins,
+              })
+            : undefined;
+
           return [
             serverOutput,
             {
-              ...(options.prebundleServerComponents
-                ? {
-                    bundleCode: await buildServerComponentBundleArtifactCode({
-                      clientRouteInferenceCache: options.clientRouteInferenceCache,
-                      code: output.code,
-                      externalizeCompatVendor,
-                      filename: absoluteFile,
-                      define: options.define,
-                      root: options.projectRoot,
-                      serverOutput,
-                      vitePlugins: options.vitePlugins,
-                    }),
-                  }
-                : {}),
+              ...(bundleCode === undefined ? {} : { bundleCode }),
               code: output.code,
               metadata: output.metadata,
               sourceHash: hashText(code),
@@ -2314,7 +2371,7 @@ async function buildServerModuleArtifacts(options: {
     }
   }
 
-  return artifacts;
+  return { artifacts, sharedChunks };
 }
 
 async function buildServerComponentBundleArtifactCode(options: {
@@ -2476,6 +2533,7 @@ async function buildRequestModuleArtifactCode(options: {
   bundleCache: Map<string, Promise<RouterBundleOutput>>;
   cacheDir?: string | undefined;
   define?: UserConfig["define"] | undefined;
+  externalizeAllowedPackages: boolean;
   filename: string;
   importPolicy: AppRouterImportPolicy;
   routeKind?: AppRoute["kind"] | undefined;
@@ -2488,6 +2546,7 @@ async function buildRequestModuleArtifactCode(options: {
       code: options.source,
       define: options.define,
       file: options.filename,
+      externalizeAllowedPackages: options.externalizeAllowedPackages,
       importPolicy: options.importPolicy,
       vitePlugins: options.vitePlugins,
     });
@@ -2512,6 +2571,7 @@ async function buildRequestModuleArtifactCode(options: {
     cacheDir: options.cacheDir,
     code: stripRouteRequestOnlyExports(options.source, options.filename),
     define: options.define,
+    externalizeAllowedPackages: options.externalizeAllowedPackages,
     filename: options.filename,
     importPolicy: options.importPolicy,
     vitePlugins: options.vitePlugins,
@@ -2524,6 +2584,7 @@ async function bundleRouteLoaderModuleCode(options: {
   cacheDir?: string | undefined;
   code: string;
   define?: UserConfig["define"] | undefined;
+  externalizeAllowedPackages?: boolean | undefined;
   filename: string;
   importPolicy?: AppRouterImportPolicy | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
@@ -2539,36 +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,
-          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(
@@ -2579,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: [
@@ -2594,14 +2663,16 @@ async function bundleRouteRequestModuleBatchCode(options: {
         appDir: options.appDir,
         importPolicy: options.importPolicy,
         label: "Request artifact",
+        externalizeAllowedPackages: options.externalizeAllowedPackages,
       }),
     ],
     root:
       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) =>
@@ -2613,6 +2684,7 @@ async function bundleRouteRequestModuleBatchCode(options: {
             cacheDir: options.cacheDir,
             code: entry.code,
             define: options.define,
+            externalizeAllowedPackages: options.externalizeAllowedPackages,
             filename: entry.filename,
             importPolicy: options.importPolicy,
             label: entry.label,
@@ -2620,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)),
   );
 }
 
@@ -2643,18 +2740,22 @@ export async function __bundleRouteRequestModuleBatchForTests(options: {
   cacheDir?: string | undefined;
   define?: UserConfig["define"] | undefined;
   entries: readonly RouteRequestModuleBatchEntry[];
+  externalizeAllowedPackages?: boolean | undefined;
   importPolicy?: AppRouterImportPolicy | undefined;
   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,
-      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,
   );
 }
 
@@ -2664,9 +2765,10 @@ async function bundleRouteRequestModuleCode(options: {
   cacheDir?: string | undefined;
   code: string;
   define?: UserConfig["define"] | undefined;
+  externalizeAllowedPackages?: boolean | undefined;
   filename: string;
   importPolicy?: AppRouterImportPolicy | undefined;
-  label: "Loader" | "Metadata";
+  label: RouteRequestModuleBundleLabel;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const output = await bundleRouterModule({
@@ -2683,6 +2785,7 @@ async function bundleRouteRequestModuleCode(options: {
       fileImportMetaUrlPlugin(),
       createAppRouterImportPolicyPlugin({
         appDir: options.appDir,
+        externalizeAllowedPackages: options.externalizeAllowedPackages,
         importPolicy: options.importPolicy,
         label: options.label,
       }),
@@ -2701,9 +2804,10 @@ function routeRequestBundleCacheKey(options: {
   appDir: string;
   code: string;
   define?: UserConfig["define"] | undefined;
+  externalizeAllowedPackages?: boolean | undefined;
   filename: string;
   importPolicy?: AppRouterImportPolicy | undefined;
-  label: "Loader" | "Metadata";
+  label: RouteRequestModuleBundleLabel;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): string {
   return stableCacheKey({
@@ -2723,6 +2827,7 @@ function routeRequestBundleCacheKey(options: {
                 ? undefined
                 : resolve(options.importPolicy.projectRoot),
           },
+    externalizeAllowedPackages: options.externalizeAllowedPackages,
     label: options.label,
     platform: "node",
     target: "es2022",
@@ -2802,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: {

package/src/import-policy.ts

@@ -21,6 +21,7 @@ export interface AppRouterImportPolicy {
 export interface AppRouterImportPolicyPluginOptions {
   allowedSourceDirs?: readonly string[] | undefined;
   appDir: string;
+  externalizeAllowedPackages?: boolean | undefined;
   importPolicy?: AppRouterImportPolicy | undefined;
   label: string;
   projectRoot?: string | undefined;
@@ -110,10 +111,12 @@ export function createAppRouterImportPolicyPlugin(options: AppRouterImportPolicy
           return undefined;
         }
 
-        return {
-          external: true,
-          path: pathToFileURL(resolvedPackage).href,
-        };
+        return options.externalizeAllowedPackages === false
+          ? undefined
+          : {
+              external: true,
+              path: pathToFileURL(resolvedPackage).href,
+            };
       });
     },
   };

package/src/render.ts

@@ -2525,6 +2525,7 @@ export async function bundleMiddlewareModuleCode(options: {
   appDir: string;
   code: string;
   define?: UserConfig["define"] | undefined;
+  externalizeAllowedPackages?: boolean | undefined;
   file: string;
   importPolicy?: AppRouterImportPolicy | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
@@ -2539,6 +2540,7 @@ export async function bundleMiddlewareModuleCode(options: {
       fileImportMetaUrlPlugin(),
       createAppRouterImportPolicyPlugin({
         appDir: options.appDir,
+        externalizeAllowedPackages: options.externalizeAllowedPackages,
         importPolicy: options.importPolicy,
         label: "Middleware",
       }),