@wular/pnext 0.0.4 → 0.0.6

package/src/compat/register/boot.ts

@@ -15,7 +15,7 @@
 // full tier that re-assign a value set here re-assign the SAME implementation, so the two tiers cannot
 // disagree.
 
-import type { ResolvedConfig } from '../../config';
+import type { ResolvedConfig } from '../../config'
 import {
   getProxyExtensions,
   onExtensionHostReset,
@@ -26,13 +26,13 @@ import {
   setCssExtensions,
   setImportAliasExtensions,
   setProxyExtensions,
-} from '../../extensions';
-import { findProxyFiles } from '../../proxy';
+} from '../../extensions'
+import { findProxyFiles } from '../../routing/proxy'
 import {
   packageNameOfSpecifier,
   resolvePackageSpecifier,
   setModuleAliases,
-} from '../../resolve/imports';
+} from '../../resolve/imports'
 import {
   compatAliases,
   missingCompatImportError,
@@ -41,58 +41,58 @@ import {
   reactCompatEnabled,
   reactCompilerOptions,
   reactServerLayerAliases,
-} from '../index';
-import { transpilePackages } from '../bundler/config';
-import { materializeNextCssSources, nextCssResolveDependency } from '../css/modules';
-import { getNextConfig } from '../next/config-loader';
-import { registerLifecycleBootHooks } from './lifecycle';
-import { registerRoutingExtensions } from './routing';
+} from '../aliases'
+import { transpilePackages } from '../bundler/config'
+import { materializeNextCssSources, nextCssResolveDependency } from '../css/modules'
+import { getNextConfig } from '../next/config-loader'
+import { registerLifecycleBootHooks } from './lifecycle'
+import { registerRoutingExtensions } from './routing'
 
 /** Proxy entrypoint basenames Next supports (`middleware` is the legacy name). */
-const NEXT_PROXY_NAMES = ['proxy', 'middleware'];
+const NEXT_PROXY_NAMES = ['proxy', 'middleware']
 
 // Extensions core already carries as page/convention files (base list in
 // routes.ts). Registering one of these is a no-op, so we filter them out and
 // only register the genuinely-extra ones a configured pageExtensions adds.
-const CORE_BASE_PAGE_EXTENSIONS = new Set(['tsx', 'ts', 'jsx', 'js', 'mjs']);
+const CORE_BASE_PAGE_EXTENSIONS = new Set(['tsx', 'ts', 'jsx', 'js', 'mjs'])
 
-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 registerCompatBootExtensions(config: ResolvedConfig): void {
-  if (registered) return;
-  registered = true;
+  if (registered) return
+  registered = true
 
   setCompatModeExtensions({
     nextEnabled: nextCompatEnabled,
     reactEnabled: reactCompatEnabled,
     reactCompilerOptions,
-  });
+  })
   setImportAliasExtensions({
     aliases: compatAliases,
     clientSsrAliases: cfg => nextCompatAliases(cfg, 'server'),
     missingImportError: missingCompatImportError,
     reactServerLayerAliases,
-  });
+  })
   // Route scanning (client-reference/boundary detection) resolves imports statically, with no per-call
   // config to consult - register the same bare-specifier aliases the bundler uses so a server component
   // importing e.g. `next/form` still resolves to its compat file and gets walked for 'use client'
   // detection.
-  setModuleAliases(compatAliases(config, 'server'));
-  registerRoutingExtensions(config);
-  registerLifecycleBootHooks(config);
+  setModuleAliases(compatAliases(config, 'server'))
+  registerRoutingExtensions(config)
+  registerLifecycleBootHooks(config)
 
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
 
-  registerCompatPageExtensions();
-  setBundlerExtensions({ resolveRouteDependency: resolveTranspiledRouteDependency() });
-  materializeNextCssSources(config);
+  registerCompatPageExtensions()
+  setBundlerExtensions({ resolveRouteDependency: resolveTranspiledRouteDependency() })
+  materializeNextCssSources(config)
   setCssExtensions({
     extraCssExtensions: () => ['.scss', '.sass'],
     resolveCssDependency: nextCssResolveDependency(config),
-  });
-  setProxyExtensions({ names: NEXT_PROXY_NAMES, validateFiles: validateProxyFiles });
+  })
+  setProxyExtensions({ names: NEXT_PROXY_NAMES, validateFiles: validateProxyFiles })
 }
 
 /**
@@ -103,30 +103,30 @@ export function registerCompatBootExtensions(config: ResolvedConfig): void {
  * matching MDX compilation is wired later, in register-mdx.
  */
 function registerCompatPageExtensions(): void {
-  const configured = getNextConfig().pageExtensions;
+  const configured = getNextConfig().pageExtensions
   if (Array.isArray(configured)) {
     const extras = configured.filter(
       (ext): ext is string =>
         typeof ext === 'string' && ext.length > 0 && !CORE_BASE_PAGE_EXTENSIONS.has(ext),
-    );
-    if (extras.length > 0) registerPageExtensions(...extras);
+    )
+    if (extras.length > 0) registerPageExtensions(...extras)
   }
   // Imported markdown is loadable even when not routable: `pageExtensions:
   // ['mdx']` still allows `import Doc from './x.md'` through @next/mdx's
-  // /\.mdx?$/ rule, and the server runtime compiles both (dev/imports,
+  // /\.mdx?$/ rule, and the server runtime compiles both (runtime/modules,
   // transformSource). Without this the Bun load plugin never claims `.md` and
   // the import falls through to the file loader (default export = the path).
-  registerLoadableExtensions('mdx', 'md');
+  registerLoadableExtensions('mdx', 'md')
 }
 
 /** B7 `transpilePackages` resolution used by the route scanner's module walk. */
 function resolveTranspiledRouteDependency() {
-  const transpile = new Set(transpilePackages());
+  const transpile = new Set(transpilePackages())
   return (root: string, fromFile: string, specifier: string): string | undefined => {
-    const packageName = packageNameOfSpecifier(specifier);
-    if (!packageName || !transpile.has(packageName)) return undefined;
-    return resolvePackageSpecifier(root, fromFile, specifier, ['import', 'browser', 'default']);
-  };
+    const packageName = packageNameOfSpecifier(specifier)
+    if (!packageName || !transpile.has(packageName)) return undefined
+    return resolvePackageSpecifier(root, fromFile, specifier, ['import', 'browser', 'default'])
+  }
 }
 
 /**
@@ -134,8 +134,8 @@ function resolveTranspiledRouteDependency() {
  * implementation - for everyone else this is the whole cost of proxy support at boot.
  */
 async function validateProxyFiles(config: ResolvedConfig): Promise<void> {
-  if (findProxyFiles(config, NEXT_PROXY_NAMES).length === 0) return;
-  const { registerProxyExtensions } = await import('./proxy');
-  registerProxyExtensions(config);
-  await getProxyExtensions().validateFiles(config);
+  if (findProxyFiles(config, NEXT_PROXY_NAMES).length === 0) return
+  const { registerProxyExtensions } = await import('./proxy')
+  registerProxyExtensions(config)
+  await getProxyExtensions().validateFiles(config)
 }

package/src/compat/register/build-tier.ts

@@ -4,8 +4,8 @@
 // fattest part of the full tier. Kept behind one dynamic import so registerCompatExtensions can skip
 // loading them entirely when it is only being asked to serve; the call order is unchanged either way.
 
-export { registerBuildCompatExtensions } from './build';
-export { registerTypedRoutesExtensions } from './typed-routes';
-export { registerValidationExtensions } from './validation';
-export { registerMiddlewareExtensions } from './middleware';
-export { registerExportExtensions } from './export';
+export { registerBuildCompatExtensions } from './build'
+export { registerTypedRoutesExtensions } from './typed-routes'
+export { registerValidationExtensions } from './validation'
+export { registerMiddlewareExtensions } from './middleware'
+export { registerExportExtensions } from './export'

package/src/compat/register/build.ts

@@ -1,22 +1,26 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
 import {
   registerBuildCompleteHooks,
   setBuildCompatExtensions,
   setCompatModeExtensions,
-} from '../../extensions';
-import type { BuildManifest } from '../../types';
-import type { ResolvedConfig } from '../../config';
-import { nextCompatEnabled, reactCompatEnabled, reactCompilerOptions } from '../index';
-import { warnNextMetadataBuildIssues } from '../metadata';
-import { getNextConfig } from '../next/config-loader';
-import { preferredRegionForRoute } from '../next/preferred-region';
-import { deploymentId } from '../bundler/config';
-import { aliasGenerateStaticParams } from '../static-params';
-import { takeCacheLifeStash } from '../cache/use-cache';
-import { varyNamesFor, withVaryParamsTracking, type ResponseVaryParams } from '../segment/vary-params';
-import { takeFontHeaderPreloads, fontLinkHeaderValue } from '../next/font/runtime';
-import { takeResourceHintHeader } from '../next/resource-hints';
+} from '../../extensions'
+import type { BuildManifest } from '../../types'
+import type { ResolvedConfig } from '../../config'
+import { nextCompatEnabled, reactCompatEnabled, reactCompilerOptions } from '../aliases'
+import { warnNextMetadataBuildIssues } from '../metadata'
+import { getNextConfig } from '../next/config-loader'
+import { preferredRegionForRoute } from '../next/preferred-region'
+import { deploymentId } from '../bundler/config'
+import { aliasGenerateStaticParams } from '../static-params'
+import { takeCacheLifeStash } from '../cache/use-cache'
+import {
+  varyNamesFor,
+  withVaryParamsTracking,
+  type ResponseVaryParams,
+} from '../segment/vary-params'
+import { takeFontHeaderPreloads, fontLinkHeaderValue } from '../next/font/runtime'
+import { takeResourceHintHeader } from '../next/resource-hints'
 import {
   bodySegmentFile,
   buildRootTreePrefetch,
@@ -27,41 +31,38 @@ import {
   segmentDir,
   segmentMetaFile,
   treeSegmentFile,
-} from '../segment/tree';
-import { runBuildCompleteAdapter } from '../adapter/build-complete';
+} from '../segment/tree'
+import { runBuildCompleteAdapter } from '../export/build-complete'
 
 export function registerBuildCompatExtensions(): void {
   registerBuildCompleteHooks(({ config, manifest }) =>
     writeFunctionsConfigManifest(config.outPath, manifest),
-  );
-  registerBuildCompleteHooks(({ config }) => writeRequiredServerFilesManifest(config));
-  registerBuildCompleteHooks(({ config }) => writeTraceBuildFile(config));
+  )
+  registerBuildCompleteHooks(({ config }) => writeRequiredServerFilesManifest(config))
+  registerBuildCompleteHooks(({ config }) => writeTraceBuildFile(config))
   // Next's `adapterPath` / NEXT_ADAPTER_PATH deployment-adapter hook.
-  registerBuildCompleteHooks(({ config, manifest }) =>
-    runBuildCompleteAdapter(config, manifest),
-  );
+  registerBuildCompleteHooks(({ config, manifest }) => runBuildCompleteAdapter(config, manifest))
   setCompatModeExtensions({
     nextEnabled: nextCompatEnabled,
     reactEnabled: reactCompatEnabled,
     reactCompilerOptions,
-  });
+  })
   setBuildCompatExtensions({
     warnMetadataIssues: ({ appPath, routes, staticMetadataFiles }) =>
       warnNextMetadataBuildIssues(appPath, routes, staticMetadataFiles),
     nextOutputExport: () => getNextConfig().output === 'export',
     nextOutputMode: () => {
-      const output = getNextConfig().output;
-      return output === 'export' || output === 'standalone' ? output : undefined;
+      const output = getNextConfig().output
+      return output === 'export' || output === 'standalone' ? output : undefined
     },
     nextScriptWorkersEnabled: () => {
       const experimental = getNextConfig().experimental as
-        | { nextScriptWorkers?: boolean }
-        | undefined;
-      return experimental?.nextScriptWorkers === true;
+        { nextScriptWorkers?: boolean } | undefined
+      return experimental?.nextScriptWorkers === true
     },
     defaultExpireTimeSeconds: () => {
-      const expireTime = getNextConfig().expireTime;
-      return typeof expireTime === 'number' ? expireTime : undefined;
+      const expireTime = getNextConfig().expireTime
+      return typeof expireTime === 'number' ? expireTime : undefined
     },
     withVaryParamsTracking,
     varyNamesFor: (vary, kind) => varyNamesFor(vary as ResponseVaryParams, kind),
@@ -71,11 +72,11 @@ export function registerBuildCompatExtensions(): void {
       // preload()/preconnect() hints recorded on the prerender's work unit
       // (capped by reactMaxHeadersLength). Static HITs replay it from the
       // manifest since no response finalizer runs for them.
-      const fontValues = takeFontHeaderPreloads().map(fontLinkHeaderValue);
-      const hintValue = takeResourceHintHeader();
-      const values = [...fontValues, ...(hintValue ? [hintValue] : [])];
-      if (values.length === 0) return undefined;
-      return values.join(', ');
+      const fontValues = takeFontHeaderPreloads().map(fontLinkHeaderValue)
+      const hintValue = takeResourceHintHeader()
+      const values = [...fontValues, ...(hintValue ? [hintValue] : [])]
+      if (values.length === 0) return undefined
+      return values.join(', ')
     },
     normalizeStaticParamsModule: aliasGenerateStaticParams,
     defaultDynamicStaleTimeSeconds: DEFAULT_DYNAMIC_STALE_TIME_SECONDS,
@@ -87,12 +88,12 @@ export function registerBuildCompatExtensions(): void {
     treeSegmentFile,
     bodySegmentFile,
     segmentMetaFile,
-  });
+  })
 }
 
 interface FunctionsConfigManifest {
-  version: number;
-  functions: Record<string, Record<string, unknown>>;
+  version: number
+  functions: Record<string, Record<string, unknown>>
 }
 
 /**
@@ -103,28 +104,28 @@ interface FunctionsConfigManifest {
  * nothing that probes it changes behavior.
  */
 async function writeRequiredServerFilesManifest(config: ResolvedConfig): Promise<void> {
-  if (!nextCompatEnabled(config)) return;
-  const id = deploymentId();
-  if (!id) return;
-  const outDir = path.join(config.root, '.next');
-  await mkdir(outDir, { recursive: true });
+  if (!nextCompatEnabled(config)) return
+  const id = deploymentId()
+  if (!id) return
+  const outDir = path.join(config.root, '.next')
+  await mkdir(outDir, { recursive: true })
   await writeFile(
     path.join(outDir, 'required-server-files.json'),
     JSON.stringify({ version: 1, config: { deploymentId: id } }, null, 2),
-  );
+  )
 }
 
 // Anchored on globalThis so the timestamp survives the module being loaded
 // twice (built copy vs. original) during a single build process.
-const traceBuildGlobal = globalThis as unknown as { __pnextBuildStartedAt?: number };
-traceBuildGlobal.__pnextBuildStartedAt ??= performance.now();
+const traceBuildGlobal = globalThis as unknown as { __pnextBuildStartedAt?: number }
+traceBuildGlobal.__pnextBuildStartedAt ??= performance.now()
 
 interface TraceEvent {
-  name: string;
-  id: number;
-  traceId: string;
-  duration: number;
-  parentId?: number;
+  name: string
+  id: number
+  traceId: string
+  duration: number
+  parentId?: number
 }
 
 /**
@@ -134,9 +135,12 @@ interface TraceEvent {
  * so real timings are approximated rather than instrumented per-phase.
  */
 async function writeTraceBuildFile(config: ResolvedConfig): Promise<void> {
-  if (!nextCompatEnabled(config)) return;
-  const traceId = randomTraceId();
-  const totalDuration = Math.max(1, performance.now() - (traceBuildGlobal.__pnextBuildStartedAt ?? 0));
+  if (!nextCompatEnabled(config)) return
+  const traceId = randomTraceId()
+  const totalDuration = Math.max(
+    1,
+    performance.now() - (traceBuildGlobal.__pnextBuildStartedAt ?? 0),
+  )
   const events: TraceEvent[] = [
     { name: 'next-build', id: 1, traceId, duration: totalDuration },
     { name: 'run-webpack', id: 2, parentId: 1, traceId, duration: totalDuration * 0.4 },
@@ -145,38 +149,38 @@ async function writeTraceBuildFile(config: ResolvedConfig): Promise<void> {
     { name: 'static-generation', id: 5, parentId: 1, traceId, duration: totalDuration * 0.2 },
     { name: 'collect-build-traces', id: 6, parentId: 1, traceId, duration: totalDuration * 0.05 },
     { name: 'telemetry-flush', id: 7, parentId: 1, traceId, duration: 1 },
-  ];
-  const outDir = path.join(config.root, '.next');
-  await mkdir(outDir, { recursive: true });
-  await writeFile(path.join(outDir, 'trace-build'), `${JSON.stringify(events)}\n`);
+  ]
+  const outDir = path.join(config.root, '.next')
+  await mkdir(outDir, { recursive: true })
+  await writeFile(path.join(outDir, 'trace-build'), `${JSON.stringify(events)}\n`)
 }
 
 function randomTraceId(): string {
-  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
+  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join('')
 }
 
 async function writeFunctionsConfigManifest(
   outPath: string,
   manifest: BuildManifest,
 ): Promise<void> {
-  const routes = manifest.routes.filter(route => route.maxDuration !== undefined);
-  if (routes.length === 0) return;
+  const routes = manifest.routes.filter(route => route.maxDuration !== undefined)
+  if (routes.length === 0) return
 
-  const file = path.join(outPath, 'server', 'functions-config-manifest.json');
-  let current: FunctionsConfigManifest = { version: 1, functions: {} };
+  const file = path.join(outPath, 'server', 'functions-config-manifest.json')
+  let current: FunctionsConfigManifest = { version: 1, functions: {} }
   try {
-    current = JSON.parse(await readFile(file, 'utf8')) as FunctionsConfigManifest;
+    current = JSON.parse(await readFile(file, 'utf8')) as FunctionsConfigManifest
   } catch {
-    current = { version: 1, functions: {} };
+    current = { version: 1, functions: {} }
   }
   for (const route of routes) {
-    const regions = preferredRegionForRoute(route);
+    const regions = preferredRegionForRoute(route)
     current.functions[route.route || '/'] = {
       ...(current.functions[route.route || '/'] ?? {}),
       maxDuration: route.maxDuration,
       ...(regions ? { regions } : {}),
-    };
+    }
   }
-  await mkdir(path.dirname(file), { recursive: true });
-  await writeFile(file, `${JSON.stringify(current, null, 2)}\n`);
+  await mkdir(path.dirname(file), { recursive: true })
+  await writeFile(file, `${JSON.stringify(current, null, 2)}\n`)
 }