@wular/pnext 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "bin": {
     "pnext": "bin/pnext"

package/src/api/router/runtime.ts

@@ -3260,40 +3260,66 @@ async function fetchPage(
     }
     if (segmentPayload) {
       segmentCacheKey = segmentDocumentCacheKey(treeResponse, href, options.prefetch!);
-      if (treeResponse.body && !treeResponse.bodyUsed) {
-        treePayload = parseSegmentTreePayload(await treeResponse.text());
-      }
-      // Remember this route's tree so a SIBLING URL of the same route never
-      // asks for it again (Next keys the route tree by route, not by URL).
-      const treeUrl = new URL(href, location.href);
-      learnRouteTree(
-        treeUrl.pathname,
-        treeUrl.search,
-        treePayload?.route,
-        treeResponse.headers.has('x-nextjs-rewritten-path') ||
-          treeResponse.headers.has('x-nextjs-rewritten-query'),
-      );
+      // The tree PAYLOAD is only bookkeeping (route learning, headFirst): read it
+      // without blocking the segment phase, so the body request goes on the wire in
+      // the same task the tree HEADERS resolve in — before the tree body's own
+      // stream-close task, where a harness batch (router-act) may already drain.
+      const treeText =
+        treeResponse.body && !treeResponse.bodyUsed ? treeResponse.text() : null;
+      const finishTree = async () => {
+        if (treeText) treePayload = parseSegmentTreePayload(await treeText);
+        // Remember this route's tree so a SIBLING URL of the same route never
+        // asks for it again (Next keys the route tree by route, not by URL).
+        const treeUrl = new URL(href, location.href);
+        learnRouteTree(
+          treeUrl.pathname,
+          treeUrl.search,
+          treePayload?.route,
+          treeResponse.headers.has('x-nextjs-rewritten-path') ||
+            treeResponse.headers.has('x-nextjs-rewritten-query'),
+        );
+      };
       releaseSlot();
       const cached = getSegmentDocument(segmentCacheKey, href, options.prefetch!);
-      if (cached) return cached;
+      if (cached) {
+        await finishTree();
+        return cached;
+      }
       // The link left the viewport while the tree was in flight: stop before
       // the segment phase (the in-flight tree request is never aborted, but no
       // follow-up request may be issued — Next's cancellation contract).
-      if (task?.cancelled) return null;
-      if (needsOutlinedHeadFirst(href, treePayload?.headFirst === true)) {
+      if (task?.cancelled) {
+        await finishTree();
+        return null;
+      }
+      // Head-before-body order is preserved: the tree response HEADERS announce
+      // outlining (x-pnext-head-outlined), so no tree-body read is needed here.
+      const treeHeadOutlined = treeResponse.headers.get('x-pnext-head-outlined');
+      if (needsOutlinedHeadFirst(href, treeHeadOutlined === 'first')) {
+        await finishTree();
         outlinedHeadHtml = await fetchOutlinedHead(href, init, headers, rscVariant);
       }
       const covered = segmentBodyCovered(href, options.prefetch);
-      if (covered) return withOutlinedHead(covered, outlinedHeadHtml);
+      if (covered) {
+        await finishTree();
+        return withOutlinedHead(covered, outlinedHeadHtml);
+      }
       bodySegment = prefetchBodySegmentPath(href);
       headers[SEGMENT_PREFETCH_HEADER] = bodySegment;
       requestHref = withRscQuery(href, `${rscVariant}:${bodySegment}`);
-      if (!(await acquireSlot(PREFETCH_PHASE_SEGMENT))) return null;
-      response = await fetchWithRedirectReplay(
+      if (!(await acquireSlot(PREFETCH_PHASE_SEGMENT))) {
+        await finishTree();
+        return null;
+      }
+      const bodyPromise = fetchWithRedirectReplay(
         requestHref,
         init,
         `${rscVariant}:${bodySegment}`,
       );
+      // A rejection before the await below must not surface as unhandled.
+      bodyPromise.catch(() => undefined);
+      await finishTree();
+      response = await bodyPromise;
     } else {
       response = treeResponse;
     }
@@ -4036,6 +4062,11 @@ async function pageForNavigation(
     // prerendered document for the SAME pathname is already cached: a static prerender never
     // rendered search params server-side, so only the client-visible URL differs.
     if (!cached.settled) {
+      // Same principle for a networkFree per-segment hit: it commits with zero
+      // network, so waiting out the in-flight prefetch would be pure latency.
+      if (segmentHit?.networkFree && !slotStateSensitive(departureNavState, segmentHit.html)) {
+        return { html: segmentHit.html, finalUrl: url.href, ok: true };
+      }
       const shared = await samePathnamePrerenderedPage(url, now, departureNavState);
       if (shared) return shared;
     }

package/src/compat/register/segment.ts

@@ -918,6 +918,11 @@ const segmentPrefetchInterceptor: RequestInterceptor = async (request, ctx) => {
             'x-nextjs-postponed': '2',
             'x-nextjs-stale-time': String(staleTime),
             ...(isStatic ? { 'x-nextjs-prerender': '1' } : {}),
+            // Announce head outlining on the tree HEADERS too, so the client
+            // can keep head-before-body order without reading the tree body.
+            ...(selection?.route.pprMetadata === true
+              ? { 'x-pnext-head-outlined': headFetchedFirst(selection) ? 'first' : '1' }
+              : {}),
             'x-nextjs-deployment-id': deploymentId(),
             // A static route's baked tree is CDN-cacheable like Next's
             // prerendered payloads; the per-variant `_rsc` cache-buster keys
@@ -949,12 +954,17 @@ const segmentPrefetchInterceptor: RequestInterceptor = async (request, ctx) => {
       ? { headOutlined: true, ...(headFetchedFirst(selection) ? { headFirst: true } : {}) }
       : {}),
   });
-  return withRewriteHeaders(
-    withDeploymentId(
-      treePrefetchResponse(payload, { format: url.searchParams.has('_rsc') ? 'flight' : 'json' }),
-    ),
-    rewriteHeaders,
-  );
+  const treeResponse = treePrefetchResponse(payload, {
+    format: url.searchParams.has('_rsc') ? 'flight' : 'json',
+  });
+  // Mirror the payload's head-outlining on the HEADERS (see baked branch).
+  if (selection?.route.pprMetadata === true) {
+    treeResponse.headers.set(
+      'x-pnext-head-outlined',
+      headFetchedFirst(selection) ? 'first' : '1',
+    );
+  }
+  return withRewriteHeaders(withDeploymentId(treeResponse), rewriteHeaders);
 };
 
 /**

package/src/dynamic/source.ts

@@ -1,4 +1,4 @@
-import { rewriteFacts } from '../resolve/scan-facts';
+import { dynamicCallFacts, rewriteFacts, type DynamicCallFact } from '../resolve/scan-facts';
 
 export interface DynamicCall {
   index: number;
@@ -86,19 +86,16 @@ export function dynamicCallsFromSource(source: string, dynamicNames: Set<string>
 export function rewriteLiteralDynamicCalls(source: string, file?: string) {
   const dynamicNames = pnextDynamicImportNames(source, file);
   if (dynamicNames.size === 0) return source;
+  const facts = dynamicCallFacts(source, file);
 
   const edits: { start: number; end: number; value: string }[] = [];
   for (const call of dynamicCallsFromSource(source, dynamicNames)) {
-    const args = source.slice(call.open + 1, call.close);
-    const literal = /^(\s*)(['"])([^'"]+)\2(?=\s*(?:,|$))/.exec(args);
-    if (!literal) continue;
-    const [match, leading = '', quote = "'", specifier] = literal;
-    if (!specifier) continue;
-    const start = call.open + 1 + leading.length;
+    const fact = factForCall(facts, call);
+    if (!fact?.literal) continue;
     edits.push({
-      start,
-      end: call.open + 1 + match.length,
-      value: `() => import(${quote}${specifier}${quote})`,
+      start: fact.specifierStart,
+      end: fact.specifierEnd,
+      value: `() => import(${source.slice(fact.specifierStart, fact.specifierEnd)})`,
     });
   }
 
@@ -123,18 +120,19 @@ export function rewriteDynamicCallTargets(
 ) {
   const dynamicNames = pnextDynamicImportNames(source, file);
   if (dynamicNames.size === 0) return source;
+  const facts = dynamicCallFacts(source, file);
 
   const edits: { at: number; value: string }[] = [];
   for (const call of dynamicCallsFromSource(source, dynamicNames)) {
-    const target = dynamicImportTarget.exec(call.source);
-    if (!target?.[2]) continue;
-    const file = resolve(target[2]);
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target) continue;
+    const file = resolve(target.specifier);
     if (!file) continue;
 
     const args = source.slice(call.open + 1, call.close);
     const argCount = topLevelArgCount(args);
     if (argCount < 1 || argCount > 2) continue;
-    const literal = JSON.stringify({ file, exportName: target[4] ?? 'default' });
+    const literal = JSON.stringify({ file, exportName: target.exportName });
     const separator = /,\s*$/.test(args) ? '' : ', ';
     edits.push({
       at: call.close,
@@ -151,8 +149,19 @@ export function rewriteDynamicCallTargets(
   return next;
 }
 
-const dynamicImportTarget =
-  /import\s*\(\s*(['"])([^'"]+)\1\s*\)(?:\s*\.then\s*\(\s*([A-Za-z_$][\w$]*)\s*=>\s*\3\.([A-Za-z_$][\w$]*)\s*\))?/;
+function factForCall(facts: DynamicCallFact[], call: DynamicCall) {
+  return facts.find(fact => fact.start === call.index);
+}
+
+/**
+ * The statically-extractable import behind one dynamic() call — the AST fact
+ * alone; a call the scan could not analyze yields no detection. Literal-loader
+ * calls (`dynamic('./x')`) answer undefined — they carry no `import()` yet.
+ */
+function loaderImportTargetForCall(call: DynamicCall, facts: DynamicCallFact[]) {
+  const fact = factForCall(facts, call);
+  return fact && !fact.literal ? fact : undefined;
+}
 
 /** Dev split of `dynamic(ssr:false)` targets; `PNEXT_DYNAMIC_SPLIT=0` restores eager builds. */
 export function devDynamicSplitEnabled() {
@@ -175,17 +184,17 @@ export function rewriteDeferredDynamicImports(
   if (dynamicNames.size === 0) return source;
   const deferred = deferredDynamicImportSpecifiers(source, file);
   if (deferred.size === 0) return source;
+  const facts = dynamicCallFacts(source, file);
 
   const edits: { start: number; end: number; value: string }[] = [];
   for (const call of dynamicCallsFromSource(source, dynamicNames)) {
-    const target = dynamicImportTarget.exec(call.source);
-    if (!target?.[2] || !deferred.has(target[2])) continue;
-    const resolved = resolve(target[2]);
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target || !deferred.has(target.specifier)) continue;
+    const resolved = resolve(target.specifier);
     if (!resolved) continue;
-    const url = href({ file: resolved, exportName: target[4] ?? 'default' });
+    const url = href({ file: resolved, exportName: target.exportName });
     if (!url) continue;
-    const specifierAt = call.index + target.index + target[0].indexOf(target[2]);
-    edits.push({ start: specifierAt, end: specifierAt + target[2].length, value: url });
+    edits.push({ start: target.specifierStart + 1, end: target.specifierEnd - 1, value: url });
   }
   if (edits.length === 0) return source;
   let next = source;
@@ -212,13 +221,13 @@ export function deferredDynamicImportSpecifiers(source: string, file?: string) {
     if (constMatch[1] && constMatch[2]) optionConsts.set(constMatch[1], constMatch[2]);
   }
 
+  const facts = dynamicCallFacts(source, file);
   for (const call of dynamicCallsFromSource(source, dynamicNames)) {
-    const target = dynamicImportTarget.exec(call.source);
-    if (!target?.[2]) continue;
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target) continue;
     // Token scan over the call plus any named option consts it references —
     // tolerant of the compile-appended target argument (rewriteDynamicCallTargets).
-    const args = source.slice(call.open + 1, call.close);
-    const tail = args.slice(args.indexOf(target[0]) + target[0].length);
+    const tail = source.slice(target.loaderEnd, call.close);
     let options = tail;
     for (const identifier of tail.match(/[A-Za-z_$][\w$]*/g) ?? []) {
       const named = optionConsts.get(identifier);
@@ -227,7 +236,7 @@ export function deferredDynamicImportSpecifiers(source: string, file?: string) {
     const ssrFalse = /\bssr\s*:\s*false\b/.test(options);
     const visible =
       /\bload\s*:\s*['"]visible['"]/.test(options) && !/\bssr\s*:\s*true\b/.test(options);
-    if (ssrFalse || visible) deferred.add(target[2]);
+    if (ssrFalse || visible) deferred.add(target.specifier);
   }
   return deferred;
 }

package/src/resolve/scan-facts.ts

@@ -75,6 +75,33 @@ export interface RewriteFacts {
   unreliable: boolean;
 }
 
+/**
+ * A `name(loader, options?)` call whose loader statically targets one module —
+ * the shape `dynamic()` extraction needs. Emitted for every identifier-callee
+ * call with such a loader; consumers gate on their own `dynamic` binding set.
+ */
+export interface DynamicCallFact {
+  name: string;
+  /** Callee identifier start — aligns with the textual call scan's index. */
+  start: number;
+  /** Call end (past the closing paren). */
+  end: number;
+  /** Loader target, cooked value. */
+  specifier: string;
+  /** Span of the quoted specifier literal, quotes included. */
+  specifierStart: number;
+  specifierEnd: number;
+  /** From the `.then(m => m.X)` arm (or awaited member); `default` otherwise. */
+  exportName: string;
+  /** First arg is a string literal (`dynamic('./x')` form), not a loader fn. */
+  literal?: boolean;
+  /** End of the loader argument — options/appended args follow it. */
+  loaderEnd: number;
+  /** Second-argument span, when present. */
+  optionsStart?: number;
+  optionsEnd?: number;
+}
+
 export interface ScanFacts {
   /** Static value imports and `export … from` re-exports, in source order. */
   imports: ScanEdge[];
@@ -88,6 +115,8 @@ export interface ScanFacts {
   exportStars: string[];
   /** A real `'use client'` directive — prologue position only, never a comment. */
   useClient: boolean;
+  /** Loader-shaped calls (see `DynamicCallFact`); only sources that can bind `dynamic` are walked. */
+  dynamicCalls: DynamicCallFact[];
 }
 
 const stylesheetOrData = /\.(?:css|scss|sass|less|styl|json)$/;
@@ -99,6 +128,7 @@ const emptyFacts: ScanFacts = {
   exportNames: [],
   exportStars: [],
   useClient: false,
+  dynamicCalls: [],
 };
 
 const emptyRewriteFacts: RewriteFacts = {
@@ -138,6 +168,15 @@ export function moduleExportStars(source: string, sourcefile = 'source.tsx') {
   return scanFacts(sourcefile, source).exportStars;
 }
 
+/**
+ * AST-derived `dynamic()` loader facts — the single source of truth. A call
+ * without a fact is an unanalyzable loader: no detection, nothing to splice.
+ */
+export function dynamicCallFacts(source: string, file = 'module.tsx'): DynamicCallFact[] {
+  if (stylesheetOrData.test(file)) return [];
+  return parsed(file, source).scan.dynamicCalls;
+}
+
 /** Module-record spans for the rewrite passes (see `RewriteFacts`). */
 export function rewriteFacts(file: string, source: string): RewriteFacts {
   if (stylesheetOrData.test(file)) return emptyRewriteFacts;
@@ -327,6 +366,12 @@ function parseFacts(file: string, source: string, lang: ParserLang) {
       exportNames,
       exportStars,
       useClient: hasUseClient(source, result),
+      // `result.program` deserializes the whole AST: walk it only for sources
+      // that can bind `dynamic()` at all (same cheap gate as dynamic/source.ts).
+      dynamicCalls:
+        source.includes('@wular/pnext') || source.includes('next/dynamic')
+          ? collectDynamicCalls(result.program as unknown as AstNode)
+          : [],
     },
     rewrite: {
       edges,
@@ -469,6 +514,195 @@ function literalSpecifier(raw: string) {
   return /^\s*(['"])([^'"]*)\1\s*$/.exec(raw)?.[2] || undefined;
 }
 
+interface AstNode {
+  type: string;
+  start: number;
+  end: number;
+  [key: string]: unknown;
+}
+
+function isNode(value: unknown): value is AstNode {
+  return typeof value === 'object' && value !== null && typeof (value as AstNode).type === 'string';
+}
+
+function child(node: AstNode | undefined, key: string): AstNode | undefined {
+  const value = node?.[key];
+  return isNode(value) ? value : undefined;
+}
+
+function collectDynamicCalls(program: AstNode): DynamicCallFact[] {
+  const calls: DynamicCallFact[] = [];
+  const visit = (value: unknown) => {
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+    if (!isNode(value)) return;
+    if (value.type === 'CallExpression') {
+      const fact = dynamicCallFact(value);
+      if (fact) calls.push(fact);
+    }
+    for (const key in value) {
+      if (key === 'type' || key === 'loc' || key === 'range') continue;
+      const entry = value[key];
+      if (entry && typeof entry === 'object') visit(entry);
+    }
+  };
+  visit(program.body);
+  return calls.sort((a, b) => a.start - b.start);
+}
+
+function dynamicCallFact(call: AstNode): DynamicCallFact | undefined {
+  const callee = child(call, 'callee');
+  if (callee?.type !== 'Identifier') return undefined;
+  const args = call.arguments;
+  if (!Array.isArray(args) || !isNode(args[0])) return undefined;
+  const loader = args[0];
+
+  let target: { specifier: AstNode; exportName: string } | undefined;
+  let literal: boolean | undefined;
+  if (stringValue(loader) !== undefined) {
+    target = { specifier: loader, exportName: 'default' };
+    literal = true;
+  } else if (loader.type === 'ArrowFunctionExpression' || loader.type === 'FunctionExpression') {
+    target = loaderImportTarget(loader) ?? firstImportTarget(loader);
+  }
+  if (!target) return undefined;
+
+  const specifier = stringValue(target.specifier);
+  if (specifier === undefined) return undefined;
+  const options = isNode(args[1]) ? args[1] : undefined;
+  return {
+    name: callee.name as string,
+    start: callee.start,
+    end: call.end,
+    specifier,
+    specifierStart: target.specifier.start,
+    specifierEnd: target.specifier.end,
+    exportName: target.exportName,
+    ...(literal ? { literal } : {}),
+    loaderEnd: loader.end,
+    ...(options ? { optionsStart: options.start, optionsEnd: options.end } : {}),
+  };
+}
+
+function stringValue(node: AstNode | undefined): string | undefined {
+  if (!node) return undefined;
+  if (node.type !== 'Literal' && node.type !== 'StringLiteral') return undefined;
+  return typeof node.value === 'string' ? node.value : undefined;
+}
+
+/** Past parens, `await`, `as`/`!` and optional-chain wrappers to the loader's real expression. */
+function unwrapExpression(node: AstNode | undefined): AstNode | undefined {
+  let current = node;
+  for (;;) {
+    if (!current) return undefined;
+    if (current.type === 'ParenthesizedExpression' || current.type === 'ChainExpression') {
+      current = child(current, 'expression');
+    } else if (current.type === 'AwaitExpression') {
+      current = child(current, 'argument');
+    } else if (current.type === 'TSAsExpression' || current.type === 'TSNonNullExpression' || current.type === 'TSSatisfiesExpression') {
+      current = child(current, 'expression');
+    } else {
+      return current;
+    }
+  }
+}
+
+/** The expression a loader function resolves to: its expression body or first `return`. */
+function loaderResult(fn: AstNode): AstNode | undefined {
+  const body = child(fn, 'body');
+  if (!body) return undefined;
+  if (body.type !== 'BlockStatement' && body.type !== 'FunctionBody') return unwrapExpression(body);
+  const statements = body.body;
+  if (!Array.isArray(statements)) return undefined;
+  for (const statement of statements) {
+    if (isNode(statement) && statement.type === 'ReturnStatement') {
+      return unwrapExpression(child(statement, 'argument'));
+    }
+  }
+  return undefined;
+}
+
+function importSource(node: AstNode | undefined): AstNode | undefined {
+  if (node?.type !== 'ImportExpression') return undefined;
+  const source = child(node, 'source');
+  return source && stringValue(source) !== undefined ? source : undefined;
+}
+
+/**
+ * Statically resolve a loader body: `import('x')`, `import('x').then(m => m.X)`
+ * (any param/arrow formatting), or `(await import('x')).X`.
+ */
+function loaderImportTarget(fn: AstNode): { specifier: AstNode; exportName: string } | undefined {
+  const result = loaderResult(fn);
+  if (!result) return undefined;
+
+  const direct = importSource(result);
+  if (direct) return { specifier: direct, exportName: 'default' };
+
+  if (result.type === 'MemberExpression' && result.computed !== true) {
+    const source = importSource(unwrapExpression(child(result, 'object')));
+    const property = child(result, 'property');
+    if (source && property?.type === 'Identifier') {
+      return { specifier: source, exportName: property.name as string };
+    }
+  }
+
+  if (result.type !== 'CallExpression') return undefined;
+  const callee = child(result, 'callee');
+  if (callee?.type !== 'MemberExpression' || callee.computed === true) return undefined;
+  if (child(callee, 'property')?.name !== 'then') return undefined;
+  const source = importSource(unwrapExpression(child(callee, 'object')));
+  if (!source) return undefined;
+  return { specifier: source, exportName: thenArmExport(result) ?? 'default' };
+}
+
+/** `X` of a `.then(m => m.X)` arm; undefined for any other arm shape. */
+function thenArmExport(thenCall: AstNode): string | undefined {
+  const args = thenCall.arguments;
+  if (!Array.isArray(args) || !isNode(args[0])) return undefined;
+  const arm = args[0];
+  if (arm.type !== 'ArrowFunctionExpression' && arm.type !== 'FunctionExpression') return undefined;
+  const params = arm.params;
+  const param = Array.isArray(params) && isNode(params[0]) ? params[0] : undefined;
+  if (param?.type !== 'Identifier') return undefined;
+  const result = loaderResult(arm);
+  if (result?.type !== 'MemberExpression' || result.computed === true) return undefined;
+  const object = unwrapExpression(child(result, 'object'));
+  if (object?.type !== 'Identifier' || object.name !== param.name) return undefined;
+  const property = child(result, 'property');
+  return property?.type === 'Identifier' ? (property.name as string) : undefined;
+}
+
+/**
+ * Fallback for loader shapes the structured pass cannot follow: the first
+ * literal `import()` anywhere in the loader, default export — mirrors what the
+ * textual extraction always did for these.
+ */
+function firstImportTarget(fn: AstNode): { specifier: AstNode; exportName: string } | undefined {
+  let found: AstNode | undefined;
+  const visit = (value: unknown) => {
+    if (found) return;
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+    if (!isNode(value)) return;
+    const source = importSource(value);
+    if (source) {
+      found = source;
+      return;
+    }
+    for (const key in value) {
+      const entry = value[key];
+      if (entry && typeof entry === 'object') visit(entry);
+    }
+  };
+  visit(fn.body);
+  return found ? { specifier: found, exportName: 'default' } : undefined;
+}
+
 type ParserLang = 'ts' | 'tsx';
 
 // `.ts` forbids JSX (`<T>value` is a type assertion there); everything else —

package/src/routing/routes.ts

@@ -15,7 +15,7 @@ import {
   resolveModuleAlias,
   resolvePackageSpecifier,
 } from '../resolve/imports';
-import { scanFacts } from '../resolve/scan-facts';
+import { dynamicCallFacts, scanFacts, type DynamicCallFact } from '../resolve/scan-facts';
 import { readSourceSync } from '../resolve/source-text';
 import { globalCssSourcesForPaths } from '../css';
 import {
@@ -2276,21 +2276,14 @@ function dynamicImportEdgesFromSource(
   if (dynamicNames.size === 0) return imports;
 
   const optionObjects = dynamicOptionObjects(source);
-  const dynamicPattern =
-    /import\s*\(\s*['"]([^'"]+)['"]\s*\)(?:\s*\.then\s*\(\s*([A-Za-z_$][\w$]*)\s*=>\s*\2\.([A-Za-z_$][\w$]*)\s*\))?/g;
-  let match: RegExpExecArray | null;
-
-  while ((match = dynamicPattern.exec(source))) {
-    const [, specifier, _moduleName, exportName] = match;
-    if (!specifier) continue;
-    if (!isDynamicCallImport(source, match.index, dynamicNames)) continue;
-
-    const resolved = resolveModuleEdge(root, file, specifier);
+  for (const fact of dynamicCallFacts(source, file)) {
+    if (!dynamicNames.has(fact.name)) continue;
+    const resolved = resolveModuleEdge(root, file, fact.specifier);
     if (!resolved) continue;
     imports.push({
       file: resolved,
-      exports: [exportName ?? 'default'],
-      dynamic: dynamicOptionsForImport(source, dynamicPattern.lastIndex, optionObjects),
+      exports: [fact.exportName],
+      dynamic: dynamicOptionsForFact(source, fact, optionObjects),
     });
   }
 
@@ -2310,35 +2303,15 @@ function dynamicOptionObjects(source: string) {
   return options;
 }
 
-function isDynamicCallImport(source: string, importIndex: number, dynamicNames: Set<string>) {
-  const prefix = source.slice(Math.max(0, importIndex - 120), importIndex);
-  const dynamicIndex = nextDynamicCallIndexFromEnd(prefix, dynamicNames);
-  if (dynamicIndex === -1) return false;
-  return !/[;\n]\s*$/.test(prefix.slice(dynamicIndex));
-}
-
-function nextDynamicCallIndexFromEnd(source: string, dynamicNames: Set<string>) {
-  let next = -1;
-  for (const name of dynamicNames) {
-    const index = source.lastIndexOf(name);
-    if (index !== -1 && index > next) next = index;
-  }
-  return next;
-}
-
-function dynamicOptionsForImport(
+function dynamicOptionsForFact(
   source: string,
-  endIndex: number,
+  fact: DynamicCallFact,
   optionObjects: Map<string, ClientDynamicReference>,
 ) {
-  const tail = source.slice(endIndex, endIndex + 300);
-  const inlineMatch = /^\s*,\s*({[\s\S]*?})\s*,?\s*\)/.exec(tail);
-  if (inlineMatch?.[1]) return dynamicOptionsFromSource(inlineMatch[1]);
-
-  const identifierMatch = /^\s*,\s*([A-Za-z_$][\w$]*)\s*,?\s*\)/.exec(tail);
-  if (identifierMatch?.[1]) return optionObjects.get(identifierMatch[1]) ?? {};
-
-  return {};
+  if (fact.optionsStart === undefined || fact.optionsEnd === undefined) return {};
+  const options = source.slice(fact.optionsStart, fact.optionsEnd);
+  if (/^[A-Za-z_$][\w$]*$/.test(options)) return optionObjects.get(options) ?? {};
+  return dynamicOptionsFromSource(options);
 }
 
 function dynamicOptionsFromSource(source?: string): ClientDynamicReference {