fix(app-router): ignore very dynamic requests during build analysis

packages/vinext/src/index.ts

@@ -175,6 +175,7 @@ import {
 import { stripServerExports } from "./plugins/strip-server-exports.js";
 import { removeConsoleCalls } from "./plugins/remove-console.js";
 import { createImportMetaUrlPlugin } from "./plugins/import-meta-url.js";
+import { createIgnoreDynamicRequestsPlugin } from "./plugins/ignore-dynamic-requests.js";
 import { createRequireContextPlugin } from "./plugins/require-context.js";
 import { createExtensionlessDynamicImportPlugin } from "./plugins/extensionless-dynamic-import.js";
 import { createWasmModuleImportPlugin } from "./plugins/wasm-module-import.js";
@@ -1024,6 +1025,10 @@ export default function vinext(options: VinextOptions = {}): PluginOption[] {
     ...(viteMajorVersion >= 8 ? [] : [tsconfigPaths()]),
     // React Fast Refresh + JSX transform for client components.
     reactPluginPromise,
+    // Next.js/Turbopack ignores "very dynamic" requests with no static path
+    // part during graph analysis. Preserve that behaviour before the CJS
+    // plugin tries to expand require(dynamic) as a static glob.
+    createIgnoreDynamicRequestsPlugin(),
     // Transform CJS require()/module.exports to ESM before other plugins
     // analyze imports (RSC directive scanning, shim resolution, etc.)
     commonjs(),

packages/vinext/src/plugins/ast-utils.ts

@@ -12,23 +12,30 @@ export type AstRange = AstRecord & {
 
 const SKIP_CHILD_KEYS = new Set(["type", "parent", "loc", "start", "end"]);
 
-function getObjectProperty(value: unknown, key: string): unknown {
-  if (typeof value !== "object" || value === null) return null;
+export function getObjectProperty(value: unknown, key: string): unknown {
+  if ((typeof value !== "object" || value === null) && typeof value !== "function") return null;
   return Reflect.get(value, key);
 }
 
 export function isAstRecord(value: unknown): value is AstRecord {
   return typeof getObjectProperty(value, "type") === "string";
 }
 
-function toAstRecord(value: unknown): AstRecord | null {
+export function toAstRecord(value: unknown): AstRecord | null {
   return isAstRecord(value) ? value : null;
 }
 
 export function nodeArray(value: unknown): unknown[] {
   return Array.isArray(value) ? value : [];
 }
 
+export function astArray(value: unknown): AstRecord[] {
+  return nodeArray(value).flatMap((entry) => {
+    const node = toAstRecord(entry);
+    return node ? [node] : [];
+  });
+}
+
 export function hasRange(node: AstRecord | null): node is AstRange {
   return node !== null && typeof node.start === "number" && typeof node.end === "number";
 }
@@ -62,6 +69,26 @@ export function forEachAstChild(node: AstRecord, callback: (child: AstRecord) =>
   }
 }
 
+/**
+ * Expression wrappers that are transparent at runtime. Unwrapping them returns
+ * the underlying expression so callers can analyze the real value.
+ */
+const TRANSPARENT_EXPRESSION_TYPES = new Set([
+  "TSAsExpression",
+  "TSTypeAssertion",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "TSSatisfiesExpression",
+  "ParenthesizedExpression",
+  "ChainExpression",
+]);
+
+export function unwrapTransparentExpression(node: AstRecord | null): AstRecord | null {
+  if (!node) return null;
+  if (!TRANSPARENT_EXPRESSION_TYPES.has(node.type)) return node;
+  return unwrapTransparentExpression(toAstRecord(getObjectProperty(node, "expression")));
+}
+
 export function collectBindingNames(pattern: unknown, target: Set<string>): void {
   const node = toAstRecord(pattern);
   if (!node) return;
@@ -76,6 +103,9 @@ export function collectBindingNames(pattern: unknown, target: Set<string>): void
     case "AssignmentPattern":
       collectBindingNames(node.left, target);
       return;
+    case "TSParameterProperty":
+      collectBindingNames(node.parameter, target);
+      return;
     case "ArrayPattern":
       for (const element of nodeArray(node.elements)) collectBindingNames(element, target);
       return;