@wular/pnext 0.0.3 → 0.0.6

package/src/compat/register/static-image.ts

@@ -8,8 +8,8 @@
 // Safe in a pure-core app: the seam only overrides core's generic asset module for recognized image
 // extensions; everything else falls through.
 
-import { setAssetExtensions } from '../../extensions';
-import { staticImageModule } from '../next/image/static-metadata';
+import { setAssetExtensions } from '../../extensions'
+import { staticImageModule } from '../next/image/static-metadata'
 
 export function registerStaticImageExtensions(): void {
   setAssetExtensions({
@@ -17,5 +17,5 @@ export function registerStaticImageExtensions(): void {
     staticAssetRelativePath: ({ base, hash, ext }) =>
       ['_next', 'static', 'media', `${base}.${hash}${ext}`].join('/'),
     staticAssetModule: staticImageModule,
-  });
+  })
 }

package/src/compat/register/{misc.ts → taint.ts}

@@ -8,25 +8,25 @@
 // Kept as an explicit registrar rather than nothing, so future misc features that DO need a registry
 // have an owned place to register without touching another file.
 
-import type { ResolvedConfig } from '../../config';
-import { taintObjectReference } from '../../utils/serialize';
-import { getNextConfig } from '../next/config-loader';
+import type { ResolvedConfig } from '../../config'
+import { taintObjectReference } from '../../utils/serialize'
+import { getNextConfig } from '../next/config-loader'
 
 // Next's `experimental.taint` message for a `process.env` reference reaching a
 // client component (asserted verbatim by test/e2e/app-dir/taint in dev; prod
 // sees the redacted React #441 text via the normal boundary error path).
 const PROCESS_ENV_TAINT_MESSAGE =
-  'Do not pass process.env to Client Components since it will leak sensitive data';
+  'Do not pass process.env to Client Components since it will leak sensitive data'
 
 // Prod redacts every RSC serialization error to React's minified #441 text
 // (test/e2e/app-dir/taint asserts this verbatim for a production build).
 const REDACTED_RSC_ERROR_MESSAGE =
-  'Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.';
+  'Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.'
 
 export function registerMiscExtensions(_config: ResolvedConfig): void {
   // No registry wiring required for the current misc cluster; behavior is
   // activated via direct imports in the action endpoint + client runtime.
-  registerTaintedReferences();
+  registerTaintedReferences()
 }
 
 /**
@@ -35,10 +35,10 @@ export function registerMiscExtensions(_config: ResolvedConfig): void {
  * IS that object throw.
  */
 function registerTaintedReferences(): void {
-  const experimental = getNextConfig().experimental as { taint?: unknown } | undefined;
-  if (experimental?.taint !== true) return;
+  const experimental = getNextConfig().experimental as { taint?: unknown } | undefined
+  if (experimental?.taint !== true) return
   taintObjectReference(
     { dev: PROCESS_ENV_TAINT_MESSAGE, prod: REDACTED_RSC_ERROR_MESSAGE },
     process.env,
-  );
+  )
 }

package/src/compat/register/typed-routes.ts

@@ -3,33 +3,33 @@
 // `<root>/.next/types/{routes.d.ts,link.d.ts,validator.ts}`. Runs during a build under compat.next;
 // pure-core apps register nothing.
 
-import type { ResolvedConfig } from '../../config';
+import type { ResolvedConfig } from '../../config'
 import {
   registerBuildParallelPhases,
   registerBuildSteps,
   type BuildStepContext,
-} from '../../extensions';
-import type { RouteManifestEntry } from '../../types';
-import { nextCompatEnabled } from '../index';
-import { writeTsconfigDefaults } from '../tsconfig-defaults';
-import { typecheckDisabled, validateTypesOffThread } from '../typecheck';
-import { generateTypedRoutes } from '../typed-routes';
+} from '../../extensions'
+import type { RouteManifestEntry } from '../../types'
+import { nextCompatEnabled } from '../aliases'
+import { writeTsconfigDefaults } from '../tsconfig-defaults'
+import { typecheckDisabled, validateTypesOffThread } from '../typecheck/check'
+import { generateTypedRoutes } from '../typed-routes/generate'
 
 export function registerTypedRoutesExtensions(_config: ResolvedConfig): void {
-  registerBuildSteps(runTypedRoutesBuildStep);
+  registerBuildSteps(runTypedRoutesBuildStep)
 }
 
 async function runTypedRoutesBuildStep(ctx: BuildStepContext): Promise<void> {
-  if (!nextCompatEnabled(ctx.config)) return;
-  await writeTsconfigDefaults(ctx.config);
-  await generateTypedRoutes(ctx.config, ctx.routes as RouteManifestEntry[]);
+  if (!nextCompatEnabled(ctx.config)) return
+  await writeTsconfigDefaults(ctx.config)
+  await generateTypedRoutes(ctx.config, ctx.routes as RouteManifestEntry[])
   // The typecheck reads only files that already exist on disk, so it runs on a worker thread
   // alongside client bundling and prerendering rather than ahead of them; the CLI awaits it before
   // the summary. A build that disables it reports no line at all.
-  if (typecheckDisabled()) return;
-  const startedAt = performance.now();
+  if (typecheckDisabled()) return
+  const startedAt = performance.now()
   registerBuildParallelPhases({
     name: 'Typecheck',
     run: validateTypesOffThread(ctx.config).then(() => performance.now() - startedAt),
-  });
+  })
 }

package/src/compat/register/{usecache.ts → use-cache.ts}

@@ -14,8 +14,8 @@
 // lazy-static MISS responses. Emitting it for pure static HITs needs the route's cacheLife persisted in
 // the build manifest and read by the static-serve path in src/cli/start.ts.
 
-import type { ResolvedConfig } from '../../config';
-import { nextCompatEnabled } from '../../compat';
+import type { ResolvedConfig } from '../../config'
+import { nextCompatEnabled } from '../../compat/aliases'
 import {
   onExtensionHostReset,
   registerBuildCompleteHooks,
@@ -23,32 +23,32 @@ import {
   registerResponseFinalizers,
   type ResponseFinalizer,
   type ResponseFinalizerContext,
-} from '../../extensions';
+} from '../../extensions'
 import {
   setUseCacheFillTimeout,
   setUseCacheRootParamNames,
   takeCacheLifeStash,
-} from '../cache/use-cache';
-import { scanRootParams } from '../ppr/root-params-scan';
+} from '../cache/use-cache'
+import { scanRootParams } from '../ppr/root-params-scan'
 import {
   beginPrerenderErrorCollection,
   endPrerenderErrorCollection,
-} from '../cache/build-prerender-errors';
-import { getNextConfig } from '../next/config-loader';
+} from '../cache/build-prerender-errors'
+import { getNextConfig } from '../next/config-loader'
 
 // Route kinds a `use cache` page/handler can be served as.
 const CACHEABLE_ROUTE_KINDS = new Set<ResponseFinalizerContext['routeKind']>([
   'html',
   'data',
   'route-handler',
-]);
+])
 
 const useCacheHeaderFinalizer: ResponseFinalizer = ctx => {
-  const life = takeCacheLifeStash();
-  if (!life) return;
-  if (!CACHEABLE_ROUTE_KINDS.has(ctx.routeKind)) return;
+  const life = takeCacheLifeStash()
+  if (!life) return
+  if (!CACHEABLE_ROUTE_KINDS.has(ctx.routeKind)) return
 
-  const { revalidateSeconds, expireSeconds, staleSeconds } = life;
+  const { revalidateSeconds, expireSeconds, staleSeconds } = life
 
   // SWR cache-control: s-maxage = revalidate, stale-while-revalidate =
   // expire − revalidate. Emitted only when a revalidate window is known and no
@@ -58,8 +58,8 @@ const useCacheHeaderFinalizer: ResponseFinalizer = ctx => {
     expireSeconds !== undefined &&
     !ctx.headers.has('cache-control')
   ) {
-    const swr = Math.max(0, expireSeconds - revalidateSeconds);
-    ctx.headers.set('cache-control', `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`);
+    const swr = Math.max(0, expireSeconds - revalidateSeconds)
+    ctx.headers.set('cache-control', `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`)
   }
 
   // x-nextjs-stale-time drives the client router's cache staleness window.
@@ -67,24 +67,24 @@ const useCacheHeaderFinalizer: ResponseFinalizer = ctx => {
   // mode-derived default, but the live render's own cacheLife is authoritative
   // (the header is internal — never user-supplied — so overwriting is safe).
   if (staleSeconds !== undefined) {
-    ctx.headers.set('x-nextjs-stale-time', String(staleSeconds));
+    ctx.headers.set('x-nextjs-stale-time', String(staleSeconds))
   }
-};
+}
 
-let registered = false;
+let registered = false
 // Host-scoped guard: a fresh host must be registered into again.
-onExtensionHostReset(() => (registered = false));
+onExtensionHostReset(() => (registered = false))
 
 export function registerUseCacheExtensions(config: ResolvedConfig): void {
-  if (registered) return;
-  if (!nextCompatEnabled(config)) return;
-  registered = true;
-  registerResponseFinalizers(useCacheHeaderFinalizer);
+  if (registered) return
+  if (!nextCompatEnabled(config)) return
+  registered = true
+  registerResponseFinalizers(useCacheHeaderFinalizer)
 
   // Seed the root-param NAME set for cache-key participation (Stage B-3): a
   // `use cache` entry's conservative first-call key may only discriminate by
   // root params, so the runtime needs the scanned names at build AND serve.
-  setUseCacheRootParamNames(scanRootParams(config.appPath));
+  setUseCacheRootParamNames(scanRootParams(config.appPath))
 
   // Arm `use cache` build-time validation for this build's prerender pass.
   // Registered as a build STEP so it runs before any page is prerendered; the
@@ -93,32 +93,32 @@ export function registerUseCacheExtensions(config: ResolvedConfig): void {
   registerBuildSteps(ctx => {
     if (nextCompatEnabled(ctx.config)) {
       const config = getNextConfig() as {
-        experimental?: { useCacheTimeout?: number };
-        staticPageGenerationTimeout?: number;
-      };
-      const configured = config.experimental?.useCacheTimeout;
-      const staticTimeout = config.staticPageGenerationTimeout;
+        experimental?: { useCacheTimeout?: number }
+        staticPageGenerationTimeout?: number
+      }
+      const configured = config.experimental?.useCacheTimeout
+      const staticTimeout = config.staticPageGenerationTimeout
       // Next clamps the build-time `use cache` fill timeout to just under the
       // page-generation timeout (1s buffer before the build worker kills the
       // page), so a slow fill fails via the clamp rather than the worker.
-      const baseMs = typeof configured === 'number' ? configured * 1000 : 50_000;
+      const baseMs = typeof configured === 'number' ? configured * 1000 : 50_000
       const clampMs =
         typeof staticTimeout === 'number' && staticTimeout > 1
           ? (staticTimeout - 1) * 1000
-          : undefined;
-      const fillMs = clampMs !== undefined ? Math.min(baseMs, clampMs) : baseMs;
-      setUseCacheFillTimeout(fillMs);
-      beginPrerenderErrorCollection();
+          : undefined
+      const fillMs = clampMs !== undefined ? Math.min(baseMs, clampMs) : baseMs
+      setUseCacheFillTimeout(fillMs)
+      beginPrerenderErrorCollection()
     }
-    return Promise.resolve();
-  });
+    return Promise.resolve()
+  })
 
   // After prerendering, surface any recorded `use cache` violations. Each is
   // printed with Next's exact error text plus the "Error occurred prerendering
   // page" line the e2e suites grep for, then the build is aborted (exit 1).
   registerBuildCompleteHooks(ctx => {
-    const errors = endPrerenderErrorCollection();
-    if (!nextCompatEnabled(ctx.config) || errors.length === 0) return Promise.resolve();
+    const errors = endPrerenderErrorCollection()
+    if (!nextCompatEnabled(ctx.config) || errors.length === 0) return Promise.resolve()
     // Messages were already printed at detection time (see recordPrerenderError);
     // the hook only forces the non-zero exit for builds that otherwise completed
     // (a swallowed hanging timeout or a caught searchParams access).
@@ -126,6 +126,6 @@ export function registerUseCacheExtensions(config: ResolvedConfig): void {
       `pnext build: ${errors.length} "use cache" validation error${
         errors.length === 1 ? '' : 's'
       } (see above)`,
-    );
-  });
+    )
+  })
 }

package/src/compat/register/validation.ts

@@ -7,50 +7,50 @@
 // The step is ordered FIRST among build steps (registered before action discovery) so validation fails
 // fast, before any bundling or prerender work. Registration is idempotent and no-op for pure-core apps.
 
-import type { ResolvedConfig } from '../../config';
-import { nextCompatEnabled } from '../../compat';
+import type { ResolvedConfig } from '../../config'
+import { nextCompatEnabled } from '../../compat/aliases'
 import {
   onExtensionHostReset,
   registerBuildSteps,
   setBuildCompatExtensions,
   type BuildStep,
-} from '../../extensions';
-import type { RouteManifestEntry } from '../../types';
-import { writeBuildFlags } from '../cache/build-flags';
-import { validateBuild } from '../validation';
+} from '../../extensions'
+import type { RouteManifestEntry } from '../../types'
+import { writeBuildFlags } from '../cache/build-flags'
+import { validateBuild } from '../validation/validate'
 import {
   diagnoseCacheComponentsPrerender,
   diagnosticLeadsWithErrorLine,
   prerenderFailureFooter,
-} from '../validation/prerender-diagnostics';
+} from '../validation/prerender-diagnostics'
 
-let registered = false;
+let registered = false
 // Host-scoped guard: a fresh host must be registered into again.
-onExtensionHostReset(() => (registered = false));
+onExtensionHostReset(() => (registered = false))
 
 export function registerValidationExtensions(config: ResolvedConfig): void {
-  if (registered) return;
-  if (!nextCompatEnabled(config)) return;
-  registered = true;
+  if (registered) return
+  if (!nextCompatEnabled(config)) return
+  registered = true
 
   const step: BuildStep = async ctx => {
     // Runtime compat gate: the extension registry is process-global, so once any compat.next build
     // registers this step it stays registered for every later buildProject() in the same process -
     // including pure-core fixtures that legitimately have no root layout. Re-check enablement per build so
     // validation only runs for the app that actually enabled compat.next.
-    if (!nextCompatEnabled(ctx.config)) return;
+    if (!nextCompatEnabled(ctx.config)) return
     await ctx.log.step('validate build', () =>
       Promise.resolve(validateBuild(ctx.config, ctx.routes as RouteManifestEntry[])),
-    );
-  };
+    )
+  }
   // Gate step: validation diagnostics must beat any error the invalid app would
   // otherwise raise first from bundling or the not-found prerender.
-  step.gate = true;
-  registerBuildSteps(step);
+  step.gate = true
+  registerBuildSteps(step)
   setBuildCompatExtensions({
     diagnoseCacheComponentsPrerender,
     diagnosticLeadsWithErrorLine,
     prerenderFailureFooter,
     recordBuildFlags: writeBuildFlags,
-  });
+  })
 }

package/src/compat/segment/loading-boundary.ts

@@ -9,8 +9,9 @@
 // must be imported from `react` AND used as JSX in the scanned source. Missing a boundary only leaves the
 // route on today's segment-miss path, so false negatives are the safe direction.
 
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import path from 'node:path'
+import { escapeRegex as escapeRegExp } from '../../utils/code'
 
 /**
  * True when the route's PAGE file wraps content in a React `<Suspense>`.
@@ -22,44 +23,45 @@ import path from 'node:path';
  * bound keeps a cyclic re-export from looping) before scanning.
  */
 export function pageHasInPageSuspense(file: string): boolean {
-  return scanSourceOf(file, 2).some(sourceHasInPageSuspense);
+  return scanSourceOf(file, 2).some(sourceHasInPageSuspense)
 }
 
 /** `file`'s source plus the sources of its relative re-export targets. */
 function scanSourceOf(file: string, depth: number, seen = new Set<string>()): string[] {
-  const resolved = resolveSourceFile(file);
-  if (resolved === null || seen.has(resolved)) return [];
-  seen.add(resolved);
-  let source: string;
+  const resolved = resolveSourceFile(file)
+  if (resolved === null || seen.has(resolved)) return []
+  seen.add(resolved)
+  let source: string
   try {
-    source = readFileSync(resolved, 'utf8');
+    source = readFileSync(resolved, 'utf8')
   } catch {
-    return [];
+    return []
   }
-  const sources = [source];
-  if (depth <= 0) return sources;
-  const pattern = /(?:export|import)\s+(?:\*(?:\s+as\s+[\w$]+)?|\{[^}]*\})\s+from\s*['"](\.[^'"]+)['"]/g;
-  let match: RegExpExecArray | null;
+  const sources = [source]
+  if (depth <= 0) return sources
+  const pattern =
+    /(?:export|import)\s+(?:\*(?:\s+as\s+[\w$]+)?|\{[^}]*\})\s+from\s*['"](\.[^'"]+)['"]/g
+  let match: RegExpExecArray | null
   while ((match = pattern.exec(source)) !== null) {
-    const specifier = match[1];
-    if (!specifier) continue;
-    sources.push(...scanSourceOf(path.resolve(path.dirname(resolved), specifier), depth - 1, seen));
+    const specifier = match[1]
+    if (!specifier) continue
+    sources.push(...scanSourceOf(path.resolve(path.dirname(resolved), specifier), depth - 1, seen))
   }
-  return sources;
+  return sources
 }
 
 /** `file` itself, or the first existing extension/index candidate for it. */
 function resolveSourceFile(file: string): string | null {
-  if (existsSync(file) && statSync(file).isFile()) return file;
+  if (existsSync(file) && statSync(file).isFile()) return file
   for (const extension of SOURCE_EXTENSIONS) {
     for (const candidate of [`${file}${extension}`, path.join(file, `index${extension}`)]) {
-      if (existsSync(candidate)) return candidate;
+      if (existsSync(candidate)) return candidate
     }
   }
-  return null;
+  return null
 }
 
-const SOURCE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs'];
+const SOURCE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs']
 
 /**
  * True when `source` imports `Suspense` from React and uses it as a JSX element. Comments are stripped
@@ -67,47 +69,43 @@ const SOURCE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs'];
  * named import and the namespace/default form are recognized.
  */
 export function sourceHasInPageSuspense(source: string): boolean {
-  const stripped = stripComments(source);
-  const clauses = reactImportClauses(stripped);
-  if (clauses.length === 0) return false;
-  const named = clauses.some(clause => /\bSuspense\b/.test(clause));
-  if (named && /<\s*Suspense[\s/>]/.test(stripped)) return true;
+  const stripped = stripComments(source)
+  const clauses = reactImportClauses(stripped)
+  if (clauses.length === 0) return false
+  const named = clauses.some(clause => /\bSuspense\b/.test(clause))
+  if (named && /<\s*Suspense[\s/>]/.test(stripped)) return true
   // `<React.Suspense>` / `<Foo.Suspense>` needs a default or namespace binding
   // of the react module under that name.
   return namespaceBindings(clauses).some(name =>
     new RegExp(`<\\s*${escapeRegExp(name)}\\.Suspense[\\s/>]`).test(stripped),
-  );
+  )
 }
 
 /** The import clauses of every `... from 'react'` statement in `source`. */
 function reactImportClauses(source: string): string[] {
-  const clauses: string[] = [];
-  const pattern = /import\s+([^'"]*?)\s+from\s*['"]react['"]/g;
-  let match: RegExpExecArray | null;
-  while ((match = pattern.exec(source)) !== null) clauses.push(match[1] ?? '');
+  const clauses: string[] = []
+  const pattern = /import\s+([^'"]*?)\s+from\s*['"]react['"]/g
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(source)) !== null) clauses.push(match[1] ?? '')
   // `const React = require('react')` — the CJS form app code still uses.
-  const cjs = /(?:const|let|var)\s+([\w$]+)\s*=\s*require\(\s*['"]react['"]\s*\)/g;
-  while ((match = cjs.exec(source)) !== null) clauses.push(`* as ${match[1] ?? ''}`);
-  return clauses;
+  const cjs = /(?:const|let|var)\s+([\w$]+)\s*=\s*require\(\s*['"]react['"]\s*\)/g
+  while ((match = cjs.exec(source)) !== null) clauses.push(`* as ${match[1] ?? ''}`)
+  return clauses
 }
 
 /** Names bound to the whole react module by an import clause (default/namespace). */
 function namespaceBindings(clauses: readonly string[]): string[] {
-  const names: string[] = [];
+  const names: string[] = []
   for (const clause of clauses) {
-    const namespace = /\*\s+as\s+([\w$]+)/.exec(clause);
-    if (namespace?.[1]) names.push(namespace[1]);
+    const namespace = /\*\s+as\s+([\w$]+)/.exec(clause)
+    if (namespace?.[1]) names.push(namespace[1])
     // A default binding precedes any `{ ... }` named list.
-    const fallback = /^\s*([\w$]+)\s*(?:,|$)/.exec(clause.split('{')[0] ?? '');
-    if (fallback?.[1] && fallback[1] !== '*') names.push(fallback[1]);
+    const fallback = /^\s*([\w$]+)\s*(?:,|$)/.exec(clause.split('{')[0] ?? '')
+    if (fallback?.[1] && fallback[1] !== '*') names.push(fallback[1])
   }
-  return names;
+  return names
 }
 
 function stripComments(source: string): string {
-  return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1');
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1')
 }