@wular/pnext 0.0.2 → 0.0.3

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;
 }
 

package/src/resolve/scan-facts.ts

@@ -10,7 +10,11 @@
 // The same parse also backs `rewriteFacts`: the record-shaped rewrite passes (specifier aliasing, namespace
 // imports, import.meta.url) splice byte spans off it instead of re-scanning the source with their own
 // regexes.
-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 { spliceSource } from '../dev/module-transform';
 
 export interface ScanEdge {

package/src/routing/href.ts

@@ -28,14 +28,13 @@ declare global {
 // once per process by the server runtime from the resolved config. On the
 // client the value is read from the injected window global (register-render's
 // trailingSlashScript), mirroring basePath / skipTrailingSlash.
-let trailingSlashUrls = false;
-
+// Anchored on globalThis, not a module local: this module is dual-copied into
+// the client/prebundled bundles, where setTrailingSlashUrls never runs.
 export function setTrailingSlashUrls(enabled: boolean) {
-  trailingSlashUrls = enabled;
+  globalThis.__PNEXT_TRAILING_SLASH__ = enabled;
 }
 
 function isTrailingSlashEnabled(): boolean {
-  if (trailingSlashUrls) return true;
   if (process.browser || typeof window !== 'undefined') return window.__PNEXT_TRAILING_SLASH__ === true;
   return globalThis.__PNEXT_TRAILING_SLASH__ === true;
 }
@@ -76,7 +75,7 @@ export function withBasePath(path: string) {
 export function applyTrailingSlash(pathname: string) {
   const [, path = '', rest = ''] = /^([^?#]*)([\s\S]*)$/.exec(pathname) ?? [];
   if (!path.startsWith('/')) return pathname;
-  if (trailingSlashUrls) {
+  if (isTrailingSlashEnabled()) {
     // Add the canonical trailing slash (skip root, already-slashed, and files).
     if (path === '/' || path.endsWith('/') || /\.[^/]+$/.test(path)) return pathname;
     return `${path}/${rest}`;

package/src/routing/routes.ts

@@ -340,7 +340,11 @@ export function setRouteFactsStore(store: RouteFactsStore | undefined) {
   factsStore = store;
 }
 
-function withDeferredFacts(base: RoutePathEntry, compute: () => RouteFacts): RouteManifestEntry {
+function withDeferredFacts(
+  appPath: string,
+  base: RoutePathEntry,
+  compute: () => RouteFacts,
+): RouteManifestEntry {
   const entry = base as RouteManifestEntry;
   let facts: RouteFacts | undefined;
   // Consumers still assign some of these (the build marks needsRouterEntry), so
@@ -355,7 +359,10 @@ function withDeferredFacts(base: RoutePathEntry, compute: () => RouteFacts): Rou
       get() {
         if (overrides.has(field)) return overrides.get(field);
         if (!facts) {
-          const key = `${base.kind}:${base.id}`;
+          // Route ids repeat across apps ('page:/' everywhere), so the app the
+          // facts were derived in is part of the key - otherwise one app's
+          // record answers another app's lookup in the same process.
+          const key = `${appPath}\0${base.kind}:${base.id}`;
           const stored = factsStore?.load(key);
           facts = stored ?? withDirCache(compute);
           if (!stored) factsStore?.save(key, facts);
@@ -415,6 +422,7 @@ function buildRouteTable(appPath: string, files: string[]): RouteManifestEntry[]
       if (!metadataParts) continue;
       routes.push(
         withDeferredFacts(
+          appPath,
           {
             id: `metadata-${routeId(metadataParts.route)}`,
             kind: 'handler',
@@ -462,6 +470,7 @@ function buildRouteTable(appPath: string, files: string[]): RouteManifestEntry[]
     const interception = parts.interception;
     routes.push(
       withDeferredFacts(
+        appPath,
         {
           id: interception ? `intercept-${sanitizeIdPart(routeDir)}` : routeId(parts.route || '/'),
           kind,
@@ -844,6 +853,7 @@ function appendSlotDerivedRoutes(
       // interceptor during slot rendering. Kept minimal on purpose.
       routes.push(
         withDeferredFacts(
+          appPath,
           {
             id: `intercept-${sanitizeIdPart(candidate.relative.replace(pageOrRouteTrailing(), ''))}`,
             kind: 'page',
@@ -905,6 +915,7 @@ function appendSlotDerivedRoutes(
 
     routes.push(
       withDeferredFacts(
+        appPath,
         {
           id: `slot-${routeId(parts.route || '/')}`,
           kind: 'page',
@@ -1050,6 +1061,7 @@ function appendDefaultDerivedRoutes(
 
     routes.push(
       withDeferredFacts(
+        appPath,
         {
           id: `default-${routeId(parts.route || '/')}`,
           kind: 'page',

package/src/runtime/server.ts

@@ -4,7 +4,8 @@ import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { copyFile, mkdir, readFile, rm, stat, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { build, transform, type Loader, type Metafile, type OnLoadResult, type OnResolveResult, type Plugin } from 'esbuild';
+import type { Loader, Metafile, OnLoadResult, OnResolveResult, Plugin } from 'esbuild';
+import { build, transform } from '../utils/esbuild';
 import {
   applyBundledSourceTransforms,
   applyServerSourcePreTransforms,
@@ -2836,9 +2837,12 @@ async function bundleExternalPackageImpl(
     resolvedEntry?.match(/\.[cm]?tsx?$/) &&
     !getExternalPackagePolicy().transpile(packageName)
   ) {
-    throw new Error(
-      `${path.relative(config.root, resolvedEntry)}\nModule parse failed: Unexpected token`,
-    );
+    const parseFailure = `${path.relative(config.root, resolvedEntry)}\nModule parse failed: Unexpected token`;
+    // Printed directly as well: the digest log path inspects the error's stack,
+    // which some runtimes emit without the message - the CLI output must always
+    // carry the parse failure (Next's transpilePackages error contract).
+    console.error(`⨯ Error: ${parseFailure}`);
+    throw new Error(parseFailure);
   }
   const entry =
     requiredEntry ??

package/src/runtime/vendor.ts

@@ -37,7 +37,7 @@ import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
 import { copyFile, mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
+import { build } from '../utils/esbuild';
 import { isCommonJsModuleSource } from '../resolve/imports';
 import { outputSpecifiers } from '../dev/module-transform';
 import { escapeRegex, isIdentifier, uniqueIdentifier } from '../utils/source';

package/src/typegen.ts

@@ -25,7 +25,7 @@ export async function writeTypegen(
   allRoutes: RouteManifestEntry[],
 ): Promise<TypegenResult> {
   const routes = allRoutes.filter(route => !route.interception && !route.synthetic);
-  const file = path.join(config.outPath, 'types', 'pnext.gen.d.ts');
+  const file = path.join(config.typesPath, 'pnext.gen.d.ts');
   const source = typegenSource(routes);
   await writeIfChanged(file, source);
   const aliases = await writeRouteAliases(config, routes);
@@ -57,7 +57,7 @@ function routeEntry(route: RouteManifestEntry) {
 }
 
 async function writeChecks(config: ResolvedConfig, routes: RouteManifestEntry[]) {
-  const checksDir = path.join(config.outPath, 'types', 'checks');
+  const checksDir = path.join(config.typesPath, 'checks');
   await rm(checksDir, { recursive: true, force: true });
   await ensureDir(checksDir);
 
@@ -72,7 +72,7 @@ async function writeChecks(config: ResolvedConfig, routes: RouteManifestEntry[])
 }
 
 async function writeRouteAliases(config: ResolvedConfig, routes: RouteManifestEntry[]) {
-  const aliasesDir = path.join(config.outPath, 'types', 'app');
+  const aliasesDir = path.join(config.typesPath, 'app');
   await rm(aliasesDir, { recursive: true, force: true });
   await ensureDir(aliasesDir);
 

package/src/utils/esbuild.ts

@@ -0,0 +1,58 @@
+// Lazy esbuild facade: importing 'esbuild' eagerly costs ~2.7 MB RSS and its
+// first build()/transform() call spawns a resident ~10-45 MB service child, so
+// the library must not load until something actually compiles.
+import type * as Esbuild from 'esbuild';
+import { loadNative } from './native-require';
+
+let esbuild: typeof Esbuild | undefined;
+
+function load(): typeof Esbuild {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  return (esbuild ??= loadNative(() => require('esbuild') as typeof Esbuild));
+}
+
+// In-flight compiles, so a stop() never kills the service child out from under
+// one: esbuild drops the pending call's promise and it never settles.
+let inFlight = 0;
+let stopWhenIdle = false;
+
+function track<T>(promise: Promise<T>): Promise<T> {
+  inFlight += 1;
+  return promise.finally(() => {
+    inFlight -= 1;
+    if (inFlight === 0 && stopWhenIdle) {
+      stopWhenIdle = false;
+      void esbuild?.stop();
+    }
+  });
+}
+
+export const build: typeof Esbuild.build = options => track(load().build(options));
+
+export const transform: typeof Esbuild.transform = (input, options) =>
+  track(load().transform(input, options));
+
+/**
+ * Spawn the resident service child ahead of the first real compile. Fire-and-forget: the spawn and
+ * its handshake are subprocess work, so a caller holding wall-clock it does not control (a dev boot,
+ * which compiles nothing before it listens) can absorb a cost the first compile would otherwise pay.
+ */
+export function warmEsbuildService(): void {
+  void transform('', { loader: 'js' }).catch(() => undefined);
+}
+
+/**
+ * Kill the resident esbuild service child (a prod server is done compiling
+ * after its boot config build). No-op when esbuild never loaded; the service
+ * respawns transparently on the next build()/transform() call. Deferred while a
+ * compile is in flight — instrumentation register() bundles concurrently with
+ * server boot, and killing the service mid-build hangs it forever.
+ */
+export function stopEsbuildService(): void {
+  if (!esbuild) return;
+  if (inFlight > 0) {
+    stopWhenIdle = true;
+    return;
+  }
+  void esbuild.stop();
+}

package/src/utils/fs.ts

@@ -92,9 +92,21 @@ export function listFilesSync(root: string): string[] {
   return out;
 }
 
-export async function ensureEmptyDir(dir: string) {
-  await rm(dir, { recursive: true, force: true });
+/** Empty `dir`, leaving the named top-level entries (and their contents) in place. */
+export async function ensureEmptyDir(dir: string, keep: readonly string[] = []) {
+  if (keep.length === 0) {
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    return;
+  }
   await mkdir(dir, { recursive: true });
+  const preserved = new Set(keep);
+  const entries = await readdir(dir).catch(() => [] as string[]);
+  await Promise.all(
+    entries
+      .filter(entry => !preserved.has(entry))
+      .map(entry => rm(path.join(dir, entry), { recursive: true, force: true })),
+  );
 }
 
 export async function ensureDir(dir: string) {

package/src/utils/native-require.ts

@@ -0,0 +1,28 @@
+// Native-binding loader guard.
+//
+// The lazy `require('esbuild' | 'oxc-*' | 'lightningcss')` facades defer a native binding until
+// something actually compiles/parses/resolves - which means the FIRST load can land anywhere, including
+// inside a render the compat edge runtime is wrapping. That runtime swaps a `process` proxy onto
+// globalThis which hides `version`/`versions` (Next parity: user code must not detect Node there), and
+// these loaders read `process.versions.node` / `process.versions.pnp` while initializing - so the
+// require throws. Load them against the real process instead; the module cache then holds a good copy
+// for every later call.
+import realProcess from 'node:process';
+
+export function loadNative<T>(load: () => T): T {
+  const globalObject = globalThis as typeof globalThis & { process?: NodeJS.Process };
+  if (globalObject.process === realProcess) return load();
+  const previous = Object.getOwnPropertyDescriptor(globalObject, 'process');
+  Object.defineProperty(globalObject, 'process', {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: realProcess,
+  });
+  try {
+    return load();
+  } finally {
+    if (previous) Object.defineProperty(globalObject, 'process', previous);
+    else delete (globalObject as { process?: NodeJS.Process }).process;
+  }
+}