@wular/pnext 0.0.2 → 0.0.4

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/ppr.ts

@@ -539,14 +539,15 @@ export function hangingPromise<T = never>(api: string): Promise<T> {
 // candidate and whether request APIs hang.
 // ---------------------------------------------------------------------------
 
-let cacheComponentsEnabled = false;
+// globalThis-anchored: the prebundled server entry inlines its own copy of this module.
+const CACHE_COMPONENTS = Symbol.for('pnext.cacheComponents');
 
 export function setCacheComponents(enabled: boolean): void {
-  cacheComponentsEnabled = enabled;
+  (globalThis as Record<PropertyKey, unknown>)[CACHE_COMPONENTS] = enabled;
 }
 
 export function cacheComponents(): boolean {
-  return cacheComponentsEnabled;
+  return (globalThis as Record<PropertyKey, unknown>)[CACHE_COMPONENTS] === true;
 }
 
 // ---------------------------------------------------------------------------
@@ -583,7 +584,7 @@ function insideUseCacheScope(): boolean {
 }
 
 export async function runWithPrerenderDeterminism<T>(fn: () => Promise<T>): Promise<T> {
-  if (!cacheComponentsEnabled) return fn();
+  if (!cacheComponents()) return fn();
   const deterministicTime = 1;
   const realRandom = Math.random;
   const RealDate = Date;

package/src/proxy.ts

@@ -1,6 +1,10 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { parseSync } from 'oxc-parser';
+// Lazy: the oxc-parser native binding costs ~12.6 MB RSS; load it only when a parse happens.
+const parseSync: typeof import('oxc-parser').parseSync = (...args) =>
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  loadNative(() => require('oxc-parser') as typeof import('oxc-parser')).parseSync(...args);
+import { loadNative } from './utils/native-require';
 import { registerServerRuntime } from './runtime/server';
 import { pathToFileHref, type ResolvedConfig } from './config';
 import { devServerModuleHref } from './dev/imports';

package/src/render/island-context.ts

@@ -1,4 +1,16 @@
-import { createContext } from 'preact';
+import { createContext, type Context } from 'preact';
+
+// Island SSR runs prebundled client chunks — a separate module graph with its own copy of this file, so
+// a plain createContext() would mint two identity-mismatched contexts. Resolve one shared instance.
+function sharedContext<T>(key: string, defaultValue: T): Context<T> {
+  const registry = globalThis as typeof globalThis & Record<symbol, Context<unknown>>;
+  const symbol = Symbol.for(key);
+  const existing = registry[symbol];
+  if (existing) return existing as Context<T>;
+  const context = createContext<T>(defaultValue);
+  registry[symbol] = context as Context<unknown>;
+  return context;
+}
 
 // ---------------------------------------------------------------------------
 // Per-island layout-segment context (CORE seam for compat useSelectedLayout-
@@ -28,7 +40,10 @@ export interface LayoutSegmentSnapshot {
   slots: Record<string, string[]>;
 }
 
-export const LayoutSegmentContext = createContext<LayoutSegmentSnapshot | null>(null);
+export const LayoutSegmentContext = sharedContext<LayoutSegmentSnapshot | null>(
+  'pnext.layoutSegmentContext',
+  null,
+);
 
 // Per-island params snapshot (CORE seam for compat useParams).
 //
@@ -44,4 +59,7 @@ export const LayoutSegmentContext = createContext<LayoutSegmentSnapshot | null>(
 
 export type RouteParamsSnapshot = Record<string, string | string[]>;
 
-export const RouteParamsContext = createContext<RouteParamsSnapshot | null>(null);
+export const RouteParamsContext = sharedContext<RouteParamsSnapshot | null>(
+  'pnext.routeParamsContext',
+  null,
+);

package/src/render/renderer.ts

@@ -103,7 +103,7 @@ import {
   ISLAND_BOUNDARY_ERROR_ELEMENT,
   ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE,
 } from '../islands/boundary-error';
-import { runWithCacheScope } from '../cache/context';
+import { captureCacheScope, runWithCacheScope } from '../cache/context';
 import { registerServerRuntime } from '../runtime/server';
 import { readText } from '../utils/fs';
 import {
@@ -2424,8 +2424,14 @@ export function pprSubShellPath(outPath: string, routeId: string, key: string) {
   return `${outPath}/ppr/${routeId}.${key}.html`;
 }
 
+/**
+ * `skipNoindex`: the 404 came out of a server action, where robots the page
+ * declared must stay authoritative — the metadata base stops forcing noindex.
+ * A default noindex is still injected when nothing declares robots at all.
+ */
 export async function renderGlobalNotFoundResponse(
   options: Omit<RenderOptions, 'route' | 'params'>,
+  { skipNoindex = false }: { skipNoindex?: boolean } = {},
 ) {
   const globalFile = ['tsx', 'ts', 'jsx', 'js']
     .map(ext => `${options.config.appPath}/global-not-found.${ext}`)
@@ -2526,7 +2532,9 @@ export async function renderGlobalNotFoundResponse(
       renderScopeRequest(notFoundOptions),
       () =>
         runWithFontScope(() =>
-          runWithCacheScope(() => renderNotFoundPage(notFoundOptions, false, { forceDefault })),
+          runWithCacheScope(() =>
+            renderNotFoundPage(notFoundOptions, false, { forceDefault, skipNoindex }),
+          ),
         ),
       {},
     );
@@ -2548,6 +2556,44 @@ export async function renderGlobalNotFoundResponse(
   return response;
 }
 
+/**
+ * notFound() thrown from a Server Action: the URL DID match a route, so render the not-found
+ * boundary within that route (keeping its layout chain and generateMetadata) instead of anchoring
+ * at the app root like renderGlobalNotFoundResponse.
+ */
+export async function renderNotFoundForRoute(
+  options: RenderOptions,
+  { skipNoindex = false }: { skipNoindex?: boolean } = {},
+): Promise<Response> {
+  const notFoundRequest = options.request
+    ? new Request(options.request.url, { headers: options.request.headers })
+    : undefined;
+  const notFoundOptions: RenderOptions = {
+    ...options,
+    ...(notFoundRequest ? { request: notFoundRequest } : {}),
+    status: 404,
+  };
+  const page = await runWithRequest(
+    renderScopeRequest(notFoundOptions),
+    () =>
+      runWithFontScope(() =>
+        runWithCacheScope(() => renderNotFoundPage(notFoundOptions, false, { skipNoindex })),
+      ),
+    {},
+  );
+  const response = new Response(pageStream(page), {
+    status: 404,
+    headers: { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' },
+  });
+  const html = await response.text();
+  const withRobots = html.includes('name="robots"')
+    ? html
+    : html.replace('</head>', '<meta name="robots" content="noindex"/></head>');
+  const headers = new Headers(response.headers);
+  headers.delete('content-length');
+  return new Response(withRobots, { status: response.status, headers });
+}
+
 // Everything after this marker is late metadata, not document bytes: the
 // router's streamed read commits the document at the marker and folds the
 // remainder into the live head.
@@ -3351,9 +3397,14 @@ async function renderTree(
   // is body-streamed anyway, resolve it as a deferred stream chunk instead.
   // Only on an RSC navigation render: a hard document load keeps blocking, so a
   // metadata notFound()/redirect() still owns the whole document.
+  // Captured explicitly: the page body already populated the render's cache() scope, and a deferred
+  // generateMetadata must reuse it or its cache()-wrapped values drift from what the body rendered.
+  const runInCacheScope = captureCacheScope();
   const pendingPageMetadata =
     typeof pageMetadata === 'function' && deferrableNavigationMetadata(options, runtimeMetadataInBody, stream)
-      ? Promise.resolve().then(() => pageMetadata(mergeMetadataEntries(layoutRender.metadata)))
+      ? Promise.resolve().then(() =>
+          runInCacheScope(() => pageMetadata(mergeMetadataEntries(layoutRender.metadata))),
+        )
       : undefined;
   try {
     resolvedPageMetadata = pendingPageMetadata
@@ -4009,9 +4060,16 @@ export function defaultNotFoundDocument(): string {
 async function renderNotFoundPage(
   options: RenderOptions,
   stream: boolean,
-  extra: { status?: number; nextFlightText?: boolean; forceDefault?: boolean } = {},
+  extra: {
+    status?: number;
+    nextFlightText?: boolean;
+    forceDefault?: boolean;
+    skipNoindex?: boolean;
+  } = {},
 ) {
   const status = extra.status ?? 404;
+  // Server-action 404s carry no fallback robots (Next's NonIndex skip).
+  const fallbackRobots = extra.skipNoindex ? {} : { robots: 'noindex' };
   // forceDefault: globalNotFound is enabled but no global-not-found.* exists —
   // skip the app's not-found.* boundary and render the built-in default 404.
   const file = extra.forceDefault ? undefined : nearestConventionFile(options, 'not-found.tsx');
@@ -4021,7 +4079,7 @@ async function renderNotFoundPage(
       notFoundOptions,
       defaultNotFoundTree(),
       stream,
-      { title: '404: This page could not be found.', robots: 'noindex' },
+      { title: '404: This page could not be found.', ...fallbackRobots },
       { status },
     );
     return extra.nextFlightText ? withNextFlightText(page) : page;
@@ -4049,7 +4107,7 @@ async function renderNotFoundPage(
       notFoundOptions,
       defaultNotFoundTree(),
       stream,
-      { title: '404: This page could not be found.', robots: 'noindex' },
+      { title: '404: This page could not be found.', ...fallbackRobots },
       { status },
     );
     return extra.nextFlightText ? withNextFlightText(page) : page;
@@ -4087,7 +4145,7 @@ async function renderNotFoundPage(
     stream,
     // On the skip path a baked `<title>Not found</title>` would precede the
     // streamed metadata chunk in document order and win `document.title`.
-    { robots: 'noindex', ...resolvedMetadata },
+    { ...fallbackRobots, ...resolvedMetadata },
     {
       status,
       ...(resolvedViewport ? { viewport: resolvedViewport } : {}),
@@ -7367,25 +7425,43 @@ function devReloadScript() {
   // unstyled and never loses client state. Anything the server could not prove
   // was CSS-only still arrives as `reload`.
   return `<script data-pnext-dev>
-const events = new EventSource('/__pnext/events');
-events.addEventListener('reload', () => location.reload());
-events.addEventListener('css-update', event => {
-  const links = [...document.querySelectorAll('link[rel=stylesheet]')].filter(link => {
-    try { return new URL(link.href, location.href).origin === location.origin; } catch { return false; }
+let events;
+let generation;
+// The stream is a long-lived connection counted against the browser's per-origin
+// socket cap (6 on HTTP/1.1). A page the browser keeps alive after navigating away
+// (bfcache) holds its own open, so every page load would leak one until the pool is
+// exhausted and further requests stall for minutes. Close on the way out, reopen on
+// restore.
+function connectDevEvents() {
+  events = new EventSource('/__pnext/events');
+  // The server stamps its build generation on connect: a page restored onto a
+  // generation it never saw missed a rebuild while it was disconnected.
+  events.addEventListener('ready', event => {
+    if (generation !== undefined && event.data !== generation) return location.reload();
+    generation = event.data;
+  });
+  events.addEventListener('reload', () => location.reload());
+  events.addEventListener('css-update', event => {
+    const links = [...document.querySelectorAll('link[rel=stylesheet]')].filter(link => {
+      try { return new URL(link.href, location.href).origin === location.origin; } catch { return false; }
+    });
+    if (links.length === 0) { location.reload(); return; }
+    for (const link of links) {
+      const url = new URL(link.href, location.href);
+      url.searchParams.set('__pnext_css', event.data);
+      const next = link.cloneNode();
+      // React tracks precedence-carrying links as its own; the swap is ours.
+      next.removeAttribute('data-precedence');
+      next.href = url.href;
+      const drop = () => link.remove();
+      next.addEventListener('load', drop, { once: true });
+      next.addEventListener('error', drop, { once: true });
+      link.after(next);
+    }
   });
-  if (links.length === 0) { location.reload(); return; }
-  for (const link of links) {
-    const url = new URL(link.href, location.href);
-    url.searchParams.set('__pnext_css', event.data);
-    const next = link.cloneNode();
-    // React tracks precedence-carrying links as its own; the swap is ours.
-    next.removeAttribute('data-precedence');
-    next.href = url.href;
-    const drop = () => link.remove();
-    next.addEventListener('load', drop, { once: true });
-    next.addEventListener('error', drop, { once: true });
-    link.after(next);
-  }
-});
+}
+connectDevEvents();
+addEventListener('pagehide', () => events.close());
+addEventListener('pageshow', event => { if (event.persisted) connectDevEvents(); });
 </script>`;
 }

package/src/resolve/engine.ts

@@ -1,6 +1,16 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { ResolverFactory, type NapiResolveOptions } from 'oxc-resolver';
+import type { ResolverFactory, NapiResolveOptions } from 'oxc-resolver';
+import { loadNative } from '../utils/native-require';
+
+// Lazy: the native binding costs ~1.3 MB RSS and a prod server may never resolve.
+function createResolverFactory(options: NapiResolveOptions): ResolverFactory {
+  const { ResolverFactory: Factory } = loadNative(
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    () => require('oxc-resolver') as typeof import('oxc-resolver'),
+  );
+  return new Factory(options);
+}
 import { clearNodeModulesFsCache } from '../utils/fs-cache';
 
 const sourceExtensions = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.mts', '.cts', '.module.css', '.css'];
@@ -200,7 +210,7 @@ function baseOptions(): NapiResolveOptions {
 }
 
 function baseResolver() {
-  baseFactory ??= new ResolverFactory(baseOptions());
+  baseFactory ??= createResolverFactory(baseOptions());
   return baseFactory;
 }