@wular/pnext 0.0.4 → 0.0.7

package/src/{dev/imports.ts → runtime/modules.ts}

@@ -1,30 +1,29 @@
-import { builtinModules } from 'node:module';
-import os from 'node:os';
-import path from 'node:path';
-import { existsSync, readFileSync, type Dirent } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { copyFile, mkdir, readdir, symlink, writeFile } from 'node:fs/promises';
-import type { OnResolveResult, Plugin } from 'esbuild';
-import { build } from '../utils/esbuild';
-import { drainPreplanBuilds, vendorTraceEnabled, vendorTraceRow } from '../runtime/vendor';
+import { builtinModules } from 'node:module'
+import os from 'node:os'
+import path from 'node:path'
+import { existsSync, readFileSync, type Dirent } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { copyFile, mkdir, readdir, symlink, writeFile } from 'node:fs/promises'
+import type { OnResolveResult, Plugin } from 'esbuild'
+import { build } from '../utils/esbuild'
+import { drainPreplanBuilds, vendorTraceEnabled, vendorTraceRow } from '../runtime/vendor'
 import {
   clientReferenceExportNames,
   clientReferenceModuleSource,
   hasUseClientDirective,
-} from '../client/reference-stub';
-import { getClientActionBundler } from './client-actions';
-import { deferredDynamicImportSpecifiers, devDynamicSplitEnabled } from '../dynamic/source';
-import { noteModuleGeneration, noteModuleImported } from './module-generations';
+} from '../client/reference-stub'
+import { getClientActionBundler } from '../dev/client-actions'
+import { deferredDynamicImportSpecifiers, devDynamicSplitEnabled } from '../resolve/dynamic'
+import { noteModuleGeneration, noteModuleImported } from './module-generations'
 import {
-  externalServerPackageHref,
   rewriteServerSource,
-  runtimeServerImportTarget,
   serverBundleTargetForRuntime,
   serverBundleRequireConditions,
   type ServerBundleTarget,
-} from '../runtime/server';
-import { writeFileAtomic } from '../utils/fs';
-import { createHash } from 'node:crypto';
+} from './loader'
+import { externalServerPackageHref, runtimeServerImportTarget } from '../runtime/vendor-build'
+import { writeFileAtomic } from '../utils/fs'
+import { createHash } from 'node:crypto'
 import {
   extraLoadableExtensions,
   getAssetExtensions,
@@ -32,15 +31,15 @@ import {
   getCssExtensions,
   getImportAliasExtensions,
   serverDefineOptions,
-} from '../extensions';
+} from '../extensions'
 import {
   frameworkRuntimeAliasEntries,
   pathToFileHref,
   pnextAliases,
   type CompatAliasTarget,
   type ResolvedConfig,
-} from '../config';
-import { readText, toPosixPath } from '../utils/fs';
+} from '../config'
+import { readText, toPosixPath } from '../utils/fs'
 import {
   type ExternalLoadTarget,
   externalPackageImportTarget,
@@ -50,8 +49,8 @@ import {
   resolveImport,
   resolveExternalLoadTarget,
   resolvePackageSpecifier,
-} from '../resolve/imports';
-import { importSpecifiers, rewriteSpecifierLiterals } from '../resolve/scan-facts';
+} from '../resolve/imports'
+import { importSpecifiers, rewriteSpecifierLiterals } from '../resolve/scan-facts'
 import {
   cacheRoot,
   devArtifactUsable,
@@ -60,27 +59,28 @@ import {
   devSourceIdentity,
   noteDevArtifactWritten,
   type DevModuleCache,
-} from './module-cache';
-import { cachedRouteBundlePath, saveRouteBundlePath } from './route-bundle-key-cache';
+} from './module-cache'
+import { cachedRouteBundlePath, saveRouteBundlePath } from '../dev/restart/route-bundle-key'
 import {
   outputSpecifiers,
   spliceSource,
   transformBailReason,
   transformServerModule,
   type SpecifierKind,
-} from './module-transform';
-import { findShakeableDynamicImports } from '../dynamic/tree-shake';
-import type { RouteManifestEntry } from '../types';
-import { uniqueIdentifier } from '../utils/source';
+} from './module-transform'
+import { findShakeableDynamicImports } from '../resolve/tree-shake'
+import type { RouteManifestEntry } from '../types'
+import { uniqueIdentifier } from '../utils/code'
+import { formatDuration } from '../utils/verbose'
 
-type AliasMap = Record<string, string>;
+type AliasMap = Record<string, string>
 
 function nextCompatEnabled(config: ResolvedConfig) {
-  return Boolean(config.compat?.next);
+  return Boolean(config.compat?.next)
 }
 
 function reactCompatEnabled(config: ResolvedConfig) {
-  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler)
 }
 
 function coreAliases(config: ResolvedConfig, target: CompatAliasTarget): AliasMap {
@@ -88,67 +88,73 @@ function coreAliases(config: ResolvedConfig, target: CompatAliasTarget): AliasMa
     ...frameworkRuntimeAliasEntries(),
     ...pnextAliases(target),
     ...getImportAliasExtensions().aliases(config, target),
-  };
+  }
 }
 
 // Cap concurrent esbuild builds: the recursive module graph can otherwise fire
 // hundreds of builds at once and saturate the host.
-const BUILD_CONCURRENCY = Math.max(2, (os.availableParallelism?.() ?? os.cpus().length) - 1);
-let buildActive = 0;
-const buildQueue: (() => void)[] = [];
-const moduleBuilds = new Map<string, Promise<string>>();
-const routeBundleBuilds = new Map<string, Promise<string>>();
+const BUILD_CONCURRENCY = Math.max(2, (os.availableParallelism?.() ?? os.cpus().length) - 1)
+let buildActive = 0
+const buildQueue: (() => void)[] = []
+const moduleBuilds = new Map<string, Promise<string>>()
+const routeBundleBuilds = new Map<string, Promise<string>>()
 
 // PNEXT_DEV_MODULE_STATS=1: attribute every per-module compile to its profile,
 // so cross-profile duplicate work is countable rather than inferred. Counts are
 // load-insensitive, which is what makes them usable on a contended box.
-interface ModuleStat { profile: string; ms: number; esbuild: boolean }
+interface ModuleStat {
+  profile: string
+  ms: number
+  esbuild: boolean
+}
 // `${profile}:${file}` of modules that fell off the oxc fast path onto esbuild.
-const esbuildFallbacks = new Set<string>();
+const esbuildFallbacks = new Set<string>()
 const moduleStats: Map<string, ModuleStat[]> | undefined =
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  process.env.PNEXT_DEV_MODULE_STATS === '1' ? new Map() : undefined;
-let moduleStatsFlush: Timer | undefined;
+  process.env.PNEXT_DEV_MODULE_STATS === '1' ? new Map() : undefined
+let moduleStatsFlush: Timer | undefined
 
 function noteModuleCompile(file: string, profile: string, ms: number, esbuild: boolean) {
-  if (!moduleStats) return;
-  const entries = moduleStats.get(file) ?? [];
-  entries.push({ profile, ms, esbuild });
-  moduleStats.set(file, entries);
+  if (!moduleStats) return
+  const entries = moduleStats.get(file) ?? []
+  entries.push({ profile, ms, esbuild })
+  moduleStats.set(file, entries)
   // Debounced: stages settle after the response, so a fixed point in the
   // request would miss the preloads this is meant to attribute.
-  clearTimeout(moduleStatsFlush);
-  moduleStatsFlush = setTimeout(reportModuleStats, 500);
-  moduleStatsFlush.unref?.();
+  clearTimeout(moduleStatsFlush)
+  moduleStatsFlush = setTimeout(reportModuleStats, 500)
+  moduleStatsFlush.unref?.()
 }
 
 function reportModuleStats() {
-  if (!moduleStats) return;
-  const byProfile = new Map<string, { files: number; ms: number; esbuild: number }>();
-  let total = 0;
-  let duplicated = 0;
-  let duplicateCompiles = 0;
-  let duplicateMs = 0;
+  if (!moduleStats) return
+  const byProfile = new Map<string, { files: number; ms: number; esbuild: number }>()
+  let total = 0
+  let duplicated = 0
+  let duplicateCompiles = 0
+  let duplicateMs = 0
   for (const entries of moduleStats.values()) {
-    total += entries.length;
-    const profiles = new Set(entries.map(entry => entry.profile));
+    total += entries.length
+    const profiles = new Set(entries.map(entry => entry.profile))
     if (profiles.size > 1) {
-      duplicated += 1;
-      duplicateCompiles += entries.length - 1;
-      duplicateMs += entries.slice(1).reduce((sum, entry) => sum + entry.ms, 0);
+      duplicated += 1
+      duplicateCompiles += entries.length - 1
+      duplicateMs += entries.slice(1).reduce((sum, entry) => sum + entry.ms, 0)
     }
     for (const entry of entries) {
-      const bucket = byProfile.get(entry.profile) ?? { files: 0, ms: 0, esbuild: 0 };
-      bucket.files += 1;
-      bucket.ms += entry.ms;
-      bucket.esbuild += entry.esbuild ? 1 : 0;
-      byProfile.set(entry.profile, bucket);
+      const bucket = byProfile.get(entry.profile) ?? { files: 0, ms: 0, esbuild: 0 }
+      bucket.files += 1
+      bucket.ms += entry.ms
+      bucket.esbuild += entry.esbuild ? 1 : 0
+      byProfile.set(entry.profile, bucket)
     }
   }
   const rows = [...byProfile.entries()]
     .sort((a, b) => b[1].ms - a[1].ms)
-    .map(([profile, b]) =>
-      `  ${profile}: ${b.files} modules, ${b.ms.toFixed(0)} ms nested-wall, ${b.esbuild} via esbuild`);
+    .map(
+      ([profile, b]) =>
+        `  ${profile}: ${b.files} modules, ${b.ms.toFixed(0)} ms nested-wall, ${b.esbuild} via esbuild`,
+    )
   console.error(
     [
       `dev-module-stats ${moduleStats.size} distinct files, ${total} compiles`,
@@ -156,63 +162,64 @@ function reportModuleStats() {
       `  cross-profile: ${duplicated} files compiled in >1 profile, ` +
         `${duplicateCompiles} redundant compiles, ${duplicateMs.toFixed(0)} ms nested-wall`,
     ].join('\n'),
-  );
+  )
   // PNEXT_DEV_MODULE_STATS_OUT=<path>: also dump the per-file list, so a floor
   // bench can replay the exact module set a route compiles in each profile.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const out = process.env.PNEXT_DEV_MODULE_STATS_OUT;
-  if (!out) return;
+  const out = process.env.PNEXT_DEV_MODULE_STATS_OUT
+  if (!out) return
   const files = [...moduleStats.entries()].flatMap(([file, entries]) =>
-    entries.map(entry => ({ file, profile: entry.profile, ms: entry.ms, esbuild: entry.esbuild })));
-  void writeFile(out, JSON.stringify(files, null, 0)).catch(() => undefined);
+    entries.map(entry => ({ file, profile: entry.profile, ms: entry.ms, esbuild: entry.esbuild })),
+  )
+  void writeFile(out, JSON.stringify(files, null, 0)).catch(() => undefined)
 }
-const routeModuleLoaders = new Map<string, Promise<DevRouteModuleLoaders>>();
+const routeModuleLoaders = new Map<string, Promise<DevRouteModuleLoaders>>()
 
 // A module that throws while evaluating stays failed in Bun's registry for the process lifetime, and
 // re-importing it surfaces downstream symptoms (a missing bundle entry, TDZ on an export) instead of
 // the original error. Record the first failure per compiled href and re-throw THAT on every later
 // request. Compiled hrefs are content-addressed, so a save that fixes the module yields a new href
 // and the entry is never consulted again.
-const moduleEvalErrors = new Map<string, unknown>();
+const moduleEvalErrors = new Map<string, unknown>()
 
 /** Import a compiled dev module, re-throwing its first evaluation error on later imports. */
 export async function importDevModule<T>(href: string): Promise<T> {
-  if (moduleEvalErrors.has(href)) throw moduleEvalErrors.get(href);
+  if (moduleEvalErrors.has(href)) throw moduleEvalErrors.get(href)
   // Pre-planned vendor builds are enqueued without an awaiter; nothing
   // evaluates until they all settle (no-op when the pipeline is empty).
-  await drainPreplanBuilds();
+  await drainPreplanBuilds()
   try {
-    const module = (await import(href)) as T;
-    noteModuleImported(href);
-    return module;
+    const module = (await import(href)) as T
+    noteModuleImported(href)
+    return module
   } catch (error) {
-    moduleEvalErrors.set(href, error);
-    throw error;
+    moduleEvalErrors.set(href, error)
+    throw error
   }
 }
-const extensionlessDynamicImportExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts']);
+const extensionlessDynamicImportExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts'])
 const externalLoadNamespaces = {
   server: 'pnext-route-external-server',
   client: 'pnext-route-external-client',
   module: 'pnext-module-external',
-} as const;
+} as const
 
-const moduleCaches = new WeakMap<ResolvedConfig, DevModuleCache>();
+const moduleCaches = new WeakMap<ResolvedConfig, DevModuleCache>()
 
 /**
- * The content-addressing cache behind every compiled path (dev/module-cache.ts).
+ * The content-addressing cache behind every compiled path (runtime/module-cache.ts).
  * Artifacts are named by a hash of their whole source graph, so this is also the
  * thing that decides what a save invalidates.
  */
 export function devModuleGraph(config: ResolvedConfig): DevModuleCache {
-  const existing = moduleCaches.get(config);
-  if (existing) return existing;
+  const existing = moduleCaches.get(config)
+  if (existing) return existing
   const cache = devModuleCache(config, {
     compileKey: devCompileKey(config),
     edges: (file, source) => graphEdges(config, file, source),
-  });
-  moduleCaches.set(config, cache);
-  return cache;
+  })
+  moduleCaches.set(config, cache)
+  return cache
 }
 
 /**
@@ -225,18 +232,22 @@ export function devModuleGraph(config: ResolvedConfig): DevModuleCache {
  * registers, and it is memoized from the first read.
  */
 export async function warmDevModulePipeline(config: ResolvedConfig) {
-  const source = 'import "./pnext-warm-import";\nexport const warm: number = 1;\n';
-  const file = path.join(config.root, 'pnext-warm.ts');
+  const source = 'import "./pnext-warm-import";\nexport const warm: number = 1;\n'
+  const file = path.join(config.root, 'pnext-warm.ts')
   await Promise.allSettled([
     // esbuild spawns its Go service child and handshakes on the first build.
-    build({ stdin: { contents: '0', loader: 'ts', resolveDir: config.root }, write: false, logLevel: 'silent' }),
+    build({
+      stdin: { contents: '0', loader: 'ts', resolveDir: config.root },
+      write: false,
+      logLevel: 'silent',
+    }),
     Promise.resolve().then(() => {
-      importSpecifiers(source, file); // oxc-parser
-      transformServerModule(source, file, serverDefineOptions().define); // oxc-transform
-      resolveLocalImport(config, file, './pnext-warm-import'); // oxc-resolver factory
-      devModuleGraph(config); // cache marker + graph.json + framework fingerprint
+      importSpecifiers(source, file) // oxc-parser
+      transformServerModule(source, file, serverDefineOptions().define) // oxc-transform
+      resolveLocalImport(config, file, './pnext-warm-import') // oxc-resolver factory
+      devModuleGraph(config) // cache marker + graph.json + framework fingerprint
     }),
-  ]);
+  ])
 }
 
 /** Compile inputs that are not sources: a change to any of them renames everything. */
@@ -249,7 +260,7 @@ function devCompileKey(config: ResolvedConfig) {
     nextConfig: nextConfigFingerprint(config),
     define: serverDefineOptions().define ?? null,
     aliases: [...devAliasKeys(config)].sort(),
-  });
+  })
 }
 
 // next.config knobs (modularizeImports, resolve aliases, compiler options) shape compiled output, and only
@@ -263,35 +274,35 @@ const NEXT_CONFIG_BASENAMES = [
   'next.config.js',
   'next.config.mjs',
   'next.config.cjs',
-];
+]
 
 function nextConfigFingerprint(config: ResolvedConfig) {
-  if (!config.compat?.next) return '';
+  if (!config.compat?.next) return ''
   for (const name of NEXT_CONFIG_BASENAMES) {
-    const candidate = path.join(config.root, name);
-    if (!existsSync(candidate)) continue;
+    const candidate = path.join(config.root, name)
+    if (!existsSync(candidate)) continue
     try {
-      return `${name}:${Bun.hash(readFileSync(candidate)).toString(36)}`;
+      return `${name}:${Bun.hash(readFileSync(candidate)).toString(36)}`
     } catch {
-      return name;
+      return name
     }
   }
-  return '';
+  return ''
 }
 
-const aliasKeys = new WeakMap<ResolvedConfig, Set<string>>();
+const aliasKeys = new WeakMap<ResolvedConfig, Set<string>>()
 
 /** Specifiers every profile rewrites at build time — never source edges. */
 function devAliasKeys(config: ResolvedConfig) {
-  const existing = aliasKeys.get(config);
-  if (existing) return existing;
+  const existing = aliasKeys.get(config)
+  if (existing) return existing
   const keys = new Set([
     ...Object.keys(coreAliases(config, 'server')),
     ...Object.keys(getImportAliasExtensions().reactServerLayerAliases(config)),
     ...Object.keys(clientSsrAliases(config)),
-  ]);
-  aliasKeys.set(config, keys);
-  return keys;
+  ])
+  aliasKeys.set(config, keys)
+  return keys
 }
 
 /**
@@ -300,45 +311,47 @@ function devAliasKeys(config: ResolvedConfig) {
  * its content, so assets and client components are edges here even where the compile walk skips them.
  */
 function graphEdges(config: ResolvedConfig, file: string, source: string) {
-  const aliases = devAliasKeys(config);
-  const imports: string[] = [];
-  const packages: string[] = [];
+  const aliases = devAliasKeys(config)
+  const imports: string[] = []
+  const packages: string[] = []
   for (const specifier of importSpecifiers(source, file)) {
-    const { sourcePath } = splitHash(specifier);
-    if (aliases.has(specifier) || aliases.has(sourcePath)) continue;
-    const resolved = resolveLocalImport(config, file, sourcePath.replace(/\?.*$/, ''));
-    const isLocalSource = sourcePath.startsWith('.') || path.isAbsolute(sourcePath);
+    const { sourcePath } = splitHash(specifier)
+    if (aliases.has(specifier) || aliases.has(sourcePath)) continue
+    const resolved = resolveLocalImport(config, file, sourcePath.replace(/\?.*$/, ''))
+    const isLocalSource = sourcePath.startsWith('.') || path.isAbsolute(sourcePath)
     // Compiled output is never a source of the graph that produced it.
-    if (resolved && isInside(config.outPath, resolved)) continue;
+    if (resolved && isInside(config.outPath, resolved)) continue
     if (resolved && (isLocalSource || isInside(config.workspaceRoot, resolved))) {
-      imports.push(path.resolve(resolved));
-      continue;
+      imports.push(path.resolve(resolved))
+      continue
     }
     // Registry package demand: recorded here so a route's vendor bundles can be
     // started as their own stage instead of blocking the module pass at first
     // use.
-    if (!isLocalSource && isPackageSpecifier(sourcePath)) packages.push(sourcePath);
+    if (!isLocalSource && isPackageSpecifier(sourcePath)) packages.push(sourcePath)
   }
-  return { imports, packages, client: hasUseClientDirective(source) };
+  return { imports, packages, client: hasUseClientDirective(source) }
 }
 
 function withBuildSlot<T>(task: () => Promise<T>): Promise<T> {
   return new Promise<T>((resolve, reject) => {
     const run = () => {
-      buildActive += 1;
-      task().then(resolve, reject).finally(() => {
-        buildActive -= 1;
-        buildQueue.shift()?.();
-      });
-    };
-    if (buildActive < BUILD_CONCURRENCY) run();
-    else buildQueue.push(run);
-  });
+      buildActive += 1
+      task()
+        .then(resolve, reject)
+        .finally(() => {
+          buildActive -= 1
+          buildQueue.shift()?.()
+        })
+    }
+    if (buildActive < BUILD_CONCURRENCY) run()
+    else buildQueue.push(run)
+  })
 }
 
 export interface DevServerModuleOptions {
-  conditionTarget?: ServerBundleTarget;
-  externalLoadTarget?: ExternalLoadTarget;
+  conditionTarget?: ServerBundleTarget
+  externalLoadTarget?: ExternalLoadTarget
   /**
    * True for modules compiled under the true `react-server` layer (App RSC,
    * route handlers, proxy/middleware): layers stricter React alias overrides
@@ -346,7 +359,7 @@ export interface DevServerModuleOptions {
    * Pages/api and other server modules keep the base aliases (full-hooks
    * `react`, kept for backward compatibility).
    */
-  reactServerLayer?: boolean;
+  reactServerLayer?: boolean
 }
 
 export async function devServerModuleHref(
@@ -361,29 +374,25 @@ export async function devServerModuleHref(
     config,
     file,
     moduleOptions.conditionTarget ?? 'server',
-  );
+  )
   const reactServerLayer =
-    moduleOptions.reactServerLayer ??
-    (conditionTarget === 'server' || conditionTarget === 'edge');
-  const release = devModuleGraph(config).hold();
+    moduleOptions.reactServerLayer ?? (conditionTarget === 'server' || conditionTarget === 'edge')
+  const release = devModuleGraph(config).hold()
   const compiled = await writeDevModule(config, file, new Set(), {
     aliases: {
       ...coreAliases(config, 'server'),
-      ...(reactServerLayer
-        ? getImportAliasExtensions().reactServerLayerAliases(config)
-        : {}),
+      ...(reactServerLayer ? getImportAliasExtensions().reactServerLayerAliases(config) : {}),
     },
     profile: reactCompatEnabled(config) ? 'compat' : 'server',
     conditionTarget,
     reactServerLayer,
     externalLoadTarget:
-      moduleOptions.externalLoadTarget ??
-      externalLoadTargetForConditionTarget(conditionTarget),
+      moduleOptions.externalLoadTarget ?? externalLoadTargetForConditionTarget(conditionTarget),
     stubClientImports: reactCompatEnabled(config),
     rewriteExternalServerImports: true,
     bundleExternalPackages: reactCompatEnabled(config),
-  }).finally(release);
-  return pathToFileHref(compiled);
+  }).finally(release)
+  return pathToFileHref(compiled)
 }
 
 export async function devClientModuleHref(
@@ -392,17 +401,17 @@ export async function devClientModuleHref(
   _version?: string,
   serverTarget?: ServerBundleTarget,
 ) {
-  const conditionTarget = clientLayerConditionTarget(config, file, serverTarget ?? 'server');
-  const throughPackage = await packageClientModuleHref(config, file, conditionTarget);
-  if (throughPackage) return throughPackage;
-  const release = devModuleGraph(config).hold();
+  const conditionTarget = clientLayerConditionTarget(config, file, serverTarget ?? 'server')
+  const throughPackage = await packageClientModuleHref(config, file, conditionTarget)
+  if (throughPackage) return throughPackage
+  const release = devModuleGraph(config).hold()
   const compiled = await writeDevModule(
     config,
     file,
     new Set(),
     clientLayerOptions(config, conditionTarget),
-  ).finally(release);
-  return pathToFileHref(compiled);
+  ).finally(release)
+  return pathToFileHref(compiled)
 }
 
 /**
@@ -422,18 +431,18 @@ async function packageClientModuleHref(
   file: string,
   conditionTarget: ServerBundleTarget,
 ) {
-  if (!reactCompatEnabled(config)) return undefined;
-  const packageDir = nodeModulesPackageDir(file);
-  if (!packageDir) return undefined;
-  const specifier = await packageSpecifierPublishing(config, packageDir, file);
-  if (!specifier) return undefined;
+  if (!reactCompatEnabled(config)) return undefined
+  const packageDir = nodeModulesPackageDir(file)
+  if (!packageDir) return undefined
+  const specifier = await packageSpecifierPublishing(config, packageDir, file)
+  if (!specifier) return undefined
   return externalServerPackageHref(
     config,
     specifier,
     'client',
     path.dirname(file),
     conditionTarget,
-  ).catch(() => undefined);
+  ).catch(() => undefined)
 }
 
 /**
@@ -446,70 +455,70 @@ async function packageSpecifierPublishing(
   packageDir: string,
   file: string,
 ) {
-  const packageName = packageNameOfDirectory(packageDir);
-  if (!packageName) return undefined;
+  const packageName = packageNameOfDirectory(packageDir)
+  if (!packageName) return undefined
   for (const subpath of packageExportSubpaths(packageDir)) {
-    const specifier = subpath === '.' ? packageName : `${packageName}/${subpath.slice(2)}`;
-    if (resolvePackageFile(config, file, specifier) === file) return specifier;
+    const specifier = subpath === '.' ? packageName : `${packageName}/${subpath.slice(2)}`
+    if (resolvePackageFile(config, file, specifier) === file) return specifier
   }
-  const entry = resolvePackageFile(config, file, packageName);
-  if (!entry || entry === file) return entry ? packageName : undefined;
-  const published = new Set(await clientReferenceExportNames(config, entry));
-  const names = await clientReferenceExportNames(config, file);
-  return names.length > 0 && names.every(name => published.has(name)) ? packageName : undefined;
+  const entry = resolvePackageFile(config, file, packageName)
+  if (!entry || entry === file) return entry ? packageName : undefined
+  const published = new Set(await clientReferenceExportNames(config, entry))
+  const names = await clientReferenceExportNames(config, file)
+  return names.length > 0 && names.every(name => published.has(name)) ? packageName : undefined
 }
 
 /** The client layer's own conditions, so the file matches the bundle's entry. */
 function resolvePackageFile(config: ResolvedConfig, fromFile: string, specifier: string) {
-  return resolvePackageSpecifier(config.root, fromFile, specifier, ['module', 'import']);
+  return resolvePackageSpecifier(config.root, fromFile, specifier, ['module', 'import'])
 }
 
 /** Every `exports` key of a package manifest; `{}` and sugar forms included. */
 function packageExportSubpaths(packageDir: string) {
   try {
     const manifest = JSON.parse(readFileSync(path.join(packageDir, 'package.json'), 'utf8')) as {
-      exports?: unknown;
-    };
-    if (typeof manifest.exports !== 'object' || manifest.exports === null) return ['.'];
-    const keys = Object.keys(manifest.exports).filter(key => key.startsWith('.'));
+      exports?: unknown
+    }
+    if (typeof manifest.exports !== 'object' || manifest.exports === null) return ['.']
+    const keys = Object.keys(manifest.exports).filter(key => key.startsWith('.'))
     // A conditions-only map (`{ import: ... }`) has no subpath keys at all.
-    return keys.length > 0 ? keys.filter(key => !key.includes('*')) : ['.'];
+    return keys.length > 0 ? keys.filter(key => !key.includes('*')) : ['.']
   } catch {
-    return ['.'];
+    return ['.']
   }
 }
 
 /** `…/node_modules/@scope/name` -> `@scope/name`. */
 function packageNameOfDirectory(packageDir: string) {
-  const parts = packageDir.split(path.sep);
-  const index = parts.lastIndexOf('node_modules');
-  if (index === -1) return undefined;
-  return parts.slice(index + 1).join('/');
+  const parts = packageDir.split(path.sep)
+  const index = parts.lastIndexOf('node_modules')
+  if (index === -1) return undefined
+  return parts.slice(index + 1).join('/')
 }
 
 /** `…/node_modules/@scope/name/build/x.js` -> `…/node_modules/@scope/name`. */
 function nodeModulesPackageDir(file: string) {
-  const parts = file.split(path.sep);
-  const index = parts.lastIndexOf('node_modules');
-  if (index === -1) return undefined;
-  const end = index + (parts[index + 1]?.startsWith('@') ? 3 : 2);
-  return end <= parts.length ? parts.slice(0, end).join(path.sep) : undefined;
+  const parts = file.split(path.sep)
+  const index = parts.lastIndexOf('node_modules')
+  if (index === -1) return undefined
+  const end = index + (parts[index + 1]?.startsWith('@') ? 3 : 2)
+  return end <= parts.length ? parts.slice(0, end).join(path.sep) : undefined
 }
 
 export interface DevRouteModuleLoaders {
-  moduleLoader: (file: string) => Promise<Record<string, unknown>>;
-  clientModuleLoader: (file: string) => Promise<Record<string, unknown>>;
+  moduleLoader: (file: string) => Promise<Record<string, unknown>>
+  clientModuleLoader: (file: string) => Promise<Record<string, unknown>>
 }
 
 interface DevModuleOptions {
-  aliases: AliasMap;
-  profile: 'server' | 'compat' | 'client';
-  conditionTarget: ServerBundleTarget;
-  reactServerLayer?: boolean;
-  externalLoadTarget: ExternalLoadTarget;
-  stubClientImports: boolean;
-  rewriteExternalServerImports: boolean;
-  bundleExternalPackages: boolean;
+  aliases: AliasMap
+  profile: 'server' | 'compat' | 'client'
+  conditionTarget: ServerBundleTarget
+  reactServerLayer?: boolean
+  externalLoadTarget: ExternalLoadTarget
+  stubClientImports: boolean
+  rewriteExternalServerImports: boolean
+  bundleExternalPackages: boolean
 }
 
 /**
@@ -522,9 +531,9 @@ interface DevModuleOptions {
 function startRouteVendorStage(config: ResolvedConfig, route: RouteManifestEntry, files: string[]) {
   // Kill switch for bisecting a suspected stage-overlap difference.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_DISABLE_VENDOR_STAGE) return;
-  if (!reactCompatEnabled(config)) return;
-  const conditionTarget = serverBundleTargetForRuntime(route.segmentConfig?.runtime);
+  if (process.env.PNEXT_DISABLE_VENDOR_STAGE) return
+  if (!reactCompatEnabled(config)) return
+  const conditionTarget = serverBundleTargetForRuntime(route.segmentConfig?.runtime)
   const options: DevModuleOptions = {
     aliases: coreAliases(config, 'server'),
     profile: 'compat',
@@ -533,40 +542,40 @@ function startRouteVendorStage(config: ResolvedConfig, route: RouteManifestEntry
     stubClientImports: true,
     rewriteExternalServerImports: true,
     bundleExternalPackages: true,
-  };
+  }
   // Only the SERVER vendor layer is seeded here: the client-reference walk already fans the
   // client-SSR demand out, so seeding that layer too only competes for the JS thread.
   //
   // Layered seeding: a separate walk pruned at 'use client' boundaries, so client-only packages get
   // no server-target builds. On-demand fallback covers anything needed sooner.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const layered = process.env.PNEXT_VENDOR_SEED_LAYERED !== '0';
-  const seedT0 = performance.now();
+  const layered = process.env.PNEXT_VENDOR_SEED_LAYERED !== '0'
+  const seedT0 = performance.now()
   void (async () => {
-    const graph = devModuleGraph(config);
-    const demand = new Set<string>();
-    const dropped = new Set<string>();
+    const graph = devModuleGraph(config)
+    const demand = new Set<string>()
+    const dropped = new Set<string>()
     // The layer of a source is part of the record the naming walk just scanned,
     // so the seed reads it instead of re-reading the whole route graph.
     const prune = (file: string) =>
       (devHeadTrimEnabled() ? graph.isClientSource(file) : fileHasUseClientDirective(file)).catch(
         () => false,
-      );
+      )
     for (const file of files) {
-      const full = await graph.packageDemand(file);
-      const serverReachable = layered ? new Set(await graph.packageDemand(file, prune)) : undefined;
+      const full = await graph.packageDemand(file)
+      const serverReachable = layered ? new Set(await graph.packageDemand(file, prune)) : undefined
       for (const specifier of full) {
-        if (!shouldBundleExternalPackage(specifier, config, file, options)) continue;
-        if (serverReachable && !serverReachable.has(specifier)) dropped.add(specifier);
-        else demand.add(specifier);
+        if (!shouldBundleExternalPackage(specifier, config, file, options)) continue
+        if (serverReachable && !serverReachable.has(specifier)) dropped.add(specifier)
+        else demand.add(specifier)
       }
     }
-    for (const specifier of demand) dropped.delete(specifier);
+    for (const specifier of demand) dropped.delete(specifier)
     // eslint-disable-next-line turbo/no-undeclared-env-vars
     if (process.env.PNEXT_DEV_PROFILE) {
       console.log(
         `dev-import vendor seed walk ${route.route} in ${formatDuration(performance.now() - seedT0)} (kept ${demand.size}, dropped ${dropped.size})`,
-      );
+      )
     }
     if (vendorTraceEnabled()) {
       vendorTraceRow({
@@ -576,18 +585,22 @@ function startRouteVendorStage(config: ResolvedConfig, route: RouteManifestEntry
         kept: [...demand].sort(),
         dropped: [...dropped].sort(),
         atMs: performance.now(),
-      });
+      })
     }
     const warm = (specifiers: Iterable<string>) =>
       Promise.all(
         [...specifiers].map(specifier =>
-          externalServerPackageHref(config, specifier, 'server', config.root, conditionTarget).catch(
-            () => undefined,
-          ),
+          externalServerPackageHref(
+            config,
+            specifier,
+            'server',
+            config.root,
+            conditionTarget,
+          ).catch(() => undefined),
         ),
-      );
-    await warm(demand);
-  })().catch(() => undefined);
+      )
+    await warm(demand)
+  })().catch(() => undefined)
 }
 
 export async function devRouteModuleLoaders(
@@ -599,35 +612,35 @@ export async function devRouteModuleLoaders(
   // The bundle's own content-addressed path is the cache key: a save that
   // changes nothing this route imports keeps it, one that does gives a new
   // path — no version bump, no wholesale eviction.
-  const release = devModuleGraph(config).hold();
+  const release = devModuleGraph(config).hold()
   const key = await profileDevImport(`route bundle key ${route.route}`, () =>
     devRouteBundlePath(config, route, layoutFiles),
   ).catch(error => {
-    release();
-    throw error;
-  });
-  noteModuleGeneration(`bundle:${route.route}`, key);
-  const existing = routeModuleLoaders.get(key);
+    release()
+    throw error
+  })
+  noteModuleGeneration(`bundle:${route.route}`, key)
+  const existing = routeModuleLoaders.get(key)
   if (existing) {
-    release();
-    return existing;
+    release()
+    return existing
   }
   // A bundle already on disk was built against vendor artifacts the previous process left next to it, so
   // seeding the stage would walk the whole graph again to demand what is already there - and it would do it
   // on the JS thread the restart's first response is waiting on. Anything genuinely missing is still built
   // on demand by the resolve path.
   if (!devArtifactUsable(key)) {
-    startRouteVendorStage(config, route, uniqueFiles([route.file, ...layoutFiles]));
+    startRouteVendorStage(config, route, uniqueFiles([route.file, ...layoutFiles]))
   }
 
   const next = createDevRouteModuleLoaders(config, route, layoutFiles, key)
     .catch(error => {
-      routeModuleLoaders.delete(key);
-      throw error;
+      routeModuleLoaders.delete(key)
+      throw error
     })
-    .finally(release);
-  routeModuleLoaders.set(key, next);
-  return next;
+    .finally(release)
+  routeModuleLoaders.set(key, next)
+  return next
 }
 
 async function createDevRouteModuleLoaders(
@@ -636,21 +649,22 @@ async function createDevRouteModuleLoaders(
   layoutFiles: string[],
   outFile: string,
 ): Promise<DevRouteModuleLoaders> {
-  const bundleFile = await writeDevRouteBundle(config, route, layoutFiles, outFile);
+  const bundleFile = await writeDevRouteBundle(config, route, layoutFiles, outFile)
   const bundle = await profileDevImport(`import route ${route.route}`, () =>
-    importDevModule<DevRouteBundle>(pathToFileHref(bundleFile)));
+    importDevModule<DevRouteBundle>(pathToFileHref(bundleFile)),
+  )
   const moduleLoader = async (file: string) => {
-    const module = bundle.modules[file];
-    if (module) return module;
+    const module = bundle.modules[file]
+    if (module) return module
     return importDevModule<Record<string, unknown>>(
       await devServerModuleHref(config, file, undefined, {
         conditionTarget: serverBundleTargetForRuntime(route.segmentConfig?.runtime),
       }),
-    );
-  };
+    )
+  }
   const clientModuleLoader = async (file: string) => {
-    const module = bundle.clientModules[file];
-    if (module) return module;
+    const module = bundle.clientModules[file]
+    if (module) return module
     return importDevModule<Record<string, unknown>>(
       await devClientModuleHref(
         config,
@@ -658,14 +672,14 @@ async function createDevRouteModuleLoaders(
         undefined,
         serverBundleTargetForRuntime(route.segmentConfig?.runtime),
       ),
-    );
-  };
-  return { moduleLoader, clientModuleLoader };
+    )
+  }
+  return { moduleLoader, clientModuleLoader }
 }
 
 interface DevRouteBundle {
-  modules: Record<string, Record<string, unknown>>;
-  clientModules: Record<string, Record<string, unknown>>;
+  modules: Record<string, Record<string, unknown>>
+  clientModules: Record<string, Record<string, unknown>>
 }
 
 async function writeDevRouteBundle(
@@ -674,80 +688,79 @@ async function writeDevRouteBundle(
   layoutFiles: string[],
   outFile: string,
 ) {
-  if (devArtifactUsable(outFile)) return outFile;
+  if (devArtifactUsable(outFile)) return outFile
 
-  const existing = routeBundleBuilds.get(outFile);
-  if (existing) return existing;
+  const existing = routeBundleBuilds.get(outFile)
+  if (existing) return existing
 
   const next = profileDevImport(`build route ${route.route}`, async () => {
-    await mkdir(path.dirname(outFile), { recursive: true });
-    const serverFiles = uniqueFiles([
-      ...(route.client ? [] : [route.file]),
-      ...layoutFiles,
-    ]);
-    const result = await withBuildSlot(() => build({
-      stdin: {
-        contents: routeBundleEntrySource(serverFiles, []),
-        loader: 'ts',
-        resolveDir: config.root,
-        sourcefile: `${route.id}.route-bundle.ts`,
-      },
-      bundle: true,
-      write: false,
-      format: 'esm',
-      platform: 'neutral',
-      target: 'es2022',
-      // Workspace .js/.mjs app modules may contain JSX (packages stay
-      // external, so node_modules never reach these loaders).
-      loader: { '.js': 'jsx', '.mjs': 'jsx' },
-      jsx: 'automatic',
-      jsxImportSource: 'preact',
-      packages: 'external',
-      logLevel: 'silent',
-      ...serverDefineOptions(),
-      plugins: [
-        serverAssetPlugin(config),
-        // Ahead of the extension plugins: they resolve without a namespace, so a tsconfig-`paths`
-        // import from a route-bundle module would land in esbuild's default namespace and take its
-        // whole subtree with it - out of this build's hooks, resolving bare specifiers like
-        // `next/dynamic` against real node_modules instead of the compat aliases.
-        devRouteBundlePlugin(config, route),
-        ...getBundlerExtensions().serverEsbuildPlugins(config),
-      ],
-    }));
-    const output = result.outputFiles[0];
-    if (!output) throw new Error(`Failed to build dev route bundle for ${route.route}`);
-    await writeCompiledFile(outFile, output.text);
-    return outFile;
+    await mkdir(path.dirname(outFile), { recursive: true })
+    const serverFiles = uniqueFiles([...(route.client ? [] : [route.file]), ...layoutFiles])
+    const result = await withBuildSlot(() =>
+      build({
+        stdin: {
+          contents: routeBundleEntrySource(serverFiles, []),
+          loader: 'ts',
+          resolveDir: config.root,
+          sourcefile: `${route.id}.route-bundle.ts`,
+        },
+        bundle: true,
+        write: false,
+        format: 'esm',
+        platform: 'neutral',
+        target: 'es2022',
+        // Workspace .js/.mjs app modules may contain JSX (packages stay
+        // external, so node_modules never reach these loaders).
+        loader: { '.js': 'jsx', '.mjs': 'jsx' },
+        jsx: 'automatic',
+        jsxImportSource: 'preact',
+        packages: 'external',
+        logLevel: 'silent',
+        ...serverDefineOptions(),
+        plugins: [
+          serverAssetPlugin(config),
+          // Ahead of the extension plugins: they resolve without a namespace, so a tsconfig-`paths`
+          // import from a route-bundle module would land in esbuild's default namespace and take its
+          // whole subtree with it - out of this build's hooks, resolving bare specifiers like
+          // `next/dynamic` against real node_modules instead of the compat aliases.
+          devRouteBundlePlugin(config, route),
+          ...getBundlerExtensions().serverEsbuildPlugins(config),
+        ],
+      }),
+    )
+    const output = result.outputFiles[0]
+    if (!output) throw new Error(`Failed to build dev route bundle for ${route.route}`)
+    await writeCompiledFile(outFile, output.text)
+    return outFile
   }).catch(error => {
-    routeBundleBuilds.delete(outFile);
-    throw error;
-  });
+    routeBundleBuilds.delete(outFile)
+    throw error
+  })
 
-  routeBundleBuilds.set(outFile, next);
-  return next;
+  routeBundleBuilds.set(outFile, next)
+  return next
 }
 
 function routeBundleEntrySource(serverFiles: string[], clientFiles: string[]) {
-  const serverImports = serverFiles.map((file, index) =>
-    `import * as server${index} from ${JSON.stringify(`pnext-server:${file}`)};`);
-  const clientImports = clientFiles.map((file, index) =>
-    `import * as client${index} from ${JSON.stringify(`pnext-client:${file}`)};`);
-  const serverEntries = serverFiles.map((file, index) =>
-    `${JSON.stringify(file)}: server${index},`);
-  const clientEntries = clientFiles.map((file, index) =>
-    `${JSON.stringify(file)}: client${index},`);
+  const serverImports = serverFiles.map(
+    (file, index) => `import * as server${index} from ${JSON.stringify(`pnext-server:${file}`)};`,
+  )
+  const clientImports = clientFiles.map(
+    (file, index) => `import * as client${index} from ${JSON.stringify(`pnext-client:${file}`)};`,
+  )
+  const serverEntries = serverFiles.map((file, index) => `${JSON.stringify(file)}: server${index},`)
+  const clientEntries = clientFiles.map((file, index) => `${JSON.stringify(file)}: client${index},`)
 
   return [
     ...serverImports,
     ...clientImports,
     `export const modules = {${serverEntries.join('')}};`,
     `export const clientModules = {${clientEntries.join('')}};`,
-  ].join('\n');
+  ].join('\n')
 }
 
 function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry): Plugin {
-  const conditionTarget = serverBundleTargetForRuntime(route.segmentConfig?.runtime);
+  const conditionTarget = serverBundleTargetForRuntime(route.segmentConfig?.runtime)
   const serverOptions: DevModuleOptions = {
     aliases: {
       ...coreAliases(config, 'server'),
@@ -763,7 +776,7 @@ function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry)
     stubClientImports: true,
     rewriteExternalServerImports: true,
     bundleExternalPackages: reactCompatEnabled(config),
-  };
+  }
   const clientOptions: DevModuleOptions = {
     aliases: clientSsrAliases(config),
     profile: 'client',
@@ -772,7 +785,7 @@ function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry)
     stubClientImports: false,
     rewriteExternalServerImports: false,
     bundleExternalPackages: reactCompatEnabled(config),
-  };
+  }
 
   return {
     name: 'pnext-dev-route-bundle',
@@ -780,25 +793,37 @@ function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry)
       // Ensure the compat client-action module set is discovered for the active
       // dev version before any route-client module loads (dev startup/reload used
       // to run this inline). No-op for pure-core / non-next apps.
-      if (nextCompatEnabled(config)) await getClientActionBundler()?.ensureArmed();
-      build.onResolve({ filter: /^file:\/\// }, args => ({ path: args.path, external: true }));
+      if (nextCompatEnabled(config)) await getClientActionBundler()?.ensureArmed()
+      build.onResolve({ filter: /^file:\/\// }, args => ({ path: args.path, external: true }))
       build.onResolve({ filter: /^pnext-server:/ }, args => ({
         path: args.path.slice('pnext-server:'.length),
         namespace: 'pnext-route-server',
-      }));
+      }))
       build.onResolve({ filter: /^pnext-client:/ }, args => ({
         path: args.path.slice('pnext-client:'.length),
         namespace: 'pnext-route-client',
-      }));
+      }))
 
       build.onResolve({ filter: /.*/, namespace: 'pnext-route-server' }, args =>
-        resolveRouteBundleSpecifier(config, args.path, args.importer, 'pnext-route-server', serverOptions),
-      );
+        resolveRouteBundleSpecifier(
+          config,
+          args.path,
+          args.importer,
+          'pnext-route-server',
+          serverOptions,
+        ),
+      )
       build.onResolve({ filter: /.*/, namespace: 'pnext-route-client' }, args =>
-        resolveRouteBundleSpecifier(config, args.path, args.importer, 'pnext-route-client', clientOptions),
-      );
-      registerExternalLoadHandlers(build, config, serverOptions, externalLoadNamespaces.server);
-      registerExternalLoadHandlers(build, config, clientOptions, externalLoadNamespaces.client);
+        resolveRouteBundleSpecifier(
+          config,
+          args.path,
+          args.importer,
+          'pnext-route-client',
+          clientOptions,
+        ),
+      )
+      registerExternalLoadHandlers(build, config, serverOptions, externalLoadNamespaces.server)
+      registerExternalLoadHandlers(build, config, clientOptions, externalLoadNamespaces.client)
 
       build.onLoad({ filter: /.*/, namespace: 'pnext-route-server' }, async args => ({
         contents: rewriteServerSource(await readText(args.path), args.path, {
@@ -806,15 +831,15 @@ function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry)
           root: config.root,
         }),
         loader: esbuildLoader(args.path),
-      }));
+      }))
       build.onLoad({ filter: /.*/, namespace: 'pnext-route-client' }, async args => {
         // A client-side import of a 'use server' module becomes the RPC stub.
-        const clientActions = nextCompatEnabled(config) ? getClientActionBundler() : undefined;
+        const clientActions = nextCompatEnabled(config) ? getClientActionBundler() : undefined
         if (clientActions?.isClientActionModule(args.path)) {
           return {
             contents: await clientActions.stubSource(args.path),
             loader: 'js',
-          };
+          }
         }
         return {
           contents: rewriteServerSource(await readText(args.path), args.path, {
@@ -822,14 +847,17 @@ function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry)
             root: config.root,
           }),
           loader: esbuildLoader(args.path),
-        };
-      });
+        }
+      })
       build.onLoad({ filter: /.*/, namespace: 'pnext-client-reference' }, async args => ({
-        contents: clientReferenceModuleSource(args.path, await clientReferenceExportNames(config, args.path)),
+        contents: clientReferenceModuleSource(
+          args.path,
+          await clientReferenceExportNames(config, args.path),
+        ),
         loader: 'js',
-      }));
+      }))
     },
-  };
+  }
 }
 
 /**
@@ -845,13 +873,12 @@ function pagesCompatSourceAlias(
   importer: string | undefined,
   options: DevModuleOptions,
 ): string | undefined {
-  if (!options.reactServerLayer) return undefined;
-  if (specifier !== 'react' && specifier !== 'react-dom') return undefined;
-  if (!importer) return undefined;
-  const posix = importer.replace(/\\/g, '/');
-  if (!posix.includes('/pnext-pages-compat/') || !posix.includes('/source-pages/'))
-    return undefined;
-  return coreAliases(config, 'server')[specifier];
+  if (!options.reactServerLayer) return undefined
+  if (specifier !== 'react' && specifier !== 'react-dom') return undefined
+  if (!importer) return undefined
+  const posix = importer.replace(/\\/g, '/')
+  if (!posix.includes('/pnext-pages-compat/') || !posix.includes('/source-pages/')) return undefined
+  return coreAliases(config, 'server')[specifier]
 }
 
 async function resolveRouteBundleSpecifier(
@@ -862,24 +889,24 @@ async function resolveRouteBundleSpecifier(
   options: DevModuleOptions,
 ): Promise<OnResolveResult | undefined> {
   const compatAlias =
-    pagesCompatSourceAlias(config, specifier, importer, options) ?? options.aliases[specifier];
+    pagesCompatSourceAlias(config, specifier, importer, options) ?? options.aliases[specifier]
   if (compatAlias) {
     return {
       path: path.isAbsolute(compatAlias) ? pathToFileHref(compatAlias) : compatAlias,
       external: true,
-    };
+    }
   }
 
   // A `turbopack.rules` loader chain owns this specifier (see the same check in
   // resolveDevModuleSpecifier): import its materialized output.
-  const pendingRuleModule = getAssetExtensions().loaderRuleModule(specifier, importer);
-  const ruleModule = pendingRuleModule === undefined ? undefined : await pendingRuleModule;
-  if (ruleModule) return { path: pathToFileHref(ruleModule), external: true };
+  const pendingRuleModule = getAssetExtensions().loaderRuleModule(specifier, importer)
+  const ruleModule = pendingRuleModule === undefined ? undefined : await pendingRuleModule
+  if (ruleModule) return { path: pathToFileHref(ruleModule), external: true }
 
-  if (isServerIgnoredAssetSpecifier(specifier)) return undefined;
+  if (isServerIgnoredAssetSpecifier(specifier)) return undefined
 
-  const { sourcePath, hash } = splitHash(specifier);
-  const resolved = resolveLocalImport(config, importer, sourcePath);
+  const { sourcePath, hash } = splitHash(specifier)
+  const resolved = resolveLocalImport(config, importer, sourcePath)
   // `resolveExtensions` can land an extensionless specifier on an asset
   // (`import img from './image'` -> image.png), which the specifier-keyed check
   // above and serverAssetPlugin's own filter both miss. Hand it to the asset
@@ -889,17 +916,17 @@ async function resolveRouteBundleSpecifier(
     isServerIgnoredAssetSpecifier(resolved) &&
     !getAssetExtensions().hasLoaderRuleFor(resolved)
   ) {
-    return { path: resolved, namespace: serverAssetNamespace };
+    return { path: resolved, namespace: serverAssetNamespace }
   }
   if (resolved && isInside(config.workspaceRoot, resolved)) {
     if (
       options.stubClientImports &&
       !isCssFile(resolved) &&
-      await fileHasUseClientDirective(resolved)
+      (await fileHasUseClientDirective(resolved))
     ) {
-      return { path: resolved, namespace: 'pnext-client-reference' };
+      return { path: resolved, namespace: 'pnext-client-reference' }
     }
-    return { path: resolved, namespace };
+    return { path: resolved, namespace }
   }
   // An absolute path that lands outside the workspace is framework runtime a rewrite injected by path
   // rather than by alias - pnext's own source is not part of the app's module graph, so it loads
@@ -907,10 +934,13 @@ async function resolveRouteBundleSpecifier(
   // esbuild does not fall back to the filesystem for an import raised from a plugin namespace, so the
   // whole route bundle fails and the route silently drops to per-module loading.
   if (resolved && path.isAbsolute(sourcePath)) {
-    return { path: `${pathToFileHref(resolved)}${hash}`, external: true };
+    return { path: `${pathToFileHref(resolved)}${hash}`, external: true }
   }
 
-  if (options.bundleExternalPackages && shouldBundleExternalPackage(sourcePath, config, importer, options)) {
+  if (
+    options.bundleExternalPackages &&
+    shouldBundleExternalPackage(sourcePath, config, importer, options)
+  ) {
     return {
       path: await externalServerPackageHref(
         config,
@@ -920,7 +950,7 @@ async function resolveRouteBundleSpecifier(
         options.conditionTarget,
       ),
       external: true,
-    };
+    }
   }
 
   if (isPackageSpecifier(sourcePath) || isBuiltinSpecifier(sourcePath)) {
@@ -929,17 +959,18 @@ async function resolveRouteBundleSpecifier(
       fromFile: importer,
       specifier: sourcePath,
       target: options.externalLoadTarget,
-    });
-    if (resolvedExternalLoad && await externalLoadNeedsFacade(resolvedExternalLoad)) {
+    })
+    if (resolvedExternalLoad && (await externalLoadNeedsFacade(resolvedExternalLoad))) {
       return {
         path: resolvedExternalLoad,
-        namespace: options.profile === 'client'
-          ? externalLoadNamespaces.client
-          : externalLoadNamespaces.server,
-      };
+        namespace:
+          options.profile === 'client'
+            ? externalLoadNamespaces.client
+            : externalLoadNamespaces.server,
+      }
     }
     const externalTarget =
-      resolvedExternalLoad ?? externalPackageImportTarget(config.root, importer, sourcePath);
+      resolvedExternalLoad ?? externalPackageImportTarget(config.root, importer, sourcePath)
     return {
       path: externalTarget
         ? `${pathToFileHref(externalTarget)}${hash}`
@@ -947,48 +978,48 @@ async function resolveRouteBundleSpecifier(
           ? runtimeServerImportTarget(specifier)
           : specifier,
       external: true,
-    };
+    }
   }
 
-  return undefined;
+  return undefined
 }
 
 // Sidecar of each artifact's raw import specifiers so the vercel trace reads
 // them back instead of re-parsing artifacts. Off outside vercel prod builds.
-let emitCompiledSpecifiersManifest = false;
+let emitCompiledSpecifiersManifest = false
 
 /** @internal Test-only. Returns a restore function. */
 export function setEmitCompiledSpecifiersManifest(enabled: boolean) {
-  const previous = emitCompiledSpecifiersManifest;
-  emitCompiledSpecifiersManifest = enabled;
+  const previous = emitCompiledSpecifiersManifest
+  emitCompiledSpecifiersManifest = enabled
   return () => {
-    emitCompiledSpecifiersManifest = previous;
-  };
+    emitCompiledSpecifiersManifest = previous
+  }
 }
 
 /** Sidecar suffix for a compiled artifact's recorded specifiers. */
-export const compiledSpecifiersManifestSuffix = '.pnext-specifiers.json';
+export const compiledSpecifiersManifestSuffix = '.pnext-specifiers.json'
 
-const compiledScriptFilePattern = /\.(?:m?js|cjs|jsx|tsx?)$/;
+const compiledScriptFilePattern = /\.(?:m?js|cjs|jsx|tsx?)$/
 
 async function writeCompiledFile(file: string, contents: string) {
-  await writeFileAtomic(file, contents);
-  noteDevArtifactWritten(file);
+  await writeFileAtomic(file, contents)
+  noteDevArtifactWritten(file)
   if (emitCompiledSpecifiersManifest && compiledScriptFilePattern.test(file)) {
     await writeFileAtomic(
       `${file}${compiledSpecifiersManifestSuffix}`,
       JSON.stringify(importSpecifiers(contents, file)),
-    );
+    )
   }
 }
 
 /** Where `file` compiles to under `profile`, named by its current source graph. */
 async function devModulePathFor(config: ResolvedConfig, file: string, profile: string) {
-  return devServerPath(config, file, profile, await devModuleGraph(config).graphHash(file));
+  return devServerPath(config, file, profile, await devModuleGraph(config).graphHash(file))
 }
 
 function devModulePath(config: ResolvedConfig, file: string, options: DevModuleOptions) {
-  return devModulePathFor(config, file, devModuleProfile(options));
+  return devModulePathFor(config, file, devModuleProfile(options))
 }
 
 async function writeDevModule(
@@ -997,39 +1028,44 @@ async function writeDevModule(
   visited: Set<string>,
   options: DevModuleOptions,
 ) {
-  const profile = devModuleProfile(options);
-  const outFile = await devModulePath(config, file, options);
-  const visitedKey = `${profile}:${file}`;
-  noteModuleGeneration(visitedKey, outFile);
-  if (visited.has(visitedKey)) return outFile;
+  const profile = devModuleProfile(options)
+  const outFile = await devModulePath(config, file, options)
+  const visitedKey = `${profile}:${file}`
+  noteModuleGeneration(visitedKey, outFile)
+  if (visited.has(visitedKey)) return outFile
 
   // The name carries the hash of this module's whole source graph, so an existing artifact is by
   // construction current. An unusable one (the cache folder was wiped from outside) falls through to
   // recompile, which overwrites it in place - never delete first, since Bun caches a failed resolution for
   // the life of the process.
-  if (devArtifactUsable(outFile)) return outFile;
+  if (devArtifactUsable(outFile)) return outFile
 
-  const existing = moduleBuilds.get(outFile);
-  if (existing) return existing;
+  const existing = moduleBuilds.get(outFile)
+  if (existing) return existing
 
-  visited.add(visitedKey);
-  const started = moduleStats ? performance.now() : 0;
+  visited.add(visitedKey)
+  const started = moduleStats ? performance.now() : 0
   const next = writeDevModuleUncached(config, file, visited, options, outFile)
     .then(result => {
       if (moduleStats) {
-        noteModuleCompile(file, profile, performance.now() - started, esbuildFallbacks.delete(visitedKey));
+        noteModuleCompile(
+          file,
+          profile,
+          performance.now() - started,
+          esbuildFallbacks.delete(visitedKey),
+        )
       }
-      return result;
+      return result
     })
     .catch(error => {
-      moduleBuilds.delete(outFile);
-      throw error;
+      moduleBuilds.delete(outFile)
+      throw error
     })
     .finally(() => {
-      moduleBuilds.delete(outFile);
-    });
-  moduleBuilds.set(outFile, next);
-  return next;
+      moduleBuilds.delete(outFile)
+    })
+  moduleBuilds.set(outFile, next)
+  return next
 }
 
 async function writeDevModuleUncached(
@@ -1039,44 +1075,49 @@ async function writeDevModuleUncached(
   options: DevModuleOptions,
   outFile: string,
 ) {
-  await mkdir(path.dirname(outFile), { recursive: true });
+  await mkdir(path.dirname(outFile), { recursive: true })
   if (isCssFile(file)) {
-    await copyFile(file, outFile);
-    return outFile;
+    await copyFile(file, outFile)
+    return outFile
   }
 
   // A client-profile compile of a 'use server' module emits the RPC stub, so
   // the browser bundle POSTs to the endpoint instead of shipping server code.
   if (options.profile === 'client' && nextCompatEnabled(config)) {
-    const clientActions = getClientActionBundler();
+    const clientActions = getClientActionBundler()
     if (clientActions) {
-      await clientActions.ensureArmed();
+      await clientActions.ensureArmed()
       if (clientActions.isClientActionModule(file)) {
-        await writeCompiledFile(outFile, await clientActions.stubSource(file));
-        return outFile;
+        await writeCompiledFile(outFile, await clientActions.stubSource(file))
+        return outFile
       }
     }
   }
 
-  let source = await readText(file);
+  let source = await readText(file)
   if (/\.mdx?$/.test(file) && nextCompatEnabled(config)) {
     // Markdown modules must be compiled to JS before import analysis and the
     // stdin-based bundle pass (which bypasses file-resolved onLoad plugins).
-    const { compileMdx } = await import('../compat/mdx/compile');
-    source = (await compileMdx(source, file, config.root)).code;
+    const { compileMdx } = await import('../compat/mdx/compile')
+    source = (await compileMdx(source, file, config.root)).code
   }
   const transformedSource = rewriteServerSource(source, file, {
     nextFonts: nextCompatEnabled(config),
     root: config.root,
-  });
+  })
   const effectiveOptions =
-    reactCompatEnabled(config) && options.profile !== 'client' && hasUseClientDirective(transformedSource)
-      ? clientLayerOptions(config, clientLayerConditionTarget(config, file, options.conditionTarget))
-      : options;
+    reactCompatEnabled(config) &&
+    options.profile !== 'client' &&
+    hasUseClientDirective(transformedSource)
+      ? clientLayerOptions(
+          config,
+          clientLayerConditionTarget(config, file, options.conditionTarget),
+        )
+      : options
   // The asset-context link walk is pure I/O against directories nothing below
   // reads, so it overlaps the shaking/scan/child-compile work and is only
   // awaited before the write.
-  const assetContext = linkAssetContext(config, file, devModuleProfile(effectiveOptions));
+  const assetContext = linkAssetContext(config, file, devModuleProfile(effectiveOptions))
   // Rewrite destructured dynamic imports (`const { used } = await import('x')`)
   // to point at a tree-shaken facade so the target's unused exports are dropped
   // (compat: mirrors webpack's dynamic-import export usage analysis). Done
@@ -1088,7 +1129,7 @@ async function writeDevModuleUncached(
   const deferredDynamic =
     effectiveOptions.profile === 'client' && devDynamicSplitEnabled()
       ? deferredDynamicTargetFiles(transformedSource, config, file)
-      : undefined;
+      : undefined
   const shakenSource = await applyDynamicImportTreeShaking(
     transformedSource,
     config,
@@ -1096,10 +1137,13 @@ async function writeDevModuleUncached(
     visited,
     effectiveOptions,
     deferredDynamic,
-  );
-  const clientReferences = reactCompatEnabled(config) && effectiveOptions.stubClientImports && !hasUseClientDirective(shakenSource)
-    ? await writeClientReferenceModules(shakenSource, config, file, effectiveOptions.aliases)
-    : { specifiers: new Map<string, string>(), files: new Set<string>() };
+  )
+  const clientReferences =
+    reactCompatEnabled(config) &&
+    effectiveOptions.stubClientImports &&
+    !hasUseClientDirective(shakenSource)
+      ? await writeClientReferenceModules(shakenSource, config, file, effectiveOptions.aliases)
+      : { specifiers: new Map<string, string>(), files: new Set<string>() }
   // Compiling this module only needs its imports' *paths*, so it runs while the
   // targets themselves compile. The write still waits for them: a compiled
   // module must never become loadable before its edges exist on disk.
@@ -1109,10 +1153,10 @@ async function writeDevModuleUncached(
     file,
     clientReferences.specifiers,
     effectiveOptions,
-  );
+  )
   // The real rejection is reported below; this only keeps it from surfacing as
   // an unhandled rejection while the imports compile.
-  compiled.catch(() => undefined);
+  compiled.catch(() => undefined)
   await Promise.all([
     assetContext,
     ...localImportTargets(shakenSource, config, file, effectiveOptions.aliases)
@@ -1127,17 +1171,17 @@ async function writeDevModuleUncached(
           !deferredDynamic?.has(path.resolve(target)),
       )
       .map(({ target }) => writeDevModule(config, target, visited, effectiveOptions)),
-  ]);
+  ])
 
-  await writeCompiledFile(outFile, await compiled);
-  return outFile;
+  await writeCompiledFile(outFile, await compiled)
+  return outFile
 }
 
-const shakeEntrySpecifier = 'pnext-shake-entry';
-const shakeEntryNamespace = 'pnext-shake-entry';
+const shakeEntrySpecifier = 'pnext-shake-entry'
+const shakeEntryNamespace = 'pnext-shake-entry'
 
 // Rewrite each shakeable destructured dynamic import in `source` so its
-// specifier points at a tree-shaken facade module (see dynamic/tree-shake.ts).
+// specifier points at a tree-shaken facade module (see resolve/tree-shake.ts).
 // Only local workspace modules are shaken; 'use client' targets keep their
 // client-reference stubbing path. Returns the source unchanged when nothing
 // qualifies.
@@ -1149,45 +1193,45 @@ async function applyDynamicImportTreeShaking(
   options: DevModuleOptions,
   deferredDynamic?: Set<string>,
 ): Promise<string> {
-  if (!nextCompatEnabled(config)) return source;
-  const candidates = findShakeableDynamicImports(source);
-  if (candidates.length === 0) return source;
+  if (!nextCompatEnabled(config)) return source
+  const candidates = findShakeableDynamicImports(source)
+  if (candidates.length === 0) return source
 
-  const edits: { start: number; end: number; value: string }[] = [];
+  const edits: { start: number; end: number; value: string }[] = []
   for (const candidate of candidates) {
-    const { sourcePath } = splitHash(candidate.specifier);
-    if (isServerIgnoredAssetSpecifier(sourcePath) && !isCssFile(sourcePath)) continue;
-    const resolved = resolveLocalImport(config, file, sourcePath);
-    if (!resolved || !isInside(config.workspaceRoot, resolved) || isCssFile(resolved)) continue;
+    const { sourcePath } = splitHash(candidate.specifier)
+    if (isServerIgnoredAssetSpecifier(sourcePath) && !isCssFile(sourcePath)) continue
+    const resolved = resolveLocalImport(config, file, sourcePath)
+    if (!resolved || !isInside(config.workspaceRoot, resolved) || isCssFile(resolved)) continue
     // A deferred dynamic() target must not compile eagerly through the facade.
-    if (deferredDynamic?.has(path.resolve(resolved))) continue;
-    if (options.stubClientImports && (await fileHasUseClientDirective(resolved))) continue;
+    if (deferredDynamic?.has(path.resolve(resolved))) continue
+    if (options.stubClientImports && (await fileHasUseClientDirective(resolved))) continue
     const facade = await writeShakenDynamicModule(
       config,
       resolved,
       candidate.usedExports,
       visited,
       options,
-    );
+    )
     edits.push({
       start: candidate.literalStart,
       end: candidate.literalEnd,
       value: JSON.stringify(pathToFileHref(facade)),
-    });
+    })
   }
 
-  if (edits.length === 0) return source;
-  let next = source;
+  if (edits.length === 0) return source
+  let next = source
   for (const edit of edits.sort((a, b) => b.start - a.start)) {
-    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`;
+    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`
   }
-  return next;
+  return next
 }
 
 function shakeExportsKey(usedExports: string[]): string {
-  const sorted = [...new Set(usedExports)].sort();
-  if (sorted.length === 0) return 'none';
-  return createHash('sha256').update(sorted.join(',')).digest('hex').slice(0, 8);
+  const sorted = [...new Set(usedExports)].sort()
+  if (sorted.length === 0) return 'none'
+  return createHash('sha256').update(sorted.join(',')).digest('hex').slice(0, 8)
 }
 
 async function shakenModulePath(
@@ -1196,26 +1240,26 @@ async function shakenModulePath(
   profile: string,
   key: string,
 ): Promise<string> {
-  const base = await devModulePathFor(config, targetFile, profile);
-  const ext = path.extname(base) || '.js';
-  return `${base.slice(0, base.length - ext.length)}.pnext-shake-${key}${ext}`;
+  const base = await devModulePathFor(config, targetFile, profile)
+  const ext = path.extname(base) || '.js'
+  return `${base.slice(0, base.length - ext.length)}.pnext-shake-${key}${ext}`
 }
 
 // Facade entry that re-exports only the destructured names from the target
 // (loaded inline via the shake-entry namespace), so esbuild tree-shakes the
 // rest. An empty set keeps side effects only.
 function shakenEntrySource(usedExports: string[]): string {
-  const names = [...new Set(usedExports)];
-  if (names.length === 0) return `import ${JSON.stringify(shakeEntrySpecifier)};\n`;
-  const named = names.filter(name => name !== 'default');
-  const lines: string[] = [];
+  const names = [...new Set(usedExports)]
+  if (names.length === 0) return `import ${JSON.stringify(shakeEntrySpecifier)};\n`
+  const named = names.filter(name => name !== 'default')
+  const lines: string[] = []
   if (named.length > 0) {
-    lines.push(`export { ${named.join(', ')} } from ${JSON.stringify(shakeEntrySpecifier)};`);
+    lines.push(`export { ${named.join(', ')} } from ${JSON.stringify(shakeEntrySpecifier)};`)
   }
   if (names.includes('default')) {
-    lines.push(`export { default } from ${JSON.stringify(shakeEntrySpecifier)};`);
+    lines.push(`export { default } from ${JSON.stringify(shakeEntrySpecifier)};`)
   }
-  return `${lines.join('\n')}\n`;
+  return `${lines.join('\n')}\n`
 }
 
 async function writeShakenDynamicModule(
@@ -1225,24 +1269,31 @@ async function writeShakenDynamicModule(
   visited: Set<string>,
   options: DevModuleOptions,
 ): Promise<string> {
-  const profile = devModuleProfile(options);
-  const outFile = await shakenModulePath(config, targetFile, profile, shakeExportsKey(usedExports));
-  if (devArtifactUsable(outFile)) return outFile;
+  const profile = devModuleProfile(options)
+  const outFile = await shakenModulePath(config, targetFile, profile, shakeExportsKey(usedExports))
+  if (devArtifactUsable(outFile)) return outFile
 
-  const key = `shake\0${outFile}`;
-  const existing = moduleBuilds.get(key);
-  if (existing) return existing;
+  const key = `shake\0${outFile}`
+  const existing = moduleBuilds.get(key)
+  if (existing) return existing
 
-  const next = writeShakenDynamicModuleUncached(config, targetFile, usedExports, visited, options, outFile)
+  const next = writeShakenDynamicModuleUncached(
+    config,
+    targetFile,
+    usedExports,
+    visited,
+    options,
+    outFile,
+  )
     .catch(error => {
-      moduleBuilds.delete(key);
-      throw error;
+      moduleBuilds.delete(key)
+      throw error
     })
     .finally(() => {
-      moduleBuilds.delete(key);
-    });
-  moduleBuilds.set(key, next);
-  return next;
+      moduleBuilds.delete(key)
+    })
+  moduleBuilds.set(key, next)
+  return next
 }
 
 async function writeShakenDynamicModuleUncached(
@@ -1253,20 +1304,22 @@ async function writeShakenDynamicModuleUncached(
   options: DevModuleOptions,
   outFile: string,
 ): Promise<string> {
-  await mkdir(path.dirname(outFile), { recursive: true });
+  await mkdir(path.dirname(outFile), { recursive: true })
   const targetSource = rewriteServerSource(await readText(targetFile), targetFile, {
     nextFonts: nextCompatEnabled(config),
     root: config.root,
-  });
+  })
   // The target is inlined into the facade, but its own transitive imports stay
   // external file:// modules — compile them the same way the normal graph walk
   // would so those hrefs resolve on disk.
   await Promise.all(
     localImportTargets(targetSource, config, targetFile, options.aliases)
-      .filter(({ target, isLocalSource }) => isLocalSource || isInside(config.workspaceRoot, target))
+      .filter(
+        ({ target, isLocalSource }) => isLocalSource || isInside(config.workspaceRoot, target),
+      )
       .map(({ target }) => writeDevModule(config, target, visited, options)),
-  );
-  const externalBundles = await externalBundleSpecifiers(targetSource, config, targetFile, options);
+  )
+  const externalBundles = await externalBundleSpecifiers(targetSource, config, targetFile, options)
   const result = await withBuildSlot(() =>
     build({
       stdin: {
@@ -1292,11 +1345,11 @@ async function writeShakenDynamicModuleUncached(
         devModuleResolvePlugin(config, targetFile, new Map(), externalBundles, options),
       ],
     }),
-  );
-  const output = result.outputFiles[0];
-  if (!output) throw new Error(`Failed to tree-shake ${targetFile}`);
-  await writeCompiledFile(outFile, addExtensionlessDynamicImportGlobAliases(output.text));
-  return outFile;
+  )
+  const output = result.outputFiles[0]
+  if (!output) throw new Error(`Failed to tree-shake ${targetFile}`)
+  await writeCompiledFile(outFile, addExtensionlessDynamicImportGlobAliases(output.text))
+  return outFile
 }
 
 // Resolve the facade's re-export entry to the target's already-transformed
@@ -1308,18 +1361,18 @@ function shakeEntryPlugin(targetFile: string, targetSource: string): Plugin {
       build.onResolve({ filter: new RegExp(`^${shakeEntrySpecifier}$`) }, () => ({
         path: targetFile,
         namespace: shakeEntryNamespace,
-      }));
+      }))
       build.onLoad({ filter: /.*/, namespace: shakeEntryNamespace }, () => ({
         contents: targetSource,
         loader: esbuildLoader(targetFile),
         resolveDir: path.dirname(targetFile),
-      }));
+      }))
     },
-  };
+  }
 }
 
 function externalLoadTargetForConditionTarget(target: ServerBundleTarget): ExternalLoadTarget {
-  return target === 'edge' ? 'edge' : 'server';
+  return target === 'edge' ? 'edge' : 'server'
 }
 
 function clientLayerOptions(
@@ -1334,7 +1387,7 @@ function clientLayerOptions(
     stubClientImports: false,
     rewriteExternalServerImports: false,
     bundleExternalPackages: reactCompatEnabled(config),
-  };
+  }
 }
 
 /**
@@ -1355,9 +1408,9 @@ function pagesLayerConditionTarget(
   file: string,
   incoming: ServerBundleTarget,
 ): ServerBundleTarget {
-  if (incoming === 'server') return isPagesRouterSourceFile(config, file) ? 'pages' : 'server';
-  if (incoming === 'edge') return isPagesRouterSourceFile(config, file) ? 'pages-edge' : 'edge';
-  return incoming;
+  if (incoming === 'server') return isPagesRouterSourceFile(config, file) ? 'pages' : 'server'
+  if (incoming === 'edge') return isPagesRouterSourceFile(config, file) ? 'pages-edge' : 'edge'
+  return incoming
 }
 
 function clientLayerConditionTarget(
@@ -1365,24 +1418,24 @@ function clientLayerConditionTarget(
   file: string,
   incoming: ServerBundleTarget,
 ): ServerBundleTarget {
-  if (!isPagesRouterSourceFile(config, file)) return 'client';
-  return incoming === 'edge' || incoming === 'pages-edge' ? 'pages-edge' : 'pages';
+  if (!isPagesRouterSourceFile(config, file)) return 'client'
+  return incoming === 'edge' || incoming === 'pages-edge' ? 'pages-edge' : 'pages'
 }
 
 function isPagesRouterSourceFile(config: ResolvedConfig, file: string): boolean {
-  const posix = file.split(path.sep).join('/');
-  if (posix.includes('/source-pages/')) return true;
+  const posix = file.split(path.sep).join('/')
+  if (posix.includes('/source-pages/')) return true
   // Materialized hybrid wrappers live under pnext-pages-compat/<hash>/app/ for
   // BOTH routers; only pages wrappers re-export from source-pages/, so sniff
   // the (tiny, generated) wrapper body to tell them apart.
   if (posix.includes('pnext-pages-compat/')) {
     try {
-      return readFileSync(file, 'utf8').includes('source-pages/');
+      return readFileSync(file, 'utf8').includes('source-pages/')
     } catch {
-      return false;
+      return false
     }
   }
-  return isInside(path.join(config.root, 'pages'), file);
+  return isInside(path.join(config.root, 'pages'), file)
 }
 
 async function buildDevModuleSource(
@@ -1392,7 +1445,7 @@ async function buildDevModuleSource(
   clientReferenceSpecifiers: Map<string, string>,
   options: DevModuleOptions,
 ) {
-  const externalBundles = await externalBundleSpecifiers(source, config, file, options);
+  const externalBundles = await externalBundleSpecifiers(source, config, file, options)
   const transformed = await transformDevModuleSource(
     source,
     config,
@@ -1400,42 +1453,44 @@ async function buildDevModuleSource(
     clientReferenceSpecifiers,
     externalBundles,
     options,
-  );
-  if (transformed !== undefined) return transformed;
-  if (moduleStats) esbuildFallbacks.add(`${devModuleProfile(options)}:${file}`);
-  const result = await withBuildSlot(() => build({
-    stdin: {
-      contents: source,
-      loader: esbuildLoader(file),
-      resolveDir: path.dirname(file),
-      sourcefile: file,
-    },
-    bundle: true,
-    write: false,
-    format: 'esm',
-    platform: 'neutral',
-    target: 'es2022',
-    // Workspace .js/.mjs app modules may contain JSX (packages stay external,
-    // so node_modules never reach these loaders).
-    loader: { '.js': 'jsx', '.mjs': 'jsx' },
-    jsx: 'automatic',
-    jsxImportSource: 'preact',
-    packages: 'external',
-    logLevel: 'silent',
-    ...serverDefineOptions(),
-    plugins: [
-      serverAssetPlugin(config),
-      ...getBundlerExtensions().serverEsbuildPlugins(config),
-      serverClientReferencePlugin(config, options),
-      devModuleResolvePlugin(config, file, clientReferenceSpecifiers, externalBundles, options),
-    ],
-  }));
-  const output = result.outputFiles[0];
-  if (!output) throw new Error(`Failed to build ${file}`);
-  const compiled = addExtensionlessDynamicImportGlobAliases(output.text);
+  )
+  if (transformed !== undefined) return transformed
+  if (moduleStats) esbuildFallbacks.add(`${devModuleProfile(options)}:${file}`)
+  const result = await withBuildSlot(() =>
+    build({
+      stdin: {
+        contents: source,
+        loader: esbuildLoader(file),
+        resolveDir: path.dirname(file),
+        sourcefile: file,
+      },
+      bundle: true,
+      write: false,
+      format: 'esm',
+      platform: 'neutral',
+      target: 'es2022',
+      // Workspace .js/.mjs app modules may contain JSX (packages stay external,
+      // so node_modules never reach these loaders).
+      loader: { '.js': 'jsx', '.mjs': 'jsx' },
+      jsx: 'automatic',
+      jsxImportSource: 'preact',
+      packages: 'external',
+      logLevel: 'silent',
+      ...serverDefineOptions(),
+      plugins: [
+        serverAssetPlugin(config),
+        ...getBundlerExtensions().serverEsbuildPlugins(config),
+        serverClientReferencePlugin(config, options),
+        devModuleResolvePlugin(config, file, clientReferenceSpecifiers, externalBundles, options),
+      ],
+    }),
+  )
+  const output = result.outputFiles[0]
+  if (!output) throw new Error(`Failed to build ${file}`)
+  const compiled = addExtensionlessDynamicImportGlobAliases(output.text)
   return options.profile === 'client' && isCommonJsModuleSource(source, file)
     ? unwrapCommonJsDefaultExport(compiled)
-    : compiled;
+    : compiled
 }
 
 /**
@@ -1455,13 +1510,13 @@ async function transformDevModuleSource(
   // Kill switch: puts every module back on the esbuild build below, for
   // bisecting a suspected transform-path difference.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_DISABLE_BATCHED_TRANSFORM) return undefined;
-  if (transformBailReason(source, file)) return undefined;
-  const transformed = transformServerModule(source, file, serverDefineOptions().define);
-  if ('bail' in transformed) return undefined;
+  if (process.env.PNEXT_DISABLE_BATCHED_TRANSFORM) return undefined
+  if (transformBailReason(source, file)) return undefined
+  const transformed = transformServerModule(source, file, serverDefineOptions().define)
+  if ('bail' in transformed) return undefined
 
-  const { code } = transformed;
-  const edits: { start: number; end: number; value: string }[] = [];
+  const { code } = transformed
+  const edits: { start: number; end: number; value: string }[] = []
   for (const found of outputSpecifiers(code)) {
     const target = await devModuleSpecifierTarget(
       found.value,
@@ -1471,11 +1526,12 @@ async function transformDevModuleSource(
       clientReferenceSpecifiers,
       externalBundles,
       options,
-    );
-    if (target === undefined) return undefined;
-    if (target !== found.value) edits.push({ start: found.start, end: found.end, value: JSON.stringify(target) });
+    )
+    if (target === undefined) return undefined
+    if (target !== found.value)
+      edits.push({ start: found.start, end: found.end, value: JSON.stringify(target) })
   }
-  return spliceSource(code, edits);
+  return spliceSource(code, edits)
 }
 
 /**
@@ -1495,11 +1551,11 @@ async function devModuleSpecifierTarget(
   // Same claim `serverAssetPlugin` makes, and in the same order: it is the first
   // onResolve in the build below.
   if (isServerIgnoredAssetSpecifier(specifier)) {
-    const resolved = resolveAssetPath(specifier, path.dirname(file));
+    const resolved = resolveAssetPath(specifier, path.dirname(file))
     // A configured loader-rule chain (turbopack.rules) preempts the generic
     // asset stub — fall through to the rule-aware resolver below.
     if (!getAssetExtensions().hasLoaderRuleFor(resolved)) {
-      return pathToFileHref(await assetStubModule(config, resolved, devModuleProfile(options)));
+      return pathToFileHref(await assetStubModule(config, resolved, devModuleProfile(options)))
     }
   }
   const resolved = await resolveDevModuleSpecifier(
@@ -1511,20 +1567,20 @@ async function devModuleSpecifierTarget(
     options,
     kind,
     file,
-  );
+  )
   // A non-external result names a namespace the bundler loads inline
   // (`pnext-module-external` facades) or a bare require-alias path.
-  return resolved.external && typeof resolved.path === 'string' ? resolved.path : undefined;
+  return resolved.external && typeof resolved.path === 'string' ? resolved.path : undefined
 }
 
-const assetStubs = new Map<string, Promise<string>>();
+const assetStubs = new Map<string, Promise<string>>()
 
 /** The empty/static-asset/css-module stub the bundler used to inline, as a file. */
 async function assetStubModule(config: ResolvedConfig, resolved: string, profile: string) {
-  const base = splitHash(resolved).sourcePath.replace(/\?.*$/, '');
-  const outFile = `${await devModulePathFor(config, base, profile)}.pnext-asset.js`;
-  const existing = assetStubs.get(outFile);
-  if (existing) return existing;
+  const base = splitHash(resolved).sourcePath.replace(/\?.*$/, '')
+  const outFile = `${await devModulePathFor(config, base, profile)}.pnext-asset.js`
+  const existing = assetStubs.get(outFile)
+  if (existing) return existing
   const next = (async () => {
     const contents =
       getCssExtensions().loadCssModuleForClient(resolved) ??
@@ -1532,27 +1588,27 @@ async function assetStubModule(config: ResolvedConfig, resolved: string, profile
         ? ''
         : isStaticImageFile(base)
           ? await staticImageModuleSource(config, resolved)
-          : 'export default "";');
-    await mkdir(path.dirname(outFile), { recursive: true });
-    await writeCompiledFile(outFile, contents);
-    return outFile;
+          : 'export default "";')
+    await mkdir(path.dirname(outFile), { recursive: true })
+    await writeCompiledFile(outFile, contents)
+    return outFile
   })().catch(error => {
-    assetStubs.delete(outFile);
-    throw error;
-  });
-  assetStubs.set(outFile, next);
-  return next;
+    assetStubs.delete(outFile)
+    throw error
+  })
+  assetStubs.set(outFile, next)
+  return next
 }
 
 function unwrapCommonJsDefaultExport(code: string) {
-  const match = /(^|\n)export default ([^;\n]+);/.exec(code);
-  if (!match?.[2]) return code;
-  const moduleName = uniqueIdentifier(code, '__pnext_cjs_module');
-  const defaultName = uniqueIdentifier(code, '__pnext_cjs_default', moduleName);
+  const match = /(^|\n)export default ([^;\n]+);/.exec(code)
+  if (!match?.[2]) return code
+  const moduleName = uniqueIdentifier(code, '__pnext_cjs_module')
+  const defaultName = uniqueIdentifier(code, '__pnext_cjs_default', moduleName)
   return code.replace(
     match[0],
     `${match[1]}var ${moduleName} = ${match[2]};\nvar ${defaultName} = ${moduleName} != null && "default" in Object(${moduleName}) ? ${moduleName}.default : ${moduleName};\nexport { ${defaultName} as default };`,
-  );
+  )
 }
 
 function devModuleResolvePlugin(
@@ -1565,7 +1621,7 @@ function devModuleResolvePlugin(
   return {
     name: 'pnext-dev-module-resolve',
     setup(build) {
-      registerExternalLoadHandlers(build, config, options, externalLoadNamespaces.module);
+      registerExternalLoadHandlers(build, config, options, externalLoadNamespaces.module)
       build.onResolve({ filter: /.*/ }, args =>
         resolveDevModuleSpecifier(
           args.path,
@@ -1577,9 +1633,9 @@ function devModuleResolvePlugin(
           args.kind,
           args.importer,
         ),
-      );
+      )
     },
-  };
+  }
 }
 
 function serverClientReferencePlugin(config: ResolvedConfig, options: DevModuleOptions): Plugin {
@@ -1587,9 +1643,9 @@ function serverClientReferencePlugin(config: ResolvedConfig, options: DevModuleO
     name: 'pnext-server-client-references',
     setup(build) {
       build.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: 'file' }, async args => {
-        if (!options.stubClientImports) return undefined;
-        const source = await readText(args.path);
-        if (!hasUseClientDirective(source)) return undefined;
+        if (!options.stubClientImports) return undefined
+        const source = await readText(args.path)
+        if (!hasUseClientDirective(source)) return undefined
         return {
           contents: clientReferenceModuleSource(
             args.path,
@@ -1597,43 +1653,45 @@ function serverClientReferencePlugin(config: ResolvedConfig, options: DevModuleO
           ),
           loader: 'js',
           resolveDir: path.dirname(args.path),
-        };
-      });
+        }
+      })
     },
-  };
+  }
 }
 
-const serverAssetNamespace = 'pnext-empty-server-asset';
+const serverAssetNamespace = 'pnext-empty-server-asset'
 
 function serverAssetPlugin(config: ResolvedConfig): Plugin {
   return {
     name: 'pnext-empty-server-assets',
     setup(build) {
       build.onResolve({ filter: serverIgnoredAssetFilter }, args => {
-        const resolved = resolveAssetPath(args.path, args.resolveDir);
+        const resolved = resolveAssetPath(args.path, args.resolveDir)
         // A configured `turbopack.rules` loader chain for this extension (e.g.
         // `*.svg`) preempts the generic asset pipeline: defer so the compat
         // loader-rule plugin's onLoad runs the chain against the real file.
         // This is the plugin that builds app-page SERVER bundles, so without
         // this escape hatch a configured `*.svg` rule never runs here.
-        if (getAssetExtensions().hasLoaderRuleFor(resolved)) return undefined;
-        return { path: resolved, namespace: serverAssetNamespace };
-      });
+        if (getAssetExtensions().hasLoaderRuleFor(resolved)) return undefined
+        return { path: resolved, namespace: serverAssetNamespace }
+      })
       build.onLoad({ filter: /.*/, namespace: serverAssetNamespace }, async args => {
         // Registry-provided CSS modules (e.g. *.module.scss) export their class
         // map on the server instead of the empty-asset stub.
-        const cssModule = getCssExtensions().loadCssModuleForClient(args.path);
+        const cssModule = getCssExtensions().loadCssModuleForClient(args.path)
         return {
-          contents: cssModule ?? (isCssFile(args.path)
-            ? ''
-            : isStaticImageFile(args.path)
-              ? await staticImageModuleSource(config, args.path)
-              : 'export default "";'),
+          contents:
+            cssModule ??
+            (isCssFile(args.path)
+              ? ''
+              : isStaticImageFile(args.path)
+                ? await staticImageModuleSource(config, args.path)
+                : 'export default "";'),
           loader: 'js',
-        };
-      });
+        }
+      })
     },
-  };
+  }
 }
 
 async function resolveDevModuleSpecifier(
@@ -1652,8 +1710,8 @@ async function resolveDevModuleSpecifier(
   // client-reference stubbing as a bare specifier - importing the raw file yields an untagged third
   // module instance the render walk never recognizes as a client boundary.
   if (specifier.startsWith('file://')) {
-    const { sourcePath: hrefPath, hash: hrefHash } = splitHash(specifier);
-    const target = fileURLToPath(hrefPath);
+    const { sourcePath: hrefPath, hash: hrefHash } = splitHash(specifier)
+    const target = fileURLToPath(hrefPath)
     if (
       options.stubClientImports &&
       !isCssFile(target) &&
@@ -1661,11 +1719,15 @@ async function resolveDevModuleSpecifier(
       existsSync(target) &&
       (await fileHasUseClientDirective(target))
     ) {
-      const stub = await clientReferencePath(config, target);
-      await writeClientReferenceModule(stub, target, await clientReferenceExportNames(config, target));
-      return { path: `${pathToFileHref(stub)}${hrefHash}`, external: true };
+      const stub = await clientReferencePath(config, target)
+      await writeClientReferenceModule(
+        stub,
+        target,
+        await clientReferenceExportNames(config, target),
+      )
+      return { path: `${pathToFileHref(stub)}${hrefHash}`, external: true }
     }
-    return { path: specifier, external: true };
+    return { path: specifier, external: true }
   }
 
   // A `turbopack.rules` loader chain owns this specifier (`?query` and all):
@@ -1674,17 +1736,17 @@ async function resolveDevModuleSpecifier(
   const pendingRuleModule = getAssetExtensions().loaderRuleModule(
     specifier,
     importer && !importer.startsWith('<') ? importer : file,
-  );
-  const ruleModule = pendingRuleModule === undefined ? undefined : await pendingRuleModule;
-  if (ruleModule) return { path: pathToFileHref(ruleModule), external: true };
+  )
+  const ruleModule = pendingRuleModule === undefined ? undefined : await pendingRuleModule
+  if (ruleModule) return { path: pathToFileHref(ruleModule), external: true }
 
-  const { sourcePath, hash } = splitHash(specifier);
+  const { sourcePath, hash } = splitHash(specifier)
 
   const compatAlias =
-    pagesCompatSourceAlias(config, specifier, importer, options) ?? options.aliases[specifier];
+    pagesCompatSourceAlias(config, specifier, importer, options) ?? options.aliases[specifier]
   if (compatAlias) {
     if (kind === 'require-call' && path.isAbsolute(compatAlias)) {
-      return { path: serverRequireAlias(specifier, compatAlias, options) };
+      return { path: serverRequireAlias(specifier, compatAlias, options) }
     }
     // A compat alias pointing at a 'use client' file needs the SAME stub-and-match treatment as any
     // other local client component: the render tree walk recognizes a client boundary by a
@@ -1697,36 +1759,44 @@ async function resolveDevModuleSpecifier(
       !isCssFile(compatAlias) &&
       (await fileHasUseClientDirective(compatAlias))
     ) {
-      const stub = await clientReferencePath(config, compatAlias);
-      await writeClientReferenceModule(stub, compatAlias, await clientReferenceExportNames(config, compatAlias));
-      return { path: pathToFileHref(stub), external: true };
+      const stub = await clientReferencePath(config, compatAlias)
+      await writeClientReferenceModule(
+        stub,
+        compatAlias,
+        await clientReferenceExportNames(config, compatAlias),
+      )
+      return { path: pathToFileHref(stub), external: true }
     }
     return {
       path: path.isAbsolute(compatAlias) ? pathToFileHref(compatAlias) : compatAlias,
       external: true,
-    };
+    }
   }
 
-  const externalBundle = externalBundles.get(sourcePath);
+  const externalBundle = externalBundles.get(sourcePath)
   if (externalBundle && kind === 'require-call') {
     const required = resolvePackageSpecifier(
       config.root,
       file,
       sourcePath,
       serverBundleRequireConditions(options.conditionTarget),
-    );
-    if (required) return { path: `${required}${hash}`, external: true };
+    )
+    if (required) return { path: `${required}${hash}`, external: true }
   }
-  if (externalBundle) return { path: `${externalBundle}${hash}`, external: true };
+  if (externalBundle) return { path: `${externalBundle}${hash}`, external: true }
 
-  const clientReferenceStubPath = clientReferenceSpecifiers.get(sourcePath);
-  if (clientReferenceStubPath) return { path: `${pathToFileHref(clientReferenceStubPath)}${hash}`, external: true };
+  const clientReferenceStubPath = clientReferenceSpecifiers.get(sourcePath)
+  if (clientReferenceStubPath)
+    return { path: `${pathToFileHref(clientReferenceStubPath)}${hash}`, external: true }
 
   if (
     sourcePath === './preact' &&
     path.resolve(importer) === new URL('../compat/react/client.ts', import.meta.url).pathname
   ) {
-    return { path: pathToFileHref(new URL('../compat/react/preact.ts', import.meta.url).pathname), external: true };
+    return {
+      path: pathToFileHref(new URL('../compat/react/preact.ts', import.meta.url).pathname),
+      external: true,
+    }
   }
 
   if (
@@ -1734,36 +1804,38 @@ async function resolveDevModuleSpecifier(
     path.resolve(importer) === new URL('../compat/react/preact.ts', import.meta.url).pathname
   ) {
     return {
-      path: pathToFileHref(new URL('../compat/client/errors/primitive-throw.ts', import.meta.url).pathname),
+      path: pathToFileHref(
+        new URL('../compat/client/errors/primitive-throw.ts', import.meta.url).pathname,
+      ),
       external: true,
-    };
+    }
   }
 
   const resolved = resolveImport(
     config.root,
     importer && !importer.startsWith('<') ? importer : file,
     sourcePath,
-  );
+  )
   // A relative specifier that resolved names first-party source next to its importer, so compile it
   // through the normal pipeline even outside workspaceRoot (compat's own runtime files live inside
   // pnext's package, not the app's workspace). A bare specifier resolving outside workspaceRoot is a
   // package meant to stay external, untouched.
-  const isLocalSourceSpecifier = sourcePath.startsWith('.') || path.isAbsolute(sourcePath);
+  const isLocalSourceSpecifier = sourcePath.startsWith('.') || path.isAbsolute(sourcePath)
   if (!resolved || (!isLocalSourceSpecifier && !isInside(config.workspaceRoot, resolved))) {
     const resolvedExternalLoad = resolveExternalLoadTarget({
       root: config.root,
       fromFile: file,
       specifier: sourcePath,
       target: options.externalLoadTarget,
-    });
-    if (resolvedExternalLoad && await externalLoadNeedsFacade(resolvedExternalLoad)) {
+    })
+    if (resolvedExternalLoad && (await externalLoadNeedsFacade(resolvedExternalLoad))) {
       return {
         path: resolvedExternalLoad,
         namespace: externalLoadNamespaces.module,
-      };
+      }
     }
     const externalTarget =
-      resolvedExternalLoad ?? externalPackageImportTarget(config.root, file, sourcePath);
+      resolvedExternalLoad ?? externalPackageImportTarget(config.root, file, sourcePath)
     return {
       path: externalTarget
         ? `${pathToFileHref(externalTarget)}${hash}`
@@ -1771,7 +1843,7 @@ async function resolveDevModuleSpecifier(
           ? runtimeServerImportTarget(specifier)
           : specifier,
       external: true,
-    };
+    }
   }
   // A configured `resolveExtensions` order can make an EXTENSIONLESS specifier
   // land on an asset (`import img from './image'` -> image.png). The asset
@@ -1785,13 +1857,21 @@ async function resolveDevModuleSpecifier(
     !isCssFile(resolved) &&
     !getAssetExtensions().hasLoaderRuleFor(resolved)
   ) {
-    const stub = await assetStubModule(config, resolved, devModuleProfile(options));
-    return { path: pathToFileHref(stub), external: true };
+    const stub = await assetStubModule(config, resolved, devModuleProfile(options))
+    return { path: pathToFileHref(stub), external: true }
   }
-  if (options.stubClientImports && !isCssFile(resolved) && await fileHasUseClientDirective(resolved)) {
-    const stub = await clientReferencePath(config, resolved);
-    await writeClientReferenceModule(stub, resolved, await clientReferenceExportNames(config, resolved));
-    return { path: `${pathToFileHref(stub)}${hash}`, external: true };
+  if (
+    options.stubClientImports &&
+    !isCssFile(resolved) &&
+    (await fileHasUseClientDirective(resolved))
+  ) {
+    const stub = await clientReferencePath(config, resolved)
+    await writeClientReferenceModule(
+      stub,
+      resolved,
+      await clientReferenceExportNames(config, resolved),
+    )
+    return { path: `${pathToFileHref(stub)}${hash}`, external: true }
   }
   // The compiled-path rewrite below is only safe for imports the WRITE pass walks:
   // writeDevModuleUncached compiles the entry source's own local import targets, nothing deeper. A
@@ -1799,13 +1879,13 @@ async function resolveDevModuleSpecifier(
   // relative imports through this hook, and nothing ever writes those into the profile cache - the
   // import would resolve to a file that does not exist. Point such a transitive import at its own
   // source instead; Bun compiles the `.ts` on import.
-  const importerFile = importer && !importer.startsWith('<') ? path.resolve(importer) : '';
+  const importerFile = importer && !importer.startsWith('<') ? path.resolve(importer) : ''
   const bundledCompatImporter =
     isLocalSourceSpecifier &&
     importerFile !== '' &&
     importerFile !== path.resolve(file) &&
     !isInside(config.workspaceRoot, importerFile) &&
-    !isInside(config.workspaceRoot, resolved);
+    !isInside(config.workspaceRoot, resolved)
   // The `importerFile !== file` term above keeps this to imports the write pass misses: the entry's
   // OWN local imports are already walked by writeDevModuleUncached. Everything deeper - a relative
   // sibling of a compat file esbuild inlined into the entry - is nobody's job but this one, whether
@@ -1818,23 +1898,23 @@ async function resolveDevModuleSpecifier(
     // pointing at the raw source instead would load a SECOND copy of the compat runtime graph and split its
     // module state. writeDevModule dedupes in-flight builds per artifact path, so a module reached from
     // several bundled importers is compiled once.
-    await writeDevModule(config, resolved, new Set(), options);
+    await writeDevModule(config, resolved, new Set(), options)
   }
   return {
     path: `${pathToFileHref(await devModulePath(config, resolved, options))}${hash}`,
     external: true,
-  };
+  }
 }
 
 function serverRequireAlias(specifier: string, alias: string, options: DevModuleOptions) {
-  if (options.conditionTarget === 'client') return alias;
+  if (options.conditionTarget === 'client') return alias
   if (specifier === 'next/navigation' && alias.endsWith(`${path.sep}navigation.ts`)) {
-    return path.join(path.dirname(alias), 'navigation.cjs');
+    return path.join(path.dirname(alias), 'navigation.cjs')
   }
   if (specifier === 'next/router' && alias.endsWith(`${path.sep}router.ts`)) {
-    return path.join(path.dirname(alias), 'router.cjs');
+    return path.join(path.dirname(alias), 'router.cjs')
   }
-  return alias;
+  return alias
 }
 
 function registerExternalLoadHandlers(
@@ -1844,34 +1924,34 @@ function registerExternalLoadHandlers(
   namespace: string,
 ) {
   build.onResolve({ filter: /.*/, namespace }, args => {
-    const { sourcePath } = splitHash(args.path);
+    const { sourcePath } = splitHash(args.path)
     const importer = args.importer.startsWith(`${namespace}:`)
       ? args.importer.slice(namespace.length + 1)
-      : args.importer;
-    const compatAlias = options.aliases[sourcePath];
+      : args.importer
+    const compatAlias = options.aliases[sourcePath]
     if (compatAlias) {
       return {
         path: path.isAbsolute(compatAlias) ? pathToFileHref(compatAlias) : compatAlias,
         external: true,
-      };
+      }
     }
     const target = resolveExternalLoadTarget({
       root: config.root,
       fromFile: importer,
       specifier: sourcePath,
       target: options.externalLoadTarget,
-    });
-    if (target) return { path: target, namespace };
+    })
+    if (target) return { path: target, namespace }
     if (sourcePath.startsWith('.') || path.isAbsolute(sourcePath)) {
-      return { path: path.resolve(path.dirname(importer), sourcePath), namespace };
+      return { path: path.resolve(path.dirname(importer), sourcePath), namespace }
     }
-    return { path: args.path, external: true };
-  });
+    return { path: args.path, external: true }
+  })
   build.onLoad({ filter: /.*/, namespace }, async args => ({
     contents: rewriteExternalLoadSpecifiers(await readText(args.path), args.path, config, options),
     loader: esbuildLoader(args.path),
     resolveDir: path.dirname(args.path),
-  }));
+  }))
 }
 
 function rewriteExternalLoadSpecifiers(
@@ -1883,74 +1963,74 @@ function rewriteExternalLoadSpecifiers(
   // Folded onto the module record (PERF-REWRITES #28); side-effect imports keep
   // resolving through the host, as under the `from`-anchored regex.
   return rewriteSpecifierLiterals(source, file, (specifier, kind) => {
-    if (kind === 'side-effect' || !specifier.startsWith('#')) return undefined;
+    if (kind === 'side-effect' || !specifier.startsWith('#')) return undefined
     const target = resolveExternalLoadTarget({
       root: config.root,
       fromFile: file,
       specifier,
       target: options.externalLoadTarget,
-    });
-    return target ? JSON.stringify(target) : undefined;
-  });
+    })
+    return target ? JSON.stringify(target) : undefined
+  })
 }
 
 async function externalLoadNeedsFacade(file: string) {
-  const source = await readText(file).catch(() => '');
-  return /\bfrom\s*['"]#|\b(?:import|require)\s*\(\s*['"]#/.test(source);
+  const source = await readText(file).catch(() => '')
+  return /\bfrom\s*['"]#|\b(?:import|require)\s*\(\s*['"]#/.test(source)
 }
 
 function addExtensionlessDynamicImportGlobAliases(source: string) {
-  if (!source.includes('__glob({')) return source;
-  const lines = source.split('\n');
-  const next: string[] = [];
-  let inGlob = false;
-  const keys = new Set<string>();
+  if (!source.includes('__glob({')) return source
+  const lines = source.split('\n')
+  const next: string[] = []
+  let inGlob = false
+  const keys = new Set<string>()
 
   for (const line of lines) {
     if (line.includes('__glob({')) {
-      inGlob = true;
-      keys.clear();
+      inGlob = true
+      keys.clear()
     }
     if (inGlob) {
-      const key = globKey(line);
-      if (key) keys.add(key);
+      const key = globKey(line)
+      if (key) keys.add(key)
     }
-    next.push(line);
+    next.push(line)
     if (inGlob) {
-      const aliases = globAliases(line, keys);
+      const aliases = globAliases(line, keys)
       if (aliases.length > 0) {
-        if (!line.endsWith(',')) next[next.length - 1] = `${line},`;
-        const value = line.replace(/^(\s*)"[^"]+":\s*/, '');
-        const normalizedValue = value.endsWith(',') ? value.slice(0, -1) : value;
+        if (!line.endsWith(',')) next[next.length - 1] = `${line},`
+        const value = line.replace(/^(\s*)"[^"]+":\s*/, '')
+        const normalizedValue = value.endsWith(',') ? value.slice(0, -1) : value
         for (const alias of aliases) {
-          keys.add(alias);
-          next.push(`${line.match(/^\s*/)?.[0] ?? ''}${JSON.stringify(alias)}: ${normalizedValue},`);
+          keys.add(alias)
+          next.push(`${line.match(/^\s*/)?.[0] ?? ''}${JSON.stringify(alias)}: ${normalizedValue},`)
         }
       }
     }
     if (inGlob && line.trim() === '});') {
-      const previous = next[next.length - 2];
-      if (previous?.endsWith(',')) next[next.length - 2] = previous.slice(0, -1);
-      inGlob = false;
+      const previous = next[next.length - 2]
+      if (previous?.endsWith(',')) next[next.length - 2] = previous.slice(0, -1)
+      inGlob = false
     }
   }
 
-  return next.join('\n');
+  return next.join('\n')
 }
 
 function globKey(line: string) {
-  return /^\s*"([^"]+)":\s*/.exec(line)?.[1];
+  return /^\s*"([^"]+)":\s*/.exec(line)?.[1]
 }
 
 function globAliases(line: string, existing: Set<string>) {
-  const key = globKey(line);
-  if (!key) return [];
-  const extension = path.extname(key);
-  if (!extensionlessDynamicImportExtensions.has(extension)) return [];
-  const aliases = [key.slice(0, -extension.length)];
-  const indexSuffix = `/index${extension}`;
-  if (key.endsWith(indexSuffix)) aliases.push(key.slice(0, -indexSuffix.length));
-  return aliases.filter(alias => alias && !existing.has(alias));
+  const key = globKey(line)
+  if (!key) return []
+  const extension = path.extname(key)
+  if (!extensionlessDynamicImportExtensions.has(extension)) return []
+  const aliases = [key.slice(0, -extension.length)]
+  const indexSuffix = `/index${extension}`
+  if (key.endsWith(indexSuffix)) aliases.push(key.slice(0, -indexSuffix.length))
+  return aliases.filter(alias => alias && !existing.has(alias))
 }
 
 async function externalBundleSpecifiers(
@@ -1959,12 +2039,14 @@ async function externalBundleSpecifiers(
   file: string,
   options: DevModuleOptions,
 ) {
-  const bundles = new Map<string, string>();
-  if (!options.bundleExternalPackages) return bundles;
+  const bundles = new Map<string, string>()
+  if (!options.bundleExternalPackages) return bundles
 
-  const candidates = [...new Set(importSpecifiers(source, file).map(specifier => splitHash(specifier).sourcePath))]
+  const candidates = [
+    ...new Set(importSpecifiers(source, file).map(specifier => splitHash(specifier).sourcePath)),
+  ]
     .filter(specifier => !isServerIgnoredAssetSpecifier(specifier))
-    .filter(specifier => shouldBundleExternalPackage(specifier, config, file, options));
+    .filter(specifier => shouldBundleExternalPackage(specifier, config, file, options))
   await Promise.all(
     candidates.map(async specifier => {
       bundles.set(
@@ -1976,10 +2058,10 @@ async function externalBundleSpecifiers(
           path.dirname(file),
           options.conditionTarget,
         ),
-      );
+      )
     }),
-  );
-  return bundles;
+  )
+  return bundles
 }
 
 function shouldBundleExternalPackage(
@@ -1988,76 +2070,84 @@ function shouldBundleExternalPackage(
   file: string,
   options: DevModuleOptions,
 ) {
-  if (options.aliases[specifier]) return false;
-  if (specifier === 'server-only') return false;
-  if (!isPackageSpecifier(specifier)) return false;
-  const resolved = resolveImport(config.root, file, specifier);
-  const inWorkspace = resolved !== undefined && isInside(config.workspaceRoot, resolved);
+  if (options.aliases[specifier]) return false
+  if (specifier === 'server-only') return false
+  if (!isPackageSpecifier(specifier)) return false
+  const resolved = resolveImport(config.root, file, specifier)
+  const inWorkspace = resolved !== undefined && isInside(config.workspaceRoot, resolved)
   // transpilePackages force-bundle; serverExternalPackages force-external (never bundled). A
   // transpiled package that resolves INSIDE the workspace is first-party source, not a registry
   // copy: it belongs to the batched module pipeline, which compiles it per file instead of
   // re-bundling its whole graph once per demanded subpath. Named imports survive that boundary
   // because CommonJS deps are now externalized or faceted rather than inlined. "Vendor" is registry
   // node_modules only.
-  const packageName = packageNameOfSpecifier(specifier);
+  const packageName = packageNameOfSpecifier(specifier)
   if (packageName) {
-    const policy = getExternalPackagePolicy();
-    if (policy.transpile(packageName)) return !inWorkspace;
-    if (policy.external(packageName)) return false;
+    const policy = getExternalPackagePolicy()
+    if (policy.transpile(packageName)) return !inWorkspace
+    if (policy.external(packageName)) return false
   }
-  return !inWorkspace;
+  return !inWorkspace
 }
 
 function clientSsrAliases(config: ResolvedConfig) {
   return {
     ...coreAliases(config, 'client'),
     ...getImportAliasExtensions().clientSsrAliases(config),
-  };
+  }
 }
 
 /** Absolute files of this module's dynamic(ssr:false) targets — the dev split points. */
 function deferredDynamicTargetFiles(source: string, config: ResolvedConfig, file: string) {
-  const specifiers = deferredDynamicImportSpecifiers(source, file);
-  if (specifiers.size === 0) return undefined;
-  const files = new Set<string>();
+  const specifiers = deferredDynamicImportSpecifiers(source, file)
+  if (specifiers.size === 0) return undefined
+  const files = new Set<string>()
   for (const specifier of specifiers) {
-    const resolved = resolveLocalImport(config, file, specifier);
-    if (resolved) files.add(path.resolve(resolved));
+    const resolved = resolveLocalImport(config, file, specifier)
+    if (resolved) files.add(path.resolve(resolved))
   }
-  return files.size > 0 ? files : undefined;
+  return files.size > 0 ? files : undefined
 }
 
-function localImportTargets(source: string, config: ResolvedConfig, file: string, aliases: AliasMap) {
-  const targets: { target: string; isLocalSource: boolean }[] = [];
+function localImportTargets(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  aliases: AliasMap,
+) {
+  const targets: { target: string; isLocalSource: boolean }[] = []
   for (const specifier of importSpecifiers(source, file)) {
     // Compat-aliased specifiers (next/server etc.) are rewritten at build
     // time; never resolve them locally — inside a workspace that ships a real
     // `next` package they would drag its whole module graph into the recursion.
-    const { sourcePath } = splitHash(specifier);
-    if (aliases[specifier] || aliases[sourcePath]) continue;
+    const { sourcePath } = splitHash(specifier)
+    if (aliases[specifier] || aliases[sourcePath]) continue
     // Non-css ignored assets (scss, fonts, images) are stubbed at build time;
     // compiling them as modules would fail the import scan. Css keeps its
     // copy-through so compiled css module paths stay importable.
-    if (isServerIgnoredAssetSpecifier(sourcePath) && !isCssFile(sourcePath)) continue;
-    const resolved = resolveImport(config.root, file, sourcePath);
+    if (isServerIgnoredAssetSpecifier(sourcePath) && !isCssFile(sourcePath)) continue
+    const resolved = resolveImport(config.root, file, sourcePath)
     // `resolveExtensions` can land an extensionless specifier on an asset
     // (`import img from './image'` -> image.png), which the specifier check
     // above misses — compiling the image bytes as a module fails the build.
-    if (resolved && isServerIgnoredAssetSpecifier(resolved) && !isCssFile(resolved)) continue;
+    if (resolved && isServerIgnoredAssetSpecifier(resolved) && !isCssFile(resolved)) continue
     // A loader-rule source is not a module either: its chain output is
     // materialized by the resolvers, so compiling the raw file would only fail
     // the parse (`*.txt`, `*.test-file.ts`, …).
-    if (resolved && getAssetExtensions().hasLoaderRuleFor(resolved)) continue;
+    if (resolved && getAssetExtensions().hasLoaderRuleFor(resolved)) continue
     // Our own emitted artifacts (a tree-shake facade the source above was just rewritten to point at, a
     // vendor bundle) are already compiled modules Bun imports directly. Feeding one back through the
     // pipeline compiles it a SECOND time, splitting module identity and pulling artifact names into the
     // source graph, where every boot's fresh names look like edits.
     if (resolved && !isInside(config.outPath, resolved)) {
-      targets.push({ target: resolved, isLocalSource: sourcePath.startsWith('.') || path.isAbsolute(sourcePath) });
+      targets.push({
+        target: resolved,
+        isLocalSource: sourcePath.startsWith('.') || path.isAbsolute(sourcePath),
+      })
     }
   }
 
-  return targets;
+  return targets
 }
 
 async function writeClientReferenceModules(
@@ -2066,57 +2156,57 @@ async function writeClientReferenceModules(
   file: string,
   aliases: AliasMap,
 ) {
-  const references = new Map<string, { file: string; exports: Set<string> }>();
+  const references = new Map<string, { file: string; exports: Set<string> }>()
 
   for (const specifier of importSpecifiers(source, file)) {
-    const { sourcePath } = splitHash(specifier);
-    if (aliases[specifier] || aliases[sourcePath]) continue;
-    const resolved = resolveImport(config.root, file, sourcePath);
-    if (!resolved || !isInside(config.workspaceRoot, resolved) || isCssFile(resolved)) continue;
-    if (!(await fileHasUseClientDirective(resolved))) continue;
+    const { sourcePath } = splitHash(specifier)
+    if (aliases[specifier] || aliases[sourcePath]) continue
+    const resolved = resolveImport(config.root, file, sourcePath)
+    if (!resolved || !isInside(config.workspaceRoot, resolved) || isCssFile(resolved)) continue
+    if (!(await fileHasUseClientDirective(resolved))) continue
 
-    const entry = references.get(sourcePath) ?? { file: resolved, exports: new Set<string>() };
+    const entry = references.get(sourcePath) ?? { file: resolved, exports: new Set<string>() }
     for (const exportName of await clientReferenceExportNames(config, resolved)) {
-      entry.exports.add(exportName);
+      entry.exports.add(exportName)
     }
-    references.set(sourcePath, entry);
+    references.set(sourcePath, entry)
   }
 
-  const specifiers = new Map<string, string>();
-  const files = new Set<string>();
+  const specifiers = new Map<string, string>()
+  const files = new Set<string>()
   await Promise.all(
     [...references.entries()].map(async ([specifier, reference]) => {
-      const stub = await clientReferencePath(config, reference.file);
-      await writeClientReferenceModule(stub, reference.file, [...reference.exports].sort());
-      specifiers.set(specifier, stub);
-      files.add(path.resolve(reference.file));
+      const stub = await clientReferencePath(config, reference.file)
+      await writeClientReferenceModule(stub, reference.file, [...reference.exports].sort())
+      specifiers.set(specifier, stub)
+      files.add(path.resolve(reference.file))
     }),
-  );
+  )
 
-  return { specifiers, files };
+  return { specifiers, files }
 }
 
 async function writeClientReferenceModule(file: string, sourceFile: string, exportNames: string[]) {
-  await mkdir(path.dirname(file), { recursive: true });
-  await writeCompiledFile(file, clientReferenceModuleSource(sourceFile, exportNames));
+  await mkdir(path.dirname(file), { recursive: true })
+  await writeCompiledFile(file, clientReferenceModuleSource(sourceFile, exportNames))
 }
 
 async function fileHasUseClientDirective(file: string) {
-  return hasUseClientDirective(await readText(file));
+  return hasUseClientDirective(await readText(file))
 }
 
 function splitHash(specifier: string) {
   // A leading '#' is a subpath-import/tsconfig-paths specifier (e.g. '#/lib/x'),
   // not a fragment separator.
-  const index = specifier.startsWith('#') ? specifier.indexOf('#', 1) : specifier.indexOf('#');
+  const index = specifier.startsWith('#') ? specifier.indexOf('#', 1) : specifier.indexOf('#')
   return index === -1
     ? { sourcePath: specifier, hash: '' }
-    : { sourcePath: specifier.slice(0, index), hash: specifier.slice(index) };
+    : { sourcePath: specifier.slice(0, index), hash: specifier.slice(index) }
 }
 
 function isInside(root: string, file: string) {
-  const relative = path.relative(root, file);
-  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+  const relative = path.relative(root, file)
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
 }
 
 function devModuleProfile(options: DevModuleOptions) {
@@ -2126,35 +2216,35 @@ function devModuleProfile(options: DevModuleOptions) {
     // compiled modules (and baked-in vendor hrefs) in separate cache dirs.
     return options.conditionTarget === 'client'
       ? options.profile
-      : `client-${options.conditionTarget}`;
+      : `client-${options.conditionTarget}`
   }
   const externalTarget =
     options.externalLoadTarget === externalLoadTargetForConditionTarget(options.conditionTarget)
       ? ''
-      : `-external-${options.externalLoadTarget}`;
-  return `${options.profile}-${options.conditionTarget}${externalTarget}${options.reactServerLayer ? '-react-server' : ''}`;
+      : `-external-${options.externalLoadTarget}`
+  return `${options.profile}-${options.conditionTarget}${externalTarget}${options.reactServerLayer ? '-react-server' : ''}`
 }
 
 // Compiled artifacts are named `<source name>.<graph hash>.<ext>` under a per-profile directory that
 // mirrors the source tree. The hash covers the module's whole source graph, so an edit renames the edited
 // file and its dependents and nothing else - a stale artifact is simply never asked for.
 function devServerPath(config: ResolvedConfig, file: string, profile: string, hash: string) {
-  const key = devServerCacheKey(config, file);
-  const ext = path.extname(key) || '.js';
+  const key = devServerCacheKey(config, file)
+  const ext = path.extname(key) || '.js'
   // A compiled `.json` module is JS (esbuild's json loader wraps it in exports),
   // so it must not keep the `.json` name — the runtime would parse the artifact
   // as JSON. Keeping the source name in front of `.js` keeps it collision-free.
-  const outExt = ext === '.json' ? '.json.js' : ext;
+  const outExt = ext === '.json' ? '.json.js' : ext
   return path.join(
     cacheRoot(config.outPath),
     profile === 'server' ? 'modules' : `modules-${profile}`,
     `${key.slice(0, key.length - ext.length)}.${hash}${outExt}`,
-  );
+  )
 }
 
 /** The staged directory mirroring `dir` for `profile` (asset links live there). */
 function devServerDir(config: ResolvedConfig, dir: string, profile: string) {
-  return path.dirname(devServerPath(config, path.join(dir, '__pnext_context__.js'), profile, 'dir'));
+  return path.dirname(devServerPath(config, path.join(dir, '__pnext_context__.js'), profile, 'dir'))
 }
 
 // A module compiled standalone (not merely as a transitive import of an
@@ -2168,23 +2258,23 @@ function devServerDir(config: ResolvedConfig, dir: string, profile: string) {
 // location once written there). Key those out-of-workspace files by a stable
 // hash of their absolute path instead of a relative path.
 function devServerCacheKey(config: ResolvedConfig, file: string) {
-  if (isInside(config.workspaceRoot, file)) return path.relative(config.workspaceRoot, file);
+  if (isInside(config.workspaceRoot, file)) return path.relative(config.workspaceRoot, file)
   // Hash the portable identity, not the absolute path: a deployed build runs
   // these same files from a different root and must find the same artifact.
   const hash = createHash('sha256')
     .update(devSourceIdentity(file, config.workspaceRoot))
     .digest('hex')
-    .slice(0, 16);
-  return path.join('external', `${hash}${path.extname(file) || '.js'}`);
+    .slice(0, 16)
+  return path.join('external', `${hash}${path.extname(file) || '.js'}`)
 }
 
 // Bundle names memoized per (route, entries) so a warm request re-derives
 // nothing; any save clears the whole map (see clearDevRouteBundleKeys).
-const routeBundleKeys = new Map<string, Promise<string>>();
+const routeBundleKeys = new Map<string, Promise<string>>()
 
 /** A save may rename any route bundle: drop every memoized name. */
 export function clearDevRouteBundleKeys() {
-  routeBundleKeys.clear();
+  routeBundleKeys.clear()
 }
 
 // The route bundle inlines the route file and its layouts, so its name carries
@@ -2194,16 +2284,16 @@ function devRouteBundlePath(
   route: RouteManifestEntry,
   layoutFiles: string[],
 ) {
-  const entries = uniqueFiles([route.file, ...layoutFiles]);
-  const memoKey = `${route.id}\0${entries.join('\0')}`;
-  const memoized = routeBundleKeys.get(memoKey);
-  if (memoized) return memoized;
+  const entries = uniqueFiles([route.file, ...layoutFiles])
+  const memoKey = `${route.id}\0${entries.join('\0')}`
+  const memoized = routeBundleKeys.get(memoKey)
+  if (memoized) return memoized
   const next = computeDevRouteBundlePath(config, route, entries).catch(error => {
-    routeBundleKeys.delete(memoKey);
-    throw error;
-  });
-  routeBundleKeys.set(memoKey, next);
-  return next;
+    routeBundleKeys.delete(memoKey)
+    throw error
+  })
+  routeBundleKeys.set(memoKey, next)
+  return next
 }
 
 async function computeDevRouteBundlePath(
@@ -2211,12 +2301,12 @@ async function computeDevRouteBundlePath(
   route: RouteManifestEntry,
   entries: string[],
 ) {
-  const graph = devModuleGraph(config);
-  const cached = await cachedRouteBundlePath(config, route.id, graph.graphKey, entries);
-  if (cached) return cached;
-  const hashes = await Promise.all(entries.map(file => graph.graphHash(file)));
-  const hash = createHash('sha256').update(hashes.join('\0')).digest('hex').slice(0, 16);
-  const bundle = path.join(cacheRoot(config.outPath), 'routes', `${route.id}.${hash}.mjs`);
+  const graph = devModuleGraph(config)
+  const cached = await cachedRouteBundlePath(config, route.id, graph.graphKey, entries)
+  if (cached) return cached
+  const hashes = await Promise.all(entries.map(file => graph.graphHash(file)))
+  const hash = createHash('sha256').update(hashes.join('\0')).digest('hex').slice(0, 16)
+  const bundle = path.join(cacheRoot(config.outPath), 'routes', `${route.id}.${hash}.mjs`)
   saveRouteBundlePath(
     config,
     route.id,
@@ -2224,82 +2314,85 @@ async function computeDevRouteBundlePath(
     entries,
     bundle,
     await graph.graphSources(entries),
-  );
-  return bundle;
+  )
+  return bundle
 }
 
 async function clientReferencePath(config: ResolvedConfig, file: string) {
-  return `${await devModulePathFor(config, file, 'compat')}.client-reference.ts`;
+  return `${await devModulePathFor(config, file, 'compat')}.client-reference.ts`
 }
 
 function isCssFile(file: string) {
-  return file.endsWith('.css');
+  return file.endsWith('.css')
 }
 
 function isStaticImageFile(file: string) {
-  return /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/.test(file);
+  return /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/.test(file)
 }
 
 const serverIgnoredAssetFilter =
-  /\.(?:css|scss|sass|woff2?|ttf|otf|eot|png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/;
+  /\.(?:css|scss|sass|woff2?|ttf|otf|eot|png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/
 
 function isServerIgnoredAssetSpecifier(specifier: string) {
-  return serverIgnoredAssetFilter.test(specifier);
+  return serverIgnoredAssetFilter.test(specifier)
 }
 
 function esbuildLoader(file: string) {
-  if (file.endsWith('.tsx')) return 'tsx';
-  if (file.endsWith('.ts')) return 'ts';
+  if (file.endsWith('.tsx')) return 'tsx'
+  if (file.endsWith('.ts')) return 'ts'
   // `import data from './x.json'` is an ordinary module edge, so the walk
   // reaches the data file itself; parsing it as JS fails on the first key.
-  if (file.endsWith('.json')) return 'json';
+  if (file.endsWith('.json')) return 'json'
   // App-convention .js/.jsx/.mjs modules may contain JSX (jsxImportSource is
   // preact via the build config), so parse them with the jsx loader. .tsx/.ts
   // keep their dedicated loaders above for the fast path.
-  return 'jsx';
+  return 'jsx'
 }
 
 function isPackageSpecifier(specifier: string) {
-  if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('file:')) return false;
-  if (specifier.startsWith('#')) return false;
-  if (specifier.startsWith('node:')) return false;
-  if (specifier.includes(':')) return false;
-  const packageName = packageNameFromSpecifier(specifier);
-  return Boolean(packageName && !builtinModules.includes(packageName));
+  if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('file:'))
+    return false
+  if (specifier.startsWith('#')) return false
+  if (specifier.startsWith('node:')) return false
+  if (specifier.includes(':')) return false
+  const packageName = packageNameFromSpecifier(specifier)
+  return Boolean(packageName && !builtinModules.includes(packageName))
 }
 
 function isBuiltinSpecifier(specifier: string) {
-  if (specifier.startsWith('node:')) return true;
-  const packageName = packageNameFromSpecifier(specifier);
-  return Boolean(packageName && builtinModules.includes(packageName));
+  if (specifier.startsWith('node:')) return true
+  const packageName = packageNameFromSpecifier(specifier)
+  return Boolean(packageName && builtinModules.includes(packageName))
 }
 
 function packageNameFromSpecifier(specifier: string) {
-  const parts = specifier.split('/');
-  return specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+  const parts = specifier.split('/')
+  return specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
 }
 
 function resolveLocalImport(config: ResolvedConfig, fromFile: string, specifier: string) {
-  if (path.isAbsolute(specifier)) return existsSync(specifier) ? specifier : undefined;
-  return resolveImport(config.root, fromFile, specifier);
+  if (path.isAbsolute(specifier)) return existsSync(specifier) ? specifier : undefined
+  return resolveImport(config.root, fromFile, specifier)
 }
 
 async function linkAssetContext(config: ResolvedConfig, file: string, profile: string) {
-  if (!isInside(config.root, file)) return;
-  const sourceDirs = ancestorDirs(config.root, path.dirname(file));
-  await Promise.all(sourceDirs.map(sourceDir => linkDirectoryAssetContext(config, sourceDir, profile)));
+  if (!isInside(config.root, file)) return
+  const sourceDirs = ancestorDirs(config.root, path.dirname(file))
+  await Promise.all(
+    sourceDirs.map(sourceDir => linkDirectoryAssetContext(config, sourceDir, profile)),
+  )
 }
 
 function ancestorDirs(root: string, dir: string) {
-  const dirs = [root];
-  const relative = path.relative(root, dir);
-  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return dirs;
-  let current = root;
+  const dirs = [root]
+  const relative = path.relative(root, dir)
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return dirs
+  let current = root
   for (const segment of relative.split(path.sep).filter(Boolean)) {
-    current = path.join(current, segment);
-    dirs.push(current);
+    current = path.join(current, segment)
+    dirs.push(current)
   }
-  return dirs;
+  return dirs
 }
 
 async function linkDirectoryAssetContext(
@@ -2307,35 +2400,35 @@ async function linkDirectoryAssetContext(
   sourceDir: string,
   profile: string,
 ) {
-  let entries: Dirent<string>[];
+  let entries: Dirent<string>[]
   try {
-    entries = await readdir(sourceDir, { withFileTypes: true, encoding: 'utf8' });
+    entries = await readdir(sourceDir, { withFileTypes: true, encoding: 'utf8' })
   } catch {
-    return;
+    return
   }
-  const targetDir = devServerDir(config, sourceDir, profile);
+  const targetDir = devServerDir(config, sourceDir, profile)
   await Promise.all(
     entries.map(async entry => {
-      if (!assetContextEntry(config, sourceDir, entry.name, entry.isDirectory())) return;
-      const source = path.join(sourceDir, entry.name);
-      const target = path.join(targetDir, entry.name);
+      if (!assetContextEntry(config, sourceDir, entry.name, entry.isDirectory())) return
+      const source = path.join(sourceDir, entry.name)
+      const target = path.join(targetDir, entry.name)
       // Root-level sibling asset directories are mirrored, not symlinked wholesale: a `dir` symlink
       // would make every path beneath it - including code modules that must be compiled through the
       // alias transform - resolve straight back to raw source, shadowing the staged compile.
       // Mirroring links only non-code leaf files.
       if (entry.isDirectory()) {
-        await mirrorAssetDirectory(source, target);
-        return;
+        await mirrorAssetDirectory(source, target)
+        return
       }
-      if (existsSync(target)) return;
-      await mkdir(path.dirname(target), { recursive: true });
+      if (existsSync(target)) return
+      await mkdir(path.dirname(target), { recursive: true })
       try {
-        await symlink(source, target, 'file');
+        await symlink(source, target, 'file')
       } catch {
-        if (!existsSync(target)) await copyFile(source, target);
+        if (!existsSync(target)) await copyFile(source, target)
       }
     }),
-  );
+  )
 }
 
 // Recursively stage an asset directory: link non-code leaf files and recurse
@@ -2343,31 +2436,31 @@ async function linkDirectoryAssetContext(
 // module graph into their own staged output and must not be shadowed by a raw
 // symlink.
 async function mirrorAssetDirectory(sourceDir: string, targetDir: string) {
-  let entries: Dirent<string>[];
+  let entries: Dirent<string>[]
   try {
-    entries = await readdir(sourceDir, { withFileTypes: true, encoding: 'utf8' });
+    entries = await readdir(sourceDir, { withFileTypes: true, encoding: 'utf8' })
   } catch {
-    return;
+    return
   }
   await Promise.all(
     entries.map(async entry => {
-      if (entry.name.startsWith('.')) return;
-      const source = path.join(sourceDir, entry.name);
-      const target = path.join(targetDir, entry.name);
+      if (entry.name.startsWith('.')) return
+      const source = path.join(sourceDir, entry.name)
+      const target = path.join(targetDir, entry.name)
       if (entry.isDirectory()) {
-        await mirrorAssetDirectory(source, target);
-        return;
+        await mirrorAssetDirectory(source, target)
+        return
       }
-      if (isCodeFile(entry.name)) return;
-      if (existsSync(target)) return;
-      await mkdir(path.dirname(target), { recursive: true });
+      if (isCodeFile(entry.name)) return
+      if (existsSync(target)) return
+      await mkdir(path.dirname(target), { recursive: true })
       try {
-        await symlink(source, target, 'file');
+        await symlink(source, target, 'file')
       } catch {
-        if (!existsSync(target)) await copyFile(source, target);
+        if (!existsSync(target)) await copyFile(source, target)
       }
     }),
-  );
+  )
 }
 
 function assetContextEntry(
@@ -2376,9 +2469,9 @@ function assetContextEntry(
   name: string,
   directory: boolean,
 ) {
-  if (name.startsWith('.')) return false;
-  if (!directory) return !isCodeFile(name);
-  if (sourceDir !== config.root) return false;
+  if (name.startsWith('.')) return false
+  if (!directory) return !isCodeFile(name)
+  if (sourceDir !== config.root) return false
   return !new Set([
     'app',
     'src',
@@ -2386,40 +2479,40 @@ function assetContextEntry(
     'public',
     'node_modules',
     path.basename(config.outRootPath),
-  ]).has(name);
+  ]).has(name)
 }
 
 function isCodeFile(file: string) {
-  if (/\.(?:tsx?|jsx?|mjs|cjs)$/.test(file)) return true;
+  if (/\.(?:tsx?|jsx?|mjs|cjs)$/.test(file)) return true
   // Extra loadable source extensions registered by compat (e.g. mdx/md) compile
   // through the module graph, so they must not be symlinked raw as asset
   // context — otherwise the raw markdown shadows the compiled staged module.
-  const dot = file.lastIndexOf('.');
-  if (dot < 0) return false;
-  return extraLoadableExtensions().includes(file.slice(dot + 1));
+  const dot = file.lastIndexOf('.')
+  if (dot < 0) return false
+  return extraLoadableExtensions().includes(file.slice(dot + 1))
 }
 
 function resolveAssetPath(specifier: string, resolveDir: string) {
-  const { sourcePath, hash } = splitHash(specifier);
-  return `${path.isAbsolute(sourcePath) ? sourcePath : path.resolve(resolveDir, sourcePath)}${hash}`;
+  const { sourcePath, hash } = splitHash(specifier)
+  return `${path.isAbsolute(sourcePath) ? sourcePath : path.resolve(resolveDir, sourcePath)}${hash}`
 }
 
 async function staticImageModuleSource(config: ResolvedConfig, file: string) {
-  const { sourcePath } = splitHash(file);
-  const bytes = new Uint8Array(await Bun.file(sourcePath).arrayBuffer());
-  const emitted: string[] = [];
+  const { sourcePath } = splitHash(file)
+  const bytes = new Uint8Array(await Bun.file(sourcePath).arrayBuffer())
+  const emitted: string[] = []
   const emit = (relative: string) => {
-    emitted.push(relative);
-    return `/${relative}`;
-  };
-  const compat = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit });
-  const source = compat ?? coreStaticAssetModule(sourcePath, bytes, emit);
+    emitted.push(relative)
+    return `/${relative}`
+  }
+  const compat = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit })
+  const source = compat ?? coreStaticAssetModule(sourcePath, bytes, emit)
   for (const relative of emitted) {
-    const target = path.join(config.outPath, 'public', ...relative.split('/'));
-    await mkdir(path.dirname(target), { recursive: true });
-    if (!existsSync(target)) await copyFile(sourcePath, target);
+    const target = path.join(config.outPath, 'public', ...relative.split('/'))
+    await mkdir(path.dirname(target), { recursive: true })
+    if (!existsSync(target)) await copyFile(sourcePath, target)
   }
-  return source;
+  return source
 }
 
 // Core's generic static-asset module (no compat override): emit under a hashed
@@ -2429,31 +2522,25 @@ function coreStaticAssetModule(
   bytes: Uint8Array,
   emit: (relative: string, bytes: Uint8Array) => string,
 ): string {
-  const ext = path.extname(sourcePath).toLowerCase() || '.bin';
-  const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 8);
-  const base = path.basename(sourcePath, path.extname(sourcePath)).replace(/[^A-Za-z0-9_-]+/g, '-');
-  const relative = getAssetExtensions().staticAssetRelativePath({ sourcePath, hash, base, ext });
-  const src = emit(relative, bytes);
-  return `const src = ${JSON.stringify(src)};\nexport default src;\nexport { src };\n`;
+  const ext = path.extname(sourcePath).toLowerCase() || '.bin'
+  const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 8)
+  const base = path.basename(sourcePath, path.extname(sourcePath)).replace(/[^A-Za-z0-9_-]+/g, '-')
+  const relative = getAssetExtensions().staticAssetRelativePath({ sourcePath, hash, base, ext })
+  const src = emit(relative, bytes)
+  return `const src = ${JSON.stringify(src)};\nexport default src;\nexport { src };\n`
 }
 
 function uniqueFiles(files: string[]) {
-  return [...new Set(files.map(file => path.resolve(file)).filter(file => existsSync(file)))];
+  return [...new Set(files.map(file => path.resolve(file)).filter(file => existsSync(file)))]
 }
 
 async function profileDevImport<T>(label: string, task: () => Promise<T>) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (!process.env.PNEXT_DEV_PROFILE) return task();
-  const start = performance.now();
+  if (!process.env.PNEXT_DEV_PROFILE) return task()
+  const start = performance.now()
   try {
-    return await task();
+    return await task()
   } finally {
-    console.log(`dev-import ${label} in ${formatDuration(performance.now() - start)}`);
+    console.log(`dev-import ${label} in ${formatDuration(performance.now() - start)}`)
   }
 }
-
-function formatDuration(durationMs: number) {
-  if (durationMs < 10) return `${durationMs.toFixed(1)}ms`;
-  if (durationMs < 1000) return `${Math.round(durationMs)}ms`;
-  return `${(durationMs / 1000).toFixed(durationMs < 10000 ? 2 : 1)}s`;
-}