@wular/pnext 0.0.1

package/src/dev/imports.ts

@@ -0,0 +1,2430 @@
+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 { build, type OnResolveResult, type Plugin } from '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';
+import {
+  externalServerPackageHref,
+  rewriteServerSource,
+  runtimeServerImportTarget,
+  serverBundleTargetForRuntime,
+  serverBundleRequireConditions,
+  type ServerBundleTarget,
+} from '../runtime/server';
+import { writeFileAtomic } from '../utils/fs';
+import { createHash } from 'node:crypto';
+import {
+  extraLoadableExtensions,
+  getAssetExtensions,
+  getBundlerExtensions,
+  getCssExtensions,
+  getImportAliasExtensions,
+  serverDefineOptions,
+} from '../extensions';
+import {
+  frameworkRuntimeAliasEntries,
+  pathToFileHref,
+  pnextAliases,
+  type CompatAliasTarget,
+  type ResolvedConfig,
+} from '../config';
+import { readText, toPosixPath } from '../utils/fs';
+import {
+  type ExternalLoadTarget,
+  externalPackageImportTarget,
+  getExternalPackagePolicy,
+  isCommonJsModuleSource,
+  packageNameOfSpecifier,
+  resolveImport,
+  resolveExternalLoadTarget,
+  resolvePackageSpecifier,
+} from '../resolve/imports';
+import { importSpecifiers, rewriteSpecifierLiterals } from '../resolve/scan-facts';
+import {
+  cacheRoot,
+  devArtifactUsable,
+  devHeadTrimEnabled,
+  devModuleCache,
+  devSourceIdentity,
+  noteDevArtifactWritten,
+  type DevModuleCache,
+} from './module-cache';
+import { cachedRouteBundlePath, saveRouteBundlePath } from './route-bundle-key-cache';
+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';
+
+type AliasMap = Record<string, string>;
+
+function nextCompatEnabled(config: ResolvedConfig) {
+  return Boolean(config.compat?.next);
+}
+
+function reactCompatEnabled(config: ResolvedConfig) {
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+}
+
+function coreAliases(config: ResolvedConfig, target: CompatAliasTarget): AliasMap {
+  return {
+    ...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>>();
+
+// 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 }
+// `${profile}:${file}` of modules that fell off the oxc fast path onto esbuild.
+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;
+
+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);
+  // 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?.();
+}
+
+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;
+  for (const entries of moduleStats.values()) {
+    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);
+    }
+    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 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`);
+  console.error(
+    [
+      `dev-module-stats ${moduleStats.size} distinct files, ${total} compiles`,
+      ...rows,
+      `  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 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);
+}
+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>();
+
+/** 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);
+  // Pre-planned vendor builds are enqueued without an awaiter; nothing
+  // evaluates until they all settle (no-op when the pipeline is empty).
+  await drainPreplanBuilds();
+  try {
+    const module = (await import(href)) as T;
+    noteModuleImported(href);
+    return module;
+  } catch (error) {
+    moduleEvalErrors.set(href, error);
+    throw error;
+  }
+}
+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;
+
+const moduleCaches = new WeakMap<ResolvedConfig, DevModuleCache>();
+
+/**
+ * The content-addressing cache behind every compiled path (dev/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 cache = devModuleCache(config, {
+    compileKey: devCompileKey(config),
+    edges: (file, source) => graphEdges(config, file, source),
+  });
+  moduleCaches.set(config, cache);
+  return cache;
+}
+
+/**
+ * Pay the compile pipeline's FIXED first-use costs - esbuild's service child, the oxc native
+ * bindings, the cache marker and persisted graph index - without compiling anything. Nothing here is
+ * route-specific, so a fresh checkout still compiles zero routes. Every step is idempotent and shares
+ * the memo the request path uses, so racing a real first request costs nothing.
+ *
+ * Call only after `bootstrapCompat`: the graph's compile key hashes the alias extensions compat
+ * 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');
+  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' }),
+    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
+    }),
+  ]);
+}
+
+/** Compile inputs that are not sources: a change to any of them renames everything. */
+function devCompileKey(config: ResolvedConfig) {
+  return JSON.stringify({
+    // Relative, never absolute: the key names every artifact, and a deployed
+    // build runs the same workspace from a different root (see module-cache).
+    root: toPosixPath(path.relative(config.workspaceRoot, config.root)),
+    compat: config.compat ?? null,
+    nextConfig: nextConfigFingerprint(config),
+    define: serverDefineOptions().define ?? null,
+    aliases: [...devAliasKeys(config)].sort(),
+  });
+}
+
+// next.config knobs (modularizeImports, resolve aliases, compiler options) shape compiled output, and only
+// some of them reach the alias/define maps above - so the config's own bytes are part of the key. Content,
+// never mtime: a rewritten-but-identical config must not rename every artifact. Files the config imports
+// are not covered.
+const NEXT_CONFIG_BASENAMES = [
+  'next.config.ts',
+  'next.config.mts',
+  'next.config.cts',
+  'next.config.js',
+  'next.config.mjs',
+  'next.config.cjs',
+];
+
+function nextConfigFingerprint(config: ResolvedConfig) {
+  if (!config.compat?.next) return '';
+  for (const name of NEXT_CONFIG_BASENAMES) {
+    const candidate = path.join(config.root, name);
+    if (!existsSync(candidate)) continue;
+    try {
+      return `${name}:${Bun.hash(readFileSync(candidate)).toString(36)}`;
+    } catch {
+      return name;
+    }
+  }
+  return '';
+}
+
+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 keys = new Set([
+    ...Object.keys(coreAliases(config, 'server')),
+    ...Object.keys(getImportAliasExtensions().reactServerLayerAliases(config)),
+    ...Object.keys(clientSsrAliases(config)),
+  ]);
+  aliasKeys.set(config, keys);
+  return keys;
+}
+
+/**
+ * Source edges the graph hash follows. A superset of the compiled graph is safe - it only widens what
+ * a save invalidates - but a subset would leave a dependent holding a name that no longer describes
+ * 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[] = [];
+  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);
+    // Compiled output is never a source of the graph that produced it.
+    if (resolved && isInside(config.outPath, resolved)) continue;
+    if (resolved && (isLocalSource || isInside(config.workspaceRoot, resolved))) {
+      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);
+  }
+  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);
+  });
+}
+
+export interface DevServerModuleOptions {
+  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
+   * with no client hook exports on top of the base server aliases.
+   * Pages/api and other server modules keep the base aliases (full-hooks
+   * `react`, kept for backward compatibility).
+   */
+  reactServerLayer?: boolean;
+}
+
+export async function devServerModuleHref(
+  config: ResolvedConfig,
+  file: string,
+  // Compiled paths are content-addressed; the caller's dev import version no
+  // longer names them (it still keys compat's own caches).
+  _version?: string,
+  moduleOptions: DevServerModuleOptions = {},
+) {
+  const conditionTarget = pagesLayerConditionTarget(
+    config,
+    file,
+    moduleOptions.conditionTarget ?? 'server',
+  );
+  const reactServerLayer =
+    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)
+        : {}),
+    },
+    profile: reactCompatEnabled(config) ? 'compat' : 'server',
+    conditionTarget,
+    reactServerLayer,
+    externalLoadTarget:
+      moduleOptions.externalLoadTarget ??
+      externalLoadTargetForConditionTarget(conditionTarget),
+    stubClientImports: reactCompatEnabled(config),
+    rewriteExternalServerImports: true,
+    bundleExternalPackages: reactCompatEnabled(config),
+  }).finally(release);
+  return pathToFileHref(compiled);
+}
+
+export async function devClientModuleHref(
+  config: ResolvedConfig,
+  file: string,
+  _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 compiled = await writeDevModule(
+    config,
+    file,
+    new Set(),
+    clientLayerOptions(config, conditionTarget),
+  ).finally(release);
+  return pathToFileHref(compiled);
+}
+
+/**
+ * The client-layer module a `'use client'` file inside node_modules SSRs from: its package's own
+ * client vendor bundle, the same artifact the app's client code reaches that package through.
+ *
+ * Compiling the file a SECOND time as a standalone module would hand the SSR pass its own copy of
+ * everything the file shares with the rest of the package - a `createContext` call, a registry, a
+ * singleton - and a provider rendered from one copy is invisible to a consumer rendered from the
+ * other. The browser build is unaffected: it compiles the whole client graph at once.
+ *
+ * Undefined means "compile it as a module", which is the answer whenever the package cannot be shown
+ * to publish the file's exports.
+ */
+async function packageClientModuleHref(
+  config: ResolvedConfig,
+  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;
+  return externalServerPackageHref(
+    config,
+    specifier,
+    'client',
+    path.dirname(file),
+    conditionTarget,
+  ).catch(() => undefined);
+}
+
+/**
+ * The specifier an importer would use to get `file`'s exports out of its
+ * package: the `exports` subpath that resolves to it, or the package itself
+ * when its entry re-exports every name the file has.
+ */
+async function packageSpecifierPublishing(
+  config: ResolvedConfig,
+  packageDir: string,
+  file: string,
+) {
+  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 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']);
+}
+
+/** 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('.'));
+    // A conditions-only map (`{ import: ... }`) has no subpath keys at all.
+    return keys.length > 0 ? keys.filter(key => !key.includes('*')) : ['.'];
+  } catch {
+    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('/');
+}
+
+/** `…/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;
+}
+
+export interface DevRouteModuleLoaders {
+  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;
+}
+
+/**
+ * Start this route's vendor bundles as an independent stage. The graph walk
+ * that names the artifacts already knows every package the route reaches, so
+ * the builds run alongside the module pass rather than serially in front of the
+ * first module that imports one. Every build is deduped by the vendor cache, so
+ * the module pass coalesces onto these instead of starting its own.
+ */
+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);
+  const options: DevModuleOptions = {
+    aliases: coreAliases(config, 'server'),
+    profile: 'compat',
+    conditionTarget,
+    externalLoadTarget: externalLoadTargetForConditionTarget(conditionTarget),
+    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();
+  void (async () => {
+    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;
+      for (const specifier of full) {
+        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);
+    // 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({
+        kind: 'seed',
+        route: route.route,
+        layered,
+        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,
+          ),
+        ),
+      );
+    await warm(demand);
+  })().catch(() => undefined);
+}
+
+export async function devRouteModuleLoaders(
+  config: ResolvedConfig,
+  route: RouteManifestEntry,
+  layoutFiles: string[],
+  _version?: string,
+): Promise<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 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);
+  if (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]));
+  }
+
+  const next = createDevRouteModuleLoaders(config, route, layoutFiles, key)
+    .catch(error => {
+      routeModuleLoaders.delete(key);
+      throw error;
+    })
+    .finally(release);
+  routeModuleLoaders.set(key, next);
+  return next;
+}
+
+async function createDevRouteModuleLoaders(
+  config: ResolvedConfig,
+  route: RouteManifestEntry,
+  layoutFiles: string[],
+  outFile: string,
+): Promise<DevRouteModuleLoaders> {
+  const bundleFile = await writeDevRouteBundle(config, route, layoutFiles, outFile);
+  const bundle = await profileDevImport(`import route ${route.route}`, () =>
+    importDevModule<DevRouteBundle>(pathToFileHref(bundleFile)));
+  const moduleLoader = async (file: string) => {
+    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;
+    return importDevModule<Record<string, unknown>>(
+      await devClientModuleHref(
+        config,
+        file,
+        undefined,
+        serverBundleTargetForRuntime(route.segmentConfig?.runtime),
+      ),
+    );
+  };
+  return { moduleLoader, clientModuleLoader };
+}
+
+interface DevRouteBundle {
+  modules: Record<string, Record<string, unknown>>;
+  clientModules: Record<string, Record<string, unknown>>;
+}
+
+async function writeDevRouteBundle(
+  config: ResolvedConfig,
+  route: RouteManifestEntry,
+  layoutFiles: string[],
+  outFile: string,
+) {
+  if (devArtifactUsable(outFile)) return outFile;
+
+  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;
+  }).catch(error => {
+    routeBundleBuilds.delete(outFile);
+    throw error;
+  });
+
+  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},`);
+
+  return [
+    ...serverImports,
+    ...clientImports,
+    `export const modules = {${serverEntries.join('')}};`,
+    `export const clientModules = {${clientEntries.join('')}};`,
+  ].join('\n');
+}
+
+function devRouteBundlePlugin(config: ResolvedConfig, route: RouteManifestEntry): Plugin {
+  const conditionTarget = serverBundleTargetForRuntime(route.segmentConfig?.runtime);
+  const serverOptions: DevModuleOptions = {
+    aliases: {
+      ...coreAliases(config, 'server'),
+      ...getImportAliasExtensions().reactServerLayerAliases(config),
+    },
+    profile: reactCompatEnabled(config) ? 'compat' : 'server',
+    conditionTarget,
+    reactServerLayer: true,
+    externalLoadTarget: externalLoadTargetForConditionTarget(conditionTarget),
+    stubClientImports: reactCompatEnabled(config),
+    rewriteExternalServerImports: true,
+    bundleExternalPackages: reactCompatEnabled(config),
+  };
+  const clientOptions: DevModuleOptions = {
+    aliases: clientSsrAliases(config),
+    profile: 'client',
+    conditionTarget: 'client',
+    externalLoadTarget: 'client-ssr',
+    stubClientImports: false,
+    rewriteExternalServerImports: false,
+    bundleExternalPackages: reactCompatEnabled(config),
+  };
+
+  return {
+    name: 'pnext-dev-route-bundle',
+    async setup(build) {
+      // 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 }));
+      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),
+      );
+      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);
+
+      build.onLoad({ filter: /.*/, namespace: 'pnext-route-server' }, async args => ({
+        contents: rewriteServerSource(await readText(args.path), args.path, {
+          nextFonts: nextCompatEnabled(config),
+          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;
+        if (clientActions?.isClientActionModule(args.path)) {
+          return {
+            contents: await clientActions.stubSource(args.path),
+            loader: 'js',
+          };
+        }
+        return {
+          contents: rewriteServerSource(await readText(args.path), args.path, {
+            nextFonts: nextCompatEnabled(config),
+            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)),
+        loader: 'js',
+      }));
+    },
+  };
+}
+
+/**
+ * Pages-router source modules are never react-server modules: they may import client hooks at top
+ * level while only their data functions (`getStaticProps`/`getServerSideProps`) run on the server -
+ * the component half renders through the 'use client' facade. Under the react-server layer alias
+ * (hook-free react entry) evaluating such a module throws at import binding, so resolve
+ * react/react-dom for those importers to the base full-hooks server shims instead.
+ */
+function pagesCompatSourceAlias(
+  config: ResolvedConfig,
+  specifier: string,
+  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];
+}
+
+async function resolveRouteBundleSpecifier(
+  config: ResolvedConfig,
+  specifier: string,
+  importer: string,
+  namespace: 'pnext-route-server' | 'pnext-route-client',
+  options: DevModuleOptions,
+): Promise<OnResolveResult | undefined> {
+  const compatAlias =
+    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 };
+
+  if (isServerIgnoredAssetSpecifier(specifier)) return undefined;
+
+  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
+  // namespace, or the loader below parses the image bytes as source.
+  if (
+    resolved &&
+    isServerIgnoredAssetSpecifier(resolved) &&
+    !getAssetExtensions().hasLoaderRuleFor(resolved)
+  ) {
+    return { path: resolved, namespace: serverAssetNamespace };
+  }
+  if (resolved && isInside(config.workspaceRoot, resolved)) {
+    if (
+      options.stubClientImports &&
+      !isCssFile(resolved) &&
+      await fileHasUseClientDirective(resolved)
+    ) {
+      return { path: resolved, namespace: 'pnext-client-reference' };
+    }
+    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
+  // externally exactly like the alias branch above. Without this the bundle cannot resolve it at all:
+  // 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 };
+  }
+
+  if (options.bundleExternalPackages && shouldBundleExternalPackage(sourcePath, config, importer, options)) {
+    return {
+      path: await externalServerPackageHref(
+        config,
+        sourcePath,
+        options.profile === 'client' ? 'client' : 'server',
+        path.dirname(importer),
+        options.conditionTarget,
+      ),
+      external: true,
+    };
+  }
+
+  if (isPackageSpecifier(sourcePath) || isBuiltinSpecifier(sourcePath)) {
+    const resolvedExternalLoad = resolveExternalLoadTarget({
+      root: config.root,
+      fromFile: importer,
+      specifier: sourcePath,
+      target: options.externalLoadTarget,
+    });
+    if (resolvedExternalLoad && await externalLoadNeedsFacade(resolvedExternalLoad)) {
+      return {
+        path: resolvedExternalLoad,
+        namespace: options.profile === 'client'
+          ? externalLoadNamespaces.client
+          : externalLoadNamespaces.server,
+      };
+    }
+    const externalTarget =
+      resolvedExternalLoad ?? externalPackageImportTarget(config.root, importer, sourcePath);
+    return {
+      path: externalTarget
+        ? `${pathToFileHref(externalTarget)}${hash}`
+        : options.rewriteExternalServerImports
+          ? runtimeServerImportTarget(specifier)
+          : specifier,
+      external: true,
+    };
+  }
+
+  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;
+
+/** @internal Test-only. Returns a restore function. */
+export function setEmitCompiledSpecifiersManifest(enabled: boolean) {
+  const previous = emitCompiledSpecifiersManifest;
+  emitCompiledSpecifiersManifest = enabled;
+  return () => {
+    emitCompiledSpecifiersManifest = previous;
+  };
+}
+
+/** Sidecar suffix for a compiled artifact's recorded specifiers. */
+export const compiledSpecifiersManifestSuffix = '.pnext-specifiers.json';
+
+const compiledScriptFilePattern = /\.(?:m?js|cjs|jsx|tsx?)$/;
+
+async function writeCompiledFile(file: string, contents: string) {
+  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));
+}
+
+function devModulePath(config: ResolvedConfig, file: string, options: DevModuleOptions) {
+  return devModulePathFor(config, file, devModuleProfile(options));
+}
+
+async function writeDevModule(
+  config: ResolvedConfig,
+  file: string,
+  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;
+
+  // 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;
+
+  const existing = moduleBuilds.get(outFile);
+  if (existing) return existing;
+
+  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));
+      }
+      return result;
+    })
+    .catch(error => {
+      moduleBuilds.delete(outFile);
+      throw error;
+    })
+    .finally(() => {
+      moduleBuilds.delete(outFile);
+    });
+  moduleBuilds.set(outFile, next);
+  return next;
+}
+
+async function writeDevModuleUncached(
+  config: ResolvedConfig,
+  file: string,
+  visited: Set<string>,
+  options: DevModuleOptions,
+  outFile: string,
+) {
+  await mkdir(path.dirname(outFile), { recursive: true });
+  if (isCssFile(file)) {
+    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();
+    if (clientActions) {
+      await clientActions.ensureArmed();
+      if (clientActions.isClientActionModule(file)) {
+        await writeCompiledFile(outFile, await clientActions.stubSource(file));
+        return outFile;
+      }
+    }
+  }
+
+  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 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;
+  // 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));
+  // 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
+  // before the import scans below so the plain (all-exports) target is never
+  // compiled when it's only reached through shakeable dynamic imports.
+  // dynamic(ssr:false) split points: the SSR layer never runs those import()s,
+  // so their subtrees (and the vendor demand they fan out) compile on browser
+  // demand instead of on the cold critical path.
+  const deferredDynamic =
+    effectiveOptions.profile === 'client' && devDynamicSplitEnabled()
+      ? deferredDynamicTargetFiles(transformedSource, config, file)
+      : undefined;
+  const shakenSource = await applyDynamicImportTreeShaking(
+    transformedSource,
+    config,
+    file,
+    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>() };
+  // 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.
+  const compiled = buildDevModuleSource(
+    shakenSource,
+    config,
+    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);
+  await Promise.all([
+    assetContext,
+    ...localImportTargets(shakenSource, config, file, effectiveOptions.aliases)
+      // Relative and absolute imports always name first-party source next to its importer (compat's
+      // own out-of-workspace runtime files import each other this way), so compile it regardless of
+      // workspaceRoot. A bare specifier that happens to resolve locally only compiles when it is
+      // inside the workspace; outside that it is meant to stay an untouched external package.
+      .filter(
+        ({ target, isLocalSource }) =>
+          (isLocalSource || isInside(config.workspaceRoot, target)) &&
+          !clientReferences.files.has(path.resolve(target)) &&
+          !deferredDynamic?.has(path.resolve(target)),
+      )
+      .map(({ target }) => writeDevModule(config, target, visited, effectiveOptions)),
+  ]);
+
+  await writeCompiledFile(outFile, await compiled);
+  return outFile;
+}
+
+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).
+// Only local workspace modules are shaken; 'use client' targets keep their
+// client-reference stubbing path. Returns the source unchanged when nothing
+// qualifies.
+async function applyDynamicImportTreeShaking(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  visited: Set<string>,
+  options: DevModuleOptions,
+  deferredDynamic?: Set<string>,
+): Promise<string> {
+  if (!nextCompatEnabled(config)) return source;
+  const candidates = findShakeableDynamicImports(source);
+  if (candidates.length === 0) return source;
+
+  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;
+    // 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;
+    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;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`;
+  }
+  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);
+}
+
+async function shakenModulePath(
+  config: ResolvedConfig,
+  targetFile: string,
+  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}`;
+}
+
+// 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[] = [];
+  if (named.length > 0) {
+    lines.push(`export { ${named.join(', ')} } from ${JSON.stringify(shakeEntrySpecifier)};`);
+  }
+  if (names.includes('default')) {
+    lines.push(`export { default } from ${JSON.stringify(shakeEntrySpecifier)};`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+async function writeShakenDynamicModule(
+  config: ResolvedConfig,
+  targetFile: string,
+  usedExports: string[],
+  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 key = `shake\0${outFile}`;
+  const existing = moduleBuilds.get(key);
+  if (existing) return existing;
+
+  const next = writeShakenDynamicModuleUncached(config, targetFile, usedExports, visited, options, outFile)
+    .catch(error => {
+      moduleBuilds.delete(key);
+      throw error;
+    })
+    .finally(() => {
+      moduleBuilds.delete(key);
+    });
+  moduleBuilds.set(key, next);
+  return next;
+}
+
+async function writeShakenDynamicModuleUncached(
+  config: ResolvedConfig,
+  targetFile: string,
+  usedExports: string[],
+  visited: Set<string>,
+  options: DevModuleOptions,
+  outFile: string,
+): Promise<string> {
+  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))
+      .map(({ target }) => writeDevModule(config, target, visited, options)),
+  );
+  const externalBundles = await externalBundleSpecifiers(targetSource, config, targetFile, options);
+  const result = await withBuildSlot(() =>
+    build({
+      stdin: {
+        contents: shakenEntrySource(usedExports),
+        loader: 'js',
+        resolveDir: path.dirname(targetFile),
+        sourcefile: `${targetFile}.pnext-shake`,
+      },
+      bundle: true,
+      write: false,
+      format: 'esm',
+      platform: 'neutral',
+      target: 'es2022',
+      jsx: 'automatic',
+      jsxImportSource: 'preact',
+      packages: 'external',
+      logLevel: 'silent',
+      ...serverDefineOptions(),
+      plugins: [
+        shakeEntryPlugin(targetFile, targetSource),
+        serverAssetPlugin(config),
+        ...getBundlerExtensions().serverEsbuildPlugins(config),
+        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;
+}
+
+// Resolve the facade's re-export entry to the target's already-transformed
+// source, loaded inline (non-external) so esbuild bundles and tree-shakes it.
+function shakeEntryPlugin(targetFile: string, targetSource: string): Plugin {
+  return {
+    name: 'pnext-shake-entry',
+    setup(build) {
+      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';
+}
+
+function clientLayerOptions(
+  config: ResolvedConfig,
+  conditionTarget: ServerBundleTarget = 'client',
+): DevModuleOptions {
+  return {
+    aliases: clientSsrAliases(config),
+    profile: 'client',
+    conditionTarget,
+    externalLoadTarget: 'client-ssr',
+    stubClientImports: false,
+    rewriteExternalServerImports: false,
+    bundleExternalPackages: reactCompatEnabled(config),
+  };
+}
+
+/**
+ * The SSR condition target for a `use client` module. App-router client components keep the
+ * browser-flavored `client` conditions. Pages-router PAGE sources instead SSR with Next's pages
+ * server-bundle conditions - `node` (or `edge-light`/`browser` under an edge runtime), never
+ * `react-server` - so packages with per-condition `exports` resolve like Next.
+ */
+/**
+ * SERVER-layer condition target for a pages-router source file. A pages page is not part of the RSC
+ * layer - Next compiles it under `node`/`edge-light` conditions WITHOUT `react-server` - but its
+ * callers only know the route's generic server target, so the demotion happens here. Without it a
+ * dual-published dependency is vendored from its `react-server` entry, which may export no `default`
+ * and 500 on every render of the page.
+ */
+function pagesLayerConditionTarget(
+  config: ResolvedConfig,
+  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;
+}
+
+function clientLayerConditionTarget(
+  config: ResolvedConfig,
+  file: string,
+  incoming: ServerBundleTarget,
+): ServerBundleTarget {
+  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;
+  // 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/');
+    } catch {
+      return false;
+    }
+  }
+  return isInside(path.join(config.root, 'pages'), file);
+}
+
+async function buildDevModuleSource(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  clientReferenceSpecifiers: Map<string, string>,
+  options: DevModuleOptions,
+) {
+  const externalBundles = await externalBundleSpecifiers(source, config, file, options);
+  const transformed = await transformDevModuleSource(
+    source,
+    config,
+    file,
+    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);
+  return options.profile === 'client' && isCommonJsModuleSource(source, file)
+    ? unwrapCommonJsDefaultExport(compiled)
+    : compiled;
+}
+
+/**
+ * The batched-pipeline fast path: oxc-transform plus our own specifier rewriting, for the great
+ * majority of server modules that are plain ESM. Returns undefined when this module needs esbuild's
+ * bundler - either its source has an esbuild-only shape, or one of its specifiers only resolves by
+ * inlining something (asset loader rules, `#subpath` facades, require-aliases).
+ */
+async function transformDevModuleSource(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  clientReferenceSpecifiers: Map<string, string>,
+  externalBundles: Map<string, string>,
+  options: DevModuleOptions,
+): Promise<string | undefined> {
+  // 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;
+
+  const { code } = transformed;
+  const edits: { start: number; end: number; value: string }[] = [];
+  for (const found of outputSpecifiers(code)) {
+    const target = await devModuleSpecifierTarget(
+      found.value,
+      found.kind,
+      config,
+      file,
+      clientReferenceSpecifiers,
+      externalBundles,
+      options,
+    );
+    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);
+}
+
+/**
+ * One specifier's rewrite target, or undefined when only the bundler can serve
+ * it. Assets take the same stub content the bundler inlines, written out as a
+ * real module instead.
+ */
+async function devModuleSpecifierTarget(
+  specifier: string,
+  kind: SpecifierKind,
+  config: ResolvedConfig,
+  file: string,
+  clientReferenceSpecifiers: Map<string, string>,
+  externalBundles: Map<string, string>,
+  options: DevModuleOptions,
+): Promise<string | undefined> {
+  // 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));
+    // 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)));
+    }
+  }
+  const resolved = await resolveDevModuleSpecifier(
+    specifier,
+    config,
+    file,
+    clientReferenceSpecifiers,
+    externalBundles,
+    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;
+}
+
+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 next = (async () => {
+    const contents =
+      getCssExtensions().loadCssModuleForClient(resolved) ??
+      (isCssFile(base)
+        ? ''
+        : isStaticImageFile(base)
+          ? await staticImageModuleSource(config, resolved)
+          : '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;
+}
+
+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);
+  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(
+  config: ResolvedConfig,
+  file: string,
+  clientReferenceSpecifiers: Map<string, string>,
+  externalBundles: Map<string, string>,
+  options: DevModuleOptions,
+): Plugin {
+  return {
+    name: 'pnext-dev-module-resolve',
+    setup(build) {
+      registerExternalLoadHandlers(build, config, options, externalLoadNamespaces.module);
+      build.onResolve({ filter: /.*/ }, args =>
+        resolveDevModuleSpecifier(
+          args.path,
+          config,
+          file,
+          clientReferenceSpecifiers,
+          externalBundles,
+          options,
+          args.kind,
+          args.importer,
+        ),
+      );
+    },
+  };
+}
+
+function serverClientReferencePlugin(config: ResolvedConfig, options: DevModuleOptions): Plugin {
+  return {
+    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;
+        return {
+          contents: clientReferenceModuleSource(
+            args.path,
+            await clientReferenceExportNames(config, args.path),
+          ),
+          loader: 'js',
+          resolveDir: path.dirname(args.path),
+        };
+      });
+    },
+  };
+}
+
+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);
+        // 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 };
+      });
+      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);
+        return {
+          contents: cssModule ?? (isCssFile(args.path)
+            ? ''
+            : isStaticImageFile(args.path)
+              ? await staticImageModuleSource(config, args.path)
+              : 'export default "";'),
+          loader: 'js',
+        };
+      });
+    },
+  };
+}
+
+async function resolveDevModuleSpecifier(
+  specifier: string,
+  config: ResolvedConfig,
+  file: string,
+  clientReferenceSpecifiers: Map<string, string>,
+  externalBundles: Map<string, string>,
+  options: DevModuleOptions,
+  kind: string,
+  importer: string,
+): Promise<OnResolveResult> {
+  // An already-resolved `file://` href is a compiled module on disk; pass it straight through as
+  // external instead of re-resolving it. But a file:// href naming a RAW 'use client' source
+  // (rewriteStaticCompatImports resolves compat aliases textually) still needs the same
+  // 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);
+    if (
+      options.stubClientImports &&
+      !isCssFile(target) &&
+      !isInside(config.outPath, target) &&
+      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 };
+    }
+    return { path: specifier, external: true };
+  }
+
+  // A `turbopack.rules` loader chain owns this specifier (`?query` and all):
+  // import the module its output was materialized to. The seam answers a bare
+  // `undefined` when nothing is configured, so the common path stays sync.
+  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 { sourcePath, hash } = splitHash(specifier);
+
+  const compatAlias =
+    pagesCompatSourceAlias(config, specifier, importer, options) ?? options.aliases[specifier];
+  if (compatAlias) {
+    if (kind === 'require-call' && path.isAbsolute(compatAlias)) {
+      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
+    // `[clientReferenceSymbol]` tag on the component object it actually rendered, matched by id
+    // against `markClientReferences`' own load of the file. Returning the raw file directly imports a
+    // THIRD, untagged instance, so the component never gets its hydration island.
+    if (
+      path.isAbsolute(compatAlias) &&
+      options.stubClientImports &&
+      !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 };
+    }
+    return {
+      path: path.isAbsolute(compatAlias) ? pathToFileHref(compatAlias) : compatAlias,
+      external: true,
+    };
+  }
+
+  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 (externalBundle) return { path: `${externalBundle}${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 };
+  }
+
+  if (
+    sourcePath === '../client/errors/primitive-throw' &&
+    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),
+      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);
+  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)) {
+      return {
+        path: resolvedExternalLoad,
+        namespace: externalLoadNamespaces.module,
+      };
+    }
+    const externalTarget =
+      resolvedExternalLoad ?? externalPackageImportTarget(config.root, file, sourcePath);
+    return {
+      path: externalTarget
+        ? `${pathToFileHref(externalTarget)}${hash}`
+        : options.rewriteExternalServerImports
+          ? 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
+  // claims above (and serverAssetPlugin's) key on the SPECIFIER, so they miss
+  // those; re-check the resolved path or the compile pass hands a .png to
+  // esbuild. A loader rule for the extension still wins, as everywhere else.
+  if (
+    isServerIgnoredAssetSpecifier(resolved) &&
+    !isServerIgnoredAssetSpecifier(sourcePath) &&
+    // Css keeps its copy-through compile, exactly as the specifier-keyed path does.
+    !isCssFile(resolved) &&
+    !getAssetExtensions().hasLoaderRuleFor(resolved)
+  ) {
+    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 };
+  }
+  // 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
+  // first-party compat runtime file pulled in by an alias that esbuild BUNDLES contributes its own
+  // 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 bundledCompatImporter =
+    isLocalSourceSpecifier &&
+    importerFile !== '' &&
+    importerFile !== path.resolve(file) &&
+    !isInside(config.workspaceRoot, importerFile) &&
+    !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
+  // the entry is a workspace module or a node_modules-nested 'use client' component. Gating on an
+  // in-workspace entry left those nested client references importing a file that was never written.
+  // Recompiling is not a risk: writeDevModule returns an already-written output as-is, so island
+  // identity across a soft navigation is preserved.
+  if (bundledCompatImporter) {
+    // Compile it here, keeping the same compiled-path rewrite so the module stays a single instance -
+    // 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);
+  }
+  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 (specifier === 'next/navigation' && alias.endsWith(`${path.sep}navigation.ts`)) {
+    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 alias;
+}
+
+function registerExternalLoadHandlers(
+  build: import('esbuild').PluginBuild,
+  config: ResolvedConfig,
+  options: DevModuleOptions,
+  namespace: string,
+) {
+  build.onResolve({ filter: /.*/, namespace }, args => {
+    const { sourcePath } = splitHash(args.path);
+    const importer = args.importer.startsWith(`${namespace}:`)
+      ? args.importer.slice(namespace.length + 1)
+      : 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 (sourcePath.startsWith('.') || path.isAbsolute(sourcePath)) {
+      return { path: path.resolve(path.dirname(importer), sourcePath), namespace };
+    }
+    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(
+  source: string,
+  file: string,
+  config: ResolvedConfig,
+  options: DevModuleOptions,
+) {
+  // 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;
+    const target = resolveExternalLoadTarget({
+      root: config.root,
+      fromFile: file,
+      specifier,
+      target: options.externalLoadTarget,
+    });
+    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);
+}
+
+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>();
+
+  for (const line of lines) {
+    if (line.includes('__glob({')) {
+      inGlob = true;
+      keys.clear();
+    }
+    if (inGlob) {
+      const key = globKey(line);
+      if (key) keys.add(key);
+    }
+    next.push(line);
+    if (inGlob) {
+      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;
+        for (const alias of aliases) {
+          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;
+    }
+  }
+
+  return next.join('\n');
+}
+
+function globKey(line: string) {
+  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));
+}
+
+async function externalBundleSpecifiers(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  options: DevModuleOptions,
+) {
+  const bundles = new Map<string, string>();
+  if (!options.bundleExternalPackages) return bundles;
+
+  const candidates = [...new Set(importSpecifiers(source, file).map(specifier => splitHash(specifier).sourcePath))]
+    .filter(specifier => !isServerIgnoredAssetSpecifier(specifier))
+    .filter(specifier => shouldBundleExternalPackage(specifier, config, file, options));
+  await Promise.all(
+    candidates.map(async specifier => {
+      bundles.set(
+        specifier,
+        await externalServerPackageHref(
+          config,
+          specifier,
+          options.profile === 'client' ? 'client' : 'server',
+          path.dirname(file),
+          options.conditionTarget,
+        ),
+      );
+    }),
+  );
+  return bundles;
+}
+
+function shouldBundleExternalPackage(
+  specifier: string,
+  config: ResolvedConfig,
+  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);
+  // 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);
+  if (packageName) {
+    const policy = getExternalPackagePolicy();
+    if (policy.transpile(packageName)) return !inWorkspace;
+    if (policy.external(packageName)) return false;
+  }
+  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>();
+  for (const specifier of specifiers) {
+    const resolved = resolveLocalImport(config, file, specifier);
+    if (resolved) files.add(path.resolve(resolved));
+  }
+  return files.size > 0 ? files : undefined;
+}
+
+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;
+    // 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);
+    // `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;
+    // 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;
+    // 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) });
+    }
+  }
+
+  return targets;
+}
+
+async function writeClientReferenceModules(
+  source: string,
+  config: ResolvedConfig,
+  file: string,
+  aliases: AliasMap,
+) {
+  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 entry = references.get(sourcePath) ?? { file: resolved, exports: new Set<string>() };
+    for (const exportName of await clientReferenceExportNames(config, resolved)) {
+      entry.exports.add(exportName);
+    }
+    references.set(sourcePath, entry);
+  }
+
+  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));
+    }),
+  );
+
+  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));
+}
+
+async function fileHasUseClientDirective(file: string) {
+  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('#');
+  return index === -1
+    ? { sourcePath: specifier, hash: '' }
+    : { 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));
+}
+
+function devModuleProfile(options: DevModuleOptions) {
+  if (options.profile === 'client') {
+    // Pages-router SSR layers ('pages'/'pages-edge') resolve package exports
+    // with different conditions than the app client layer — keep their
+    // compiled modules (and baked-in vendor hrefs) in separate cache dirs.
+    return options.conditionTarget === 'client'
+      ? options.profile
+      : `client-${options.conditionTarget}`;
+  }
+  const externalTarget =
+    options.externalLoadTarget === externalLoadTargetForConditionTarget(options.conditionTarget)
+      ? ''
+      : `-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';
+  // 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;
+  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'));
+}
+
+// A module compiled standalone (not merely as a transitive import of an
+// in-workspace file) can live OUTSIDE config.workspaceRoot: a compat runtime
+// file (e.g. `next/form` -> src/compat/next/form.tsx, shipped inside pnext's
+// own package) reached directly as a route's client-reference entry, not
+// through any in-workspace importer. `path.relative(workspaceRoot, file)` for
+// such a file is riddled with `..` segments walking up past unrelated
+// ancestors; joining that under outPath silently produces a bogus path (and
+// the file's own untouched relative imports then resolve from the wrong
+// 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);
+  // 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'}`);
+}
+
+// The route bundle inlines the route file and its layouts, so its name carries
+// every source graph it bundles.
+async function devRouteBundlePath(
+  config: ResolvedConfig,
+  route: RouteManifestEntry,
+  layoutFiles: string[],
+) {
+  const graph = devModuleGraph(config);
+  const entries = uniqueFiles([route.file, ...layoutFiles]);
+  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,
+    graph.graphKey,
+    entries,
+    bundle,
+    await graph.graphSources(entries),
+  );
+  return bundle;
+}
+
+async function clientReferencePath(config: ResolvedConfig, file: string) {
+  return `${await devModulePathFor(config, file, 'compat')}.client-reference.ts`;
+}
+
+function isCssFile(file: string) {
+  return file.endsWith('.css');
+}
+
+function isStaticImageFile(file: string) {
+  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)(?:$|[?#])/;
+
+function isServerIgnoredAssetSpecifier(specifier: string) {
+  return serverIgnoredAssetFilter.test(specifier);
+}
+
+function esbuildLoader(file: string) {
+  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';
+  // 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';
+}
+
+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));
+}
+
+function isBuiltinSpecifier(specifier: string) {
+  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];
+}
+
+function resolveLocalImport(config: ResolvedConfig, fromFile: string, specifier: string) {
+  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)));
+}
+
+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;
+  for (const segment of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    dirs.push(current);
+  }
+  return dirs;
+}
+
+async function linkDirectoryAssetContext(
+  config: ResolvedConfig,
+  sourceDir: string,
+  profile: string,
+) {
+  let entries: Dirent<string>[];
+  try {
+    entries = await readdir(sourceDir, { withFileTypes: true, encoding: 'utf8' });
+  } catch {
+    return;
+  }
+  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);
+      // 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;
+      }
+      if (existsSync(target)) return;
+      await mkdir(path.dirname(target), { recursive: true });
+      try {
+        await symlink(source, target, 'file');
+      } catch {
+        if (!existsSync(target)) await copyFile(source, target);
+      }
+    }),
+  );
+}
+
+// Recursively stage an asset directory: link non-code leaf files and recurse
+// into subdirectories, but never link code files — those compile through the
+// 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>[];
+  try {
+    entries = await readdir(sourceDir, { withFileTypes: true, encoding: 'utf8' });
+  } catch {
+    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.isDirectory()) {
+        await mirrorAssetDirectory(source, target);
+        return;
+      }
+      if (isCodeFile(entry.name)) return;
+      if (existsSync(target)) return;
+      await mkdir(path.dirname(target), { recursive: true });
+      try {
+        await symlink(source, target, 'file');
+      } catch {
+        if (!existsSync(target)) await copyFile(source, target);
+      }
+    }),
+  );
+}
+
+function assetContextEntry(
+  config: ResolvedConfig,
+  sourceDir: string,
+  name: string,
+  directory: boolean,
+) {
+  if (name.startsWith('.')) return false;
+  if (!directory) return !isCodeFile(name);
+  if (sourceDir !== config.root) return false;
+  return !new Set([
+    'app',
+    'src',
+    'pages',
+    'public',
+    'node_modules',
+    path.basename(config.outPath),
+  ]).has(name);
+}
+
+function isCodeFile(file: string) {
+  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));
+}
+
+function resolveAssetPath(specifier: string, resolveDir: string) {
+  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 emit = (relative: string) => {
+    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);
+  }
+  return source;
+}
+
+// Core's generic static-asset module (no compat override): emit under a hashed
+// media URL and export the URL string as default.
+function coreStaticAssetModule(
+  sourcePath: string,
+  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`;
+}
+
+function uniqueFiles(files: string[]) {
+  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();
+  try {
+    return await task();
+  } finally {
+    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`;
+}