@wular/pnext 0.1.7 → 0.1.8

package/dist/server/_chunks/{build-t9h0hec3.js → build-kh5e3x48.js}

@@ -10,10 +10,10 @@ import {
   buildClientEntries,
   emitStaticClientChunks,
   startClientSources
-} from "./index-nyrba2kr.js";
+} from "./index-1pzm1hdy.js";
 import {
   writeTypegen
-} from "./index-wpfhfbs4.js";
+} from "./index-38xpdxwd.js";
 import {
   handleRouteModule,
   staticRouteParams
@@ -23,23 +23,23 @@ import {
   assertNoServerActionsWithoutCompat,
   materializeRouteFacts,
   scanRoutes
-} from "./index-8k7pfejn.js";
+} from "./index-jn9rbhrx.js";
 import {
-  compiledSpecifiersManifestSuffix,
   devServerModuleHref,
   resetModuleGraphFailure,
   setEmitCompiledSpecifiersManifest,
   setReleaseCompile
-} from "./index-1011cscr.js";
+} from "./index-fjv96re1.js";
 import"./index-n4hxpng2.js";
 import"./index-x3yn4ywm.js";
 import {
+  cacheRoot as cacheRoot2,
   compiledSourceGraph,
   flushDevModuleCaches,
   registerServerRuntime
-} from "./index-vvmmknm1.js";
-import"./index-91x12ykq.js";
-import"./index-tvqkq6e6.js";
+} from "./index-rjegyfx4.js";
+import"./index-0r5eqfc7.js";
+import"./index-3e075kny.js";
 import {
   clientEntryName,
   defaultNotFoundDocument,
@@ -61,21 +61,22 @@ import {
   staticParamsFor,
   staticRouteMetadataKey,
   withDynamicMetadataRoutes
-} from "./index-3tf1xjsp.js";
+} from "./index-x2m17v9c.js";
 import {
   findLayouts
-} from "./index-jepjvcrf.js";
+} from "./index-8ct7rqy3.js";
 import {
   findProxyFile,
   proxyExternalLoadTarget,
   proxyRoutePatterns,
   validateProxyFiles
-} from "./index-kq8kpzye.js";
+} from "./index-3ycf5ckv.js";
 import {
   serverBundleTargetForRuntime,
   throwIfModuleGraphFailed
-} from "./index-3xbr4eyv.js";
-import"./index-rn8dyr1f.js";
+} from "./index-0yjv5v47.js";
+import"./index-yrjkqtfj.js";
+import"./index-jbj7ehef.js";
 import {
   buildGlobalCss,
   buildNotFoundCss,
@@ -83,21 +84,21 @@ import {
   globalCssSources,
   prepareRouteCssChunks,
   warmCssPipeline
-} from "./index-2dv4y4wd.js";
+} from "./index-n629dy38.js";
 import {
   createVerboseLogger
 } from "./index-73z4esab.js";
 import {
   emittedAssetNames,
   registerCssRuntime
-} from "./index-y2jr2n72.js";
+} from "./index-d158y67j.js";
 import {
   nextCompatEnabled
 } from "./index-web361b8.js";
 import"./index-knp0s912.js";
 import {
   frameworkFingerprint
-} from "./index-c0g2wf3z.js";
+} from "./index-gcmj16xy.js";
 import"./index-ye9hmsvf.js";
 import {
   setRequestRuntime
@@ -109,10 +110,10 @@ import {
 } from "./index-fp8r0sqs.js";
 import"./index-cjgqs13g.js";
 import"./index-yhxkxghe.js";
-import"./index-fkp000p1.js";
+import"./index-29pq0kax.js";
 import {
   interceptionMarkerLevels
-} from "./index-p77b4kcx.js";
+} from "./index-cn86z041.js";
 import {
   ensureEmptyDir,
   listFiles,
@@ -122,7 +123,7 @@ import {
   toPosixPath,
   writeFileAtomic,
   writeText
-} from "./index-20ppawv7.js";
+} from "./index-4da76t62.js";
 import {
   cacheRoot,
   namedBunBinary
@@ -130,24 +131,27 @@ import {
 import"./index-vz0km5qk.js";
 import {
   bootstrapCompat
-} from "./index-5gyr4emz.js";
+} from "./index-tq3b39a5.js";
 import {
-  readPrebundleStamp,
-  runtimeEntryDirs,
-  runtimeEntryFiles
-} from "./index-y36a0ybw.js";
-import {
-  DEFAULT_OUT_DIR,
   devOutSegment,
+  frameworkRuntimeSpecifiers,
   loadConfig,
   pathToFileHref
-} from "./index-x93hv0sc.js";
+} from "./index-71885zaq.js";
+import {
+  outCachePath
+} from "./index-bzd2ef7t.js";
 import"./index-jcsjq3d1.js";
 import {
+  PREBUNDLE_STAMP,
   buildIndexFile,
+  buildManifestFile,
+  prebundledFile,
   readBuildIndex,
-  releaseSourceFile
-} from "./index-tqn2qnnn.js";
+  readPrebundleStamp,
+  releaseSourceFile,
+  standaloneOriginsFile
+} from "./index-hdbwtdv2.js";
 import {
   bold,
   cyan,
@@ -170,21 +174,22 @@ import {
 } from "./index-kresp2n8.js";
 import"./index-e3a6yx84.js";
 import {
-  importSpecifiers,
-  scanFactsStats
-} from "./index-z4z9zv3b.js";
-import {
-  resolveImport,
-  workspacePackageRoots
-} from "./index-yz54pxrh.js";
+  importMetaRefs,
+  moduleSpecifierEdges,
+  scanFactsStats,
+  spliceSource
+} from "./index-x9c55pzy.js";
+import"./index-d1jsmhhk.js";
 import"./index-7wc9n8be.js";
 import"./index-pym1cezq.js";
+import {
+  splitResourceQuery
+} from "./index-jt8e1pje.js";
 import {
   buildParallelPhaseError,
   clearBuildParallelPhases,
   getBuildExtensions,
   getCompatModeExtensions,
-  getImportAliasExtensions,
   getRenderExtensions,
   runInitHooks,
   withRouteRuntime
@@ -193,192 +198,19 @@ import {
   escapeRegex
 } from "./index-qjj6gddn.js";
 import"./index-4399bvd2.js";
-import {
-  __require
-} from "./index-rt9qq1va.js";
+import"./index-rt9qq1va.js";
 
 // src/cli/build.ts
-import { copyFile as copyFile2, mkdir as mkdir4, rename as rename2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
+import { copyFile as copyFile3, mkdir as mkdir4, rename as rename3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync3, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
 import { createRequire } from "module";
 import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/adapters/vercel.ts
-import { copyFile, link, mkdir, readFile, rename, rm, symlink, writeFile } from "fs/promises";
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, realpathSync as realpathSync2, rmSync, statSync } from "fs";
-import { builtinModules } from "module";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/cli/adapters/vercel-warm.ts
-import { fileURLToPath } from "url";
-
-// src/runtime/release-graph.ts
-import { existsSync, readFileSync, realpathSync } from "fs";
+import { copyFile, cp, mkdir, readFile, readdir, rename, rm } from "fs/promises";
+import { constants, existsSync, readdirSync } from "fs";
 import path from "path";
-var layerDirs = {
-  "server:server": "rsc",
-  "client:client": "ssr"
-};
-var layers = Object.keys(layerDirs);
-var frameworkRoot = realpathSync(path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", ".."));
-
-// src/cli/adapters/vercel-warm.ts
-var DONE_MARKER = "pnext-warm-done:";
-var COMPILED_MARKER = "pnext-warm-compiled";
-var ATTEMPT_TIMEOUT_MS = 10 * 60000;
-var MAX_ATTEMPTS = 3;
-var FULL_MODE_FLAG = "--full";
-function startWarmChild(config, mode = "full") {
-  const children = new Set;
-  let disposed = false;
-  const spawn = () => {
-    if (disposed)
-      return;
-    const child = spawnWarmProcess(config, mode);
-    if (!child)
-      return;
-    children.add(child);
-    child.exited.finally(() => children.delete(child));
-    forwardWarmStderr(child);
-    return child;
-  };
-  const killOnExit = () => kill();
-  const kill = () => {
-    if (disposed)
-      return;
-    disposed = true;
-    process.off("exit", killOnExit);
-    for (const child of children)
-      child.kill();
-    children.clear();
-  };
-  process.once("exit", killOnExit);
-  const first = spawn();
-  return {
-    prewarm(files) {
-      if (!first || files.length === 0)
-        return;
-      try {
-        first.stdin.write(`${JSON.stringify({ prewarm: files })}
-`);
-        first.stdin.flush();
-      } catch {}
-    },
-    finish: (log, onCompiled, facts = { clientReferences: [] }) => warmWithRestarts(first, spawn, mode, log, facts, onCompiled).finally(kill),
-    kill
-  };
-}
-async function forwardWarmStderr(child) {
-  try {
-    const reader = child.stderr.getReader();
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        return;
-      process.stderr.write(value);
-    }
-  } catch {}
-}
-function spawnWarmProcess(config, mode) {
-  const entry = fileURLToPath(new URL(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/adapters/vercel-warm.ts").href));
-  const argv = mode === "full" ? [config.root, FULL_MODE_FLAG] : [config.root];
-  try {
-    return Bun.spawn([namedBunBinary("pnext-warm"), "--conditions=react-server", entry, ...argv], {
-      cwd: config.root,
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-      env: process.env
-    });
-  } catch {
-    return;
-  }
-}
-async function warmWithRestarts(first, spawn, mode, log, facts, onCompiled) {
-  const finished = new Map;
-  const compiled = () => [...finished.values()].filter((file) => Boolean(file));
-  let fired = false;
-  const fireOnCompiled = onCompiled ? () => {
-    if (fired)
-      return;
-    fired = true;
-    onCompiled(compiled());
-  } : undefined;
-  let child = first;
-  for (let attempt = 1;attempt <= MAX_ATTEMPTS && child; attempt++) {
-    const before = finished.size;
-    const failure = await runAttempt(child, {
-      skip: [...finished.keys()],
-      compiled: Object.fromEntries([...finished].filter((entry) => Boolean(entry[1]))),
-      ...facts
-    }, finished, fireOnCompiled);
-    if (!failure) {
-      log.log(`warmed ${compiled().length} modules`);
-      return compiled();
-    }
-    child = finished.size > before && attempt < MAX_ATTEMPTS ? spawn() : undefined;
-    if (child)
-      log.log(`warm-up ${failure} after ${finished.size} files; restarting past them`);
-    else
-      warmIncomplete(failure, finished.size, mode);
-  }
-  fireOnCompiled?.();
-  return compiled();
-}
-async function runAttempt(child, request, finished, onCompiled) {
-  try {
-    child.stdin.write(`${JSON.stringify(request)}
-`);
-    child.stdin.end();
-  } catch {}
-  const timeout = setTimeout(() => child.kill("SIGKILL"), ATTEMPT_TIMEOUT_MS);
-  timeout.unref?.();
-  const processLine = (line) => {
-    if (!line)
-      return;
-    if (line === COMPILED_MARKER) {
-      onCompiled?.();
-      return;
-    }
-    if (!line.startsWith(DONE_MARKER)) {
-      console.log(line);
-      return;
-    }
-    const [source, artifact] = line.slice(DONE_MARKER.length).split("\t");
-    if (source)
-      finished.set(source, artifact || undefined);
-  };
-  const reader = child.stdout.getReader();
-  const decoder = new TextDecoder;
-  let buffer = "";
-  for (;; ) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    buffer += decoder.decode(value, { stream: true });
-    let newline;
-    while ((newline = buffer.indexOf(`
-`)) >= 0) {
-      processLine(buffer.slice(0, newline));
-      buffer = buffer.slice(newline + 1);
-    }
-  }
-  if (buffer)
-    processLine(buffer);
-  const code = await child.exited.finally(() => clearTimeout(timeout));
-  if (code === 0)
-    return;
-  return child.signalCode ? `was killed by ${child.signalCode}` : `exited with code ${code}`;
-}
-function warmIncomplete(failure, done, mode) {
-  console.warn(`pnext build: module warm-up ${failure} after warming ${done} file(s). ` + (mode === "full" ? "The function ships without the rest of its module cache and may fail to render those " + "routes at request time, where Vercel's filesystem is read-only." : "The production server compiles the rest on the first request that needs them."));
-}
-if (false) {}
-
-// src/cli/adapters/vercel.ts
-var RUNTIME_ROOT = "/var/task";
 var SERVER_FUNCTION = "_pnext";
 var FUNCTION_PLATFORM = {
   architecture: "x86_64",
@@ -386,127 +218,20 @@ var FUNCTION_PLATFORM = {
   cpu: "x64",
   libc: "glibc"
 };
-var prunedDirNames = [
-  "node_modules",
-  ".git",
-  ".next",
-  ".pnext",
-  ".turbo",
-  ".cache",
-  ".vercel",
-  ".tmp"
-];
-var droppedFileSuffixes = [
-  ".map",
-  ".d.ts",
-  ".d.mts",
-  ".d.cts",
-  ".DS_Store",
-  compiledSpecifiersManifestSuffix
-];
-var packPruningEnabled = true;
-function packRules(config) {
-  const devPaths = new Set([config.outRootPath, path2.resolve(config.root, DEFAULT_OUT_DIR)].map((root) => path2.resolve(root, devOutSegment)).filter((dev) => !isInsideDir(dev, config.outPath)));
-  devPaths.add(path2.join(config.outRootPath, "pnext-pages-compat"));
-  if (!packPruningEnabled) {
-    return {
-      prunedDirs: new Set(["node_modules", ".git"]),
-      droppedSuffixes: [],
-      compiled: new Set,
-      keep: new Set,
-      keepPaths: new Set([path2.resolve(config.outPath)]),
-      devPaths
-    };
-  }
-  const keep = new Set(config.adapter?.keep ?? []);
-  const extra = config.adapter?.exclude ?? [];
-  const isSuffix = (entry) => entry.startsWith(".") && !prunedDirNames.includes(entry);
-  return {
-    prunedDirs: new Set([...prunedDirNames, ...extra.filter((entry) => !isSuffix(entry))].filter((name) => !keep.has(name))),
-    droppedSuffixes: [...droppedFileSuffixes, ...extra.filter(isSuffix)].filter((suffix) => !keep.has(suffix)),
-    compiled: new Set,
-    keep,
-    keepPaths: new Set([path2.resolve(config.outPath), path2.resolve(config.root, DEFAULT_OUT_DIR)]),
-    devPaths
-  };
-}
-function withinKeepPath(pack, source) {
-  const resolved = path2.resolve(source);
-  for (const keep of pack.keepPaths) {
-    if (resolved === keep || resolved.startsWith(`${keep}${path2.sep}`))
-      return true;
-  }
-  return false;
-}
-function shipsDir(pack, name, source, isLink = false) {
-  if (pack.devPaths.has(path2.resolve(source)))
-    return false;
-  if (!pack.prunedDirs.has(name))
-    return true;
-  return !isLink && withinKeepPath(pack, source);
-}
-function shipsFile(pack, name, source) {
-  if (pack.droppedSuffixes.some((suffix) => name.endsWith(suffix)))
-    return false;
-  if (!pack.compiled.has(path2.resolve(source)) || withinKeepPath(pack, source))
-    return true;
-  return [...pack.keep].some((entry) => name === entry || entry.startsWith(".") && name.endsWith(entry));
-}
-function releaseCompiledSources(config) {
-  flushDevModuleCaches();
-  const index = readBuildIndex(config.outPath);
-  const graph = compiledSourceGraph(config.outPath, config.workspaceRoot);
-  const queue = Object.keys(index.modules).map((key) => releaseSourceFile(key.slice(key.indexOf(":", key.indexOf(":") + 1) + 1), config.root, config.workspaceRoot));
-  if (index.proxy)
-    queue.push(path2.resolve(config.root, index.proxy.file));
-  const script = /\.(?:[cm]?[jt]s|[jt]sx)$/;
-  const frozen = (dir, pattern) => (readDirEntries(dir) ?? []).filter((entry) => pattern.test(entry.name) && script.test(entry.name)).forEach((entry) => queue.push(path2.join(dir, entry.name)));
-  frozen(config.root, /^(?:pnext|next)\.config\./);
-  if (index.instrumentation) {
-    for (const dir of [config.root, path2.join(config.root, "src")])
-      frozen(dir, /^instrumentation\./);
-  }
-  const compiled = new Set;
-  for (const file of queue) {
-    if (compiled.has(file))
-      continue;
-    compiled.add(file);
-    let real = file;
-    try {
-      real = realpathSync2(file);
-    } catch {
-      continue;
-    }
-    compiled.add(real);
-    queue.push(...graph.get(file) ?? [], ...graph.get(real) ?? []);
-  }
-  return compiled;
-}
+var functionDroppedPackages = [/^sharp$/, /^@img\/sharp-libvips/];
 async function writeVercelOutput(config, manifest, options = {}) {
   const log = createVerboseLogger(options.verbose ?? false, "vercel");
-  const outputPath = path2.join(config.root, ".vercel", "output");
+  const outputPath = path.join(config.root, ".vercel", "output");
+  const staticPath = path.join(config.outPath, "static");
   const staticFiles = manifest.staticFiles ?? {};
-  const warm = options.warm ?? startWarmChild(config);
   await log.step("prepare output directory", () => emptyDir(outputPath));
-  let resolveWarmedModules;
-  const warmedModulesEarly = new Promise((resolve) => {
-    resolveWarmedModules = resolve;
-  });
-  const warmSettled = warm.finish(log, (modules) => resolveWarmedModules(modules), {
-    globalCss: globalCssSources(config),
-    clientReferences: [...compiledClientReferenceFiles()]
-  });
-  warmSettled.catch(() => {
-    return;
-  });
-  const warmedModules = await log.step("warm module cache (compiled)", () => warmedModulesEarly);
-  const functionPath = path2.join(outputPath, "functions", `${SERVER_FUNCTION}.func`);
-  await writeServerFunction(config, manifest, functionPath, warmedModules, warmSettled, log);
-  await log.step("copy static files", () => copyStaticFiles(path2.join(config.outPath, "public"), path2.join(outputPath, "static"), (relative) => !staticFiles[relative] || canServeStaticOnVercel(staticFiles[relative])));
-  const overrides = await staticOverrides(path2.join(config.outPath, "public"), staticFiles);
+  const functionPath = path.join(outputPath, "functions", `${SERVER_FUNCTION}.func`);
+  await writeServerFunction(config.outPath, manifest, functionPath, log);
+  await log.step("copy static files", () => copyStaticFiles(staticPath, path.join(outputPath, "static"), (relative) => !staticFiles[relative] || canServeStaticOnVercel(staticFiles[relative])));
+  const overrides = await staticOverrides(staticPath, staticFiles);
   const routes = [
     ...compatStaticRewrite(config, outputPath),
-    ...await immutableAssetRoutes(path2.join(config.outPath, "public"), manifest.publicAssets),
+    ...await immutableAssetRoutes(staticPath, manifest.publicAssets),
     ...await proxyRoutes(config),
     ...staticHeaderRoutes(staticFiles),
     { handle: "filesystem" },
@@ -517,17 +242,17 @@ async function writeVercelOutput(config, manifest, options = {}) {
     routes,
     ...Object.keys(overrides).length > 0 ? { overrides } : {}
   };
-  await writeText(path2.join(outputPath, "config.json"), `${JSON.stringify(vercelConfig, null, 2)}
+  await writeText(path.join(outputPath, "config.json"), `${JSON.stringify(vercelConfig, null, 2)}
 `);
 }
 async function emptyDir(dir) {
-  const parent = path2.dirname(dir);
+  const parent = path.dirname(dir);
   await mkdir(parent, { recursive: true });
-  const staleMarker = `${path2.basename(dir)}.stale-`;
-  if (existsSync2(dir)) {
-    await rename(dir, path2.join(parent, `${staleMarker}${process.pid.toString(36)}-${Date.now().toString(36)}`));
+  const staleMarker = `${path.basename(dir)}.stale-`;
+  if (existsSync(dir)) {
+    await rename(dir, path.join(parent, `${staleMarker}${process.pid.toString(36)}-${Date.now().toString(36)}`));
   }
-  const stale = readdirSync(parent).filter((entry) => entry.startsWith(staleMarker)).map((entry) => path2.join(parent, entry));
+  const stale = readdirSync(parent).filter((entry) => entry.startsWith(staleMarker)).map((entry) => path.join(parent, entry));
   await mkdir(dir, { recursive: true });
   if (stale.length > 0) {
     Bun.spawn(["rm", "-rf", ...stale], { stdout: "ignore", stderr: "ignore" });
@@ -536,15 +261,15 @@ async function emptyDir(dir) {
 function compatStaticRewrite(config, outputPath) {
   if (!nextCompatEnabled(config))
     return [];
-  const staticDir = path2.join(outputPath, "static");
-  const names = readdirSyncSafe(path2.join(staticDir, "assets")).filter((name) => !existsSync2(path2.join(staticDir, "_next", "static", name)));
+  const staticDir = path.join(outputPath, "static");
+  const names = readdirSyncSafe(path.join(staticDir, "assets")).filter((name) => !existsSync(path.join(staticDir, "_next", "static", name)));
   if (names.length === 0)
     return [];
   const alternation = names.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
   return [{ src: `^/_next/static/(${alternation})(/.*)?$`, dest: "/assets/$1$2", continue: true }];
 }
 function readdirSyncSafe(dir) {
-  return existsSync2(dir) ? readdirSync(dir) : [];
+  return existsSync(dir) ? readdirSync(dir) : [];
 }
 async function proxyRoutes(config) {
   const proxyFile = findProxyFile(config);
@@ -556,672 +281,120 @@ async function proxyRoutes(config) {
     dest: `/${SERVER_FUNCTION}`
   }));
 }
-async function writeServerFunction(config, manifest, functionPath, warmedModules, warmSettled, log) {
-  const workspaceRoot = config.workspaceRoot;
-  await mkdir(functionPath, { recursive: true });
-  const pack = packRules(config);
-  const framework = await resolveFrameworkPackage(workspaceRoot);
-  const { root: pnextRoot, inWorkspace: pnextInWorkspace, targetRel: pnextTargetRel } = framework;
-  const release = releaseEntries(config, manifest);
-  const prebundle = release ? readPrebundleStamp(pnextRoot, frameworkFingerprint()) : undefined;
-  const closure = await traceNodeModulesClosure(config, manifest, functionPath, framework, [...warmedModules, ...release ?? []], pack, log, Boolean(release));
-  const replicaPathFor = (file) => {
-    if (isInsideDir(pnextRoot, file)) {
-      return path2.join(functionPath, pnextTargetRel, path2.relative(pnextRoot, file));
-    }
-    if (isInsideDir(workspaceRoot, file)) {
-      return path2.join(functionPath, path2.relative(workspaceRoot, file));
-    }
-    return;
-  };
-  const appRel = path2.relative(workspaceRoot, config.root);
-  const packageRoots = workspacePackageRoots(workspaceRoot).map((root) => path2.resolve(root));
-  const neededRoots = new Set;
-  for (const file of closure.tracedFiles) {
-    const root = packageRoots.find((candidate) => isInsideDir(candidate, file));
-    if (root)
-      neededRoots.add(root);
-  }
-  for (const relative of closure.workspacePackages) {
-    neededRoots.add(path2.resolve(workspaceRoot, relative));
-  }
-  if (!release) {
-    for (const file of globalCssSources(config)) {
-      const root = packageRoots.find((candidate) => isInsideDir(candidate, file));
-      if (root)
-        neededRoots.add(root);
-    }
-    addWorkspaceDependencies(neededRoots, packageRoots, [path2.resolve(config.root), ...neededRoots]);
-  }
-  neededRoots.delete(path2.resolve(config.root));
-  neededRoots.delete(pnextRoot);
-  await log.step("await handler warm-up", () => warmSettled);
-  const roots = neededRoots.size + 2;
-  await log.step(`copy function tree (${closure.packageCount} packages, ${roots} roots)`, () => Promise.all([
-    closure.copy(),
-    copyTree(config.root, path2.join(functionPath, appRel), release ? { ...pack, compiled: releaseCompiledSources(config) } : pack, ["public", ".vercel", ".next", ".turbo"]),
-    copyPackageTree(pnextRoot, path2.join(functionPath, pnextTargetRel), pack, prebundle && ["config", "dist", ...prebundle.source]),
-    ...[...neededRoots].map((packageRoot) => copyPackageTree(packageRoot, path2.join(functionPath, path2.relative(workspaceRoot, packageRoot)), pack)),
-    ...["package.json", "tsconfig.json", "bunfig.toml"].map((name) => path2.join(workspaceRoot, name)).filter((file) => existsSync2(file)).map((file) => copyFile(file, path2.join(functionPath, path2.basename(file))))
-  ]));
-  await log.step("rewrite baked paths", () => rewriteBakedPaths(path2.join(functionPath, appRel, path2.relative(config.root, config.outPath)), [
-    ...pnextInWorkspace ? [] : [[pnextRoot, toPosixPath(path2.join(RUNTIME_ROOT, pnextTargetRel))]],
-    [workspaceRoot, RUNTIME_ROOT]
-  ]));
-  await log.step("inject compat tsconfig paths", () => injectCompatPaths(config, functionPath, pnextRoot, replicaPathFor));
-  const startEntry = toPosixPath(path2.join(pnextTargetRel, prebundle ? "dist/server/cli/start.js" : "src/cli/start.ts"));
-  await writeText(path2.join(functionPath, "index.mjs"), `import path from 'node:path';
-import { createRequestHandler } from ${JSON.stringify(`./${startEntry}`)};
+async function writeServerFunction(standalonePath, manifest, functionPath, log) {
+  await mkdir(path.dirname(functionPath), { recursive: true });
+  await log.step("copy standalone", () => cp(standalonePath, functionPath, { recursive: true, verbatimSymlinks: true }));
+  const modules = path.join(functionPath, "node_modules");
+  const packages = await packageDirs(modules);
+  await Promise.all([...packages].filter(([name]) => functionDroppedPackages.some((pattern) => pattern.test(name))).map(([, dirs]) => Promise.all(dirs.map((dir) => rm(dir, { recursive: true, force: true })))));
+  await log.step("platform natives", () => replaceHostNatives(packages, log));
+  await writeText(path.join(functionPath, "index.mjs"), `import { createRequestHandler } from './server/entry.js';
 
-const handlerPromise = createRequestHandler({
-  root: path.join(import.meta.dirname, ${JSON.stringify(appRel)}),
-});
+const handlerPromise = createRequestHandler({ root: import.meta.dirname });
 
 async function handler(request) {
-  return (await handlerPromise)(request);
-}
-
-// Callable for the Node-style launcher, \`fetch\` for the Bun runtime.
-export default Object.assign(handler, { fetch: handler });
-`);
-  const maxDuration = manifest.routes.reduce((max, route) => route.maxDuration ? Math.max(max ?? 0, route.maxDuration) : max, undefined);
-  await writeText(path2.join(functionPath, ".vc-config.json"), `${JSON.stringify({
-    runtime: "bun1.4.x",
-    handler: "index.mjs",
-    launcherType: "Nodejs",
-    architecture: FUNCTION_PLATFORM.architecture,
-    useWebApi: true,
-    supportsResponseStreaming: true,
-    ...maxDuration ? { maxDuration } : {}
-  }, null, 2)}
-`);
-}
-function addWorkspaceDependencies(roots, packageRoots, from) {
-  const byName = new Map;
-  for (const root of packageRoots) {
-    const name = packageManifest(root)?.name;
-    if (name && !byName.has(name))
-      byName.set(name, root);
-  }
-  const queue = [...from];
-  const seen = new Set(queue);
-  while (queue.length > 0) {
-    const manifest = packageManifest(queue.pop());
-    if (!manifest)
-      continue;
-    for (const field of ["dependencies", "optionalDependencies"]) {
-      for (const name of Object.keys(manifest[field] ?? {})) {
-        const root = byName.get(name);
-        if (!root || seen.has(root))
-          continue;
-        seen.add(root);
-        roots.add(root);
-        queue.push(root);
-      }
-    }
-  }
-}
-var manifests = new Map;
-function packageManifest(root) {
-  const cached = manifests.get(root);
-  if (cached !== undefined || manifests.has(root))
-    return cached;
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync2(path2.join(root, "package.json"), "utf8"));
-  } catch {
-    parsed = undefined;
-  }
-  manifests.set(root, parsed);
-  return parsed;
-}
-async function copyTree(from, to, pack, excludeNames = [], visited = new Set([realDir(from) ?? path2.resolve(from)])) {
-  const exclude = new Set(excludeNames);
-  const clone = directoryCloneEnabled ? await directoryCloner() : null;
-  if (exclude.size === 0 && !existsSync2(to)) {
-    await mkdir(path2.dirname(to), { recursive: true });
-    if (clone?.(from, to))
-      return normalizeClone(to, from, pack, visited);
-  }
-  const entries = readDirEntries(from);
-  if (!entries)
-    return;
-  await mkdir(to, { recursive: true });
-  await Promise.all(entries.map(async (entry) => {
-    const source = path2.join(from, entry.name);
-    const target = path2.join(to, entry.name);
-    if (exclude.has(entry.name) || !shipsDir(pack, entry.name, source, entry.isSymbolicLink()))
-      return;
-    if (entry.isSymbolicLink()) {
-      const link2 = resolveLinkTarget(source);
-      if (!link2)
-        return;
-      if (link2.isDirectory) {
-        if (visited.has(link2.path))
-          return;
-        visited.add(link2.path);
-        return copyTree(link2.path, target, pack, [], visited);
-      }
-      return shipsFile(pack, entry.name, source) ? linkOrCopyFile(link2.path, target) : undefined;
-    }
-    if (entry.isDirectory() && clone?.(source, target)) {
-      return normalizeClone(target, source, pack, visited);
-    }
-    if (entry.isDirectory())
-      return copyTree(source, target, pack, [], visited);
-    if (entry.isFile() && shipsFile(pack, entry.name, source))
-      return linkOrCopyFile(source, target);
-  }));
-}
-function readDirEntries(dir) {
-  try {
-    return readdirSync(dir, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-var directoryCloneEnabled = true;
-var cloner;
-async function directoryCloner() {
-  if (cloner !== undefined)
-    return cloner;
-  cloner = null;
-  if (process.platform === "darwin") {
-    try {
-      const { dlopen } = await import("bun:ffi");
-      const { symbols } = dlopen("libSystem.B.dylib", {
-        clonefile: { args: ["cstring", "cstring", "i32"], returns: "i32" }
-      });
-      cloner = (from, to) => symbols.clonefile(Buffer.from(`${from}\x00`), Buffer.from(`${to}\x00`), 0) === 0;
-    } catch {}
-  }
-  return cloner;
-}
-async function normalizeClone(dir, from, pack, visited) {
-  const stack = [[dir, from]];
-  const pending = [];
-  while (stack.length > 0) {
-    const [current, currentFrom] = stack.pop();
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const full = path2.join(current, entry.name);
-      const source = path2.join(currentFrom, entry.name);
-      if (!shipsDir(pack, entry.name, source, entry.isSymbolicLink())) {
-        rmSync(full, { recursive: true, force: true });
-      } else if (entry.isSymbolicLink()) {
-        const link2 = resolveLinkTarget(source);
-        rmSync(full, { force: true });
-        if (!link2)
-          continue;
-        if (link2.isDirectory) {
-          if (visited.has(link2.path))
-            continue;
-          visited.add(link2.path);
-          pending.push(copyTree(link2.path, full, pack, [], visited));
-        } else if (shipsFile(pack, entry.name, source)) {
-          pending.push(linkOrCopyFile(link2.path, full));
-        }
-      } else if (entry.isDirectory()) {
-        stack.push([full, source]);
-      } else if (!shipsFile(pack, entry.name, source)) {
-        rmSync(full, { force: true });
-      }
-    }
-  }
-  await Promise.all(pending);
-}
-async function resolveFrameworkPackage(workspaceRoot) {
-  const root = path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/adapters", "../../..");
-  const packageJson = await readPackageJson(root);
-  const packageName = packageJson?.name ?? "pnext";
-  const inWorkspace = isInsideDir(workspaceRoot, root) && !root.includes("node_modules");
-  return {
-    root,
-    packageName,
-    dependencies: Object.keys(packageJson?.dependencies ?? {}),
-    optionalDependencies: Object.keys(packageJson?.optionalDependencies ?? {}),
-    inWorkspace,
-    targetRel: inWorkspace ? path2.relative(workspaceRoot, root) : path2.join("node_modules", packageName)
-  };
-}
-var packageCopyExcludes = [
-  "node_modules",
-  ".cache",
-  ".vercel",
-  ".next",
-  ".pnext",
-  ".turbo",
-  "test",
-  "tests",
-  "__tests__"
-];
-async function copyPackageTree(from, to, pack, only) {
-  const files = only ?? (await readPackageJson(from))?.files;
-  if (!files?.length || files.some((entry) => /[*?[\]{}!]/.test(entry))) {
-    return copyTree(from, to, pack, packageCopyExcludes);
-  }
-  await mkdir(to, { recursive: true });
-  await Promise.all([...files, "package.json", "tsconfig.json"].map(async (name) => {
-    const source = path2.join(from, name);
-    const stats = statSync(source, { throwIfNoEntry: false });
-    if (!stats)
-      return;
-    if (stats.isDirectory())
-      return copyTree(source, path2.join(to, name), pack);
-    if (!shipsFile(pack, name, source))
-      return;
-    await mkdir(path2.dirname(path2.join(to, name)), { recursive: true });
-    return linkOrCopyFile(source, path2.join(to, name));
-  }));
-}
-async function readPackageJson(dir) {
-  const file = path2.join(dir, "package.json");
-  if (!existsSync2(file))
-    return;
-  return JSON.parse(await readFile(file, "utf8"));
-}
-var dependencyClosureEnabled = true;
-function skipDependencyClosure() {
-  return !dependencyClosureEnabled;
-}
-async function linkOrCopyFile(from, to) {
-  try {
-    await link(from, to);
-  } catch {
-    await copyFile(from, to).catch((error) => {
-      if (error.code !== "ENOENT")
-        throw error;
-    });
-  }
-}
-function resolveLinkTarget(link2) {
-  const resolved = realDir(link2) ?? realFile(link2);
-  if (!resolved)
-    return;
-  try {
-    return { path: resolved, isDirectory: statSync(resolved).isDirectory() };
-  } catch {
-    return;
-  }
-}
-function realFile(file) {
-  try {
-    return realpathSync2(file);
-  } catch {
-    return;
-  }
-}
-function isInsideDir(root, file) {
-  const relative = path2.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
-}
-function isFrameworkOwnedAliasTarget(frameworkRoot2, target) {
-  if (!path2.isAbsolute(target) || !isInsideDir(frameworkRoot2, target))
-    return false;
-  return !path2.relative(frameworkRoot2, target).split(path2.sep).includes("node_modules");
-}
-function frameworkOwnedAliases(config, frameworkRoot2) {
-  return Object.entries(getImportAliasExtensions().aliases(config, "server")).filter(([, target]) => isFrameworkOwnedAliasTarget(frameworkRoot2, target));
+  return (await handlerPromise)(request);
 }
-async function injectCompatPaths(config, functionPath, frameworkRoot2, replicaPathFor) {
-  const aliasTargets = frameworkOwnedAliases(config, frameworkRoot2).map(([specifier, target]) => [specifier, replicaPathFor(target)]).filter((entry) => Boolean(entry[1]));
-  if (aliasTargets.length === 0)
-    return;
-  for (const file of walkTsconfigFiles(functionPath)) {
-    let parsed;
-    try {
-      const source = stripJsonComments(await readFile(file, "utf8")).replace(/,\s*([}\]])/g, "$1");
-      parsed = JSON.parse(source);
-    } catch (error) {
-      console.warn(`vercel adapter: could not update ${file}:`, error);
-      continue;
-    }
-    const dir = path2.dirname(file);
-    const compilerOptions = parsed.compilerOptions ??= {};
-    const paths = compilerOptions.paths ??= {};
-    for (const [specifier, target] of aliasTargets) {
-      if (paths[specifier])
-        continue;
-      const relative = toPosixPath(path2.relative(dir, target));
-      paths[specifier] = [relative.startsWith(".") ? relative : `./${relative}`];
-    }
-    compilerOptions.baseUrl ??= ".";
-    await rm(file);
-    await writeFile(file, `${JSON.stringify(parsed, null, 2)}
+
+// Callable for the Node-style launcher, \`fetch\` for the Bun runtime.
+export default Object.assign(handler, { fetch: handler });
+`);
+  const maxDuration = manifest.routes.reduce((max, route) => route.maxDuration ? Math.max(max ?? 0, route.maxDuration) : max, undefined);
+  await writeText(path.join(functionPath, ".vc-config.json"), `${JSON.stringify({
+    runtime: "bun1.4.x",
+    handler: "index.mjs",
+    launcherType: "Nodejs",
+    architecture: FUNCTION_PLATFORM.architecture,
+    useWebApi: true,
+    supportsResponseStreaming: true,
+    ...maxDuration ? { maxDuration } : {}
+  }, null, 2)}
 `);
-  }
 }
-function stripJsonComments(source) {
-  let result = "";
-  let inString = false;
-  for (let index = 0;index < source.length; index++) {
-    const char = source[index];
-    if (inString) {
-      result += char;
-      if (char === "\\") {
-        result += source[++index] ?? "";
-      } else if (char === '"') {
-        inString = false;
+async function packageDirs(modules) {
+  const found = new Map;
+  const visit = async (dir, depth) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const full = path.join(dir, entry.name);
+      if (entry.name === ".bun" || entry.name === ".pnpm") {
+        for (const store of await readdir(full, { withFileTypes: true }).catch(() => []))
+          if (store.isDirectory())
+            await visit(path.join(full, store.name, "node_modules"), 0);
+      } else if (entry.name.startsWith("@") && depth === 0) {
+        await visit(full, 1);
+      } else if (existsSync(path.join(full, "package.json"))) {
+        const name = depth === 1 ? `${path.basename(dir)}/${entry.name}` : entry.name;
+        found.set(name, [...found.get(name) ?? [], full]);
+        await visit(path.join(full, "node_modules"), 0);
       }
-      continue;
     }
-    if (char === '"') {
-      inString = true;
-      result += char;
-      continue;
-    }
-    if (char === "/" && source[index + 1] === "/") {
-      while (index < source.length && source[index] !== `
-`)
-        index++;
-      result += `
-`;
-      continue;
-    }
-    if (char === "/" && source[index + 1] === "*") {
-      index += 2;
-      while (index < source.length && !(source[index] === "*" && source[index + 1] === "/"))
-        index++;
-      index++;
-      continue;
-    }
-    result += char;
-  }
-  return result;
+  };
+  await visit(modules, 0);
+  return found;
 }
-var bakedPathFileFilter = /\.(?:m?js|cjs|jsx|tsx?|json|html|css)$/;
-var BAKED_PATH_CONCURRENCY = 64;
-async function rewriteBakedPaths(dir, replacements) {
-  if (!existsSync2(dir))
+async function readPackageJson(dir) {
+  try {
+    return JSON.parse(await readFile(path.join(dir, "package.json"), "utf8"));
+  } catch {
     return;
-  const files = (await listFiles(dir)).filter((file) => bakedPathFileFilter.test(file));
-  for (let i = 0;i < files.length; i += BAKED_PATH_CONCURRENCY) {
-    await Promise.all(files.slice(i, i + BAKED_PATH_CONCURRENCY).map(async (file) => {
-      const source = await readFile(file, "utf8");
-      let rewritten = source;
-      for (const [from, to] of replacements) {
-        if (rewritten.includes(from))
-          rewritten = rewritten.replaceAll(from, to);
-      }
-      if (rewritten === source)
-        return;
-      await rm(file);
-      await writeFile(file, rewritten);
-    }));
   }
 }
-async function artifactSpecifiers(file) {
-  const sidecar = await readFile(`${file}${compiledSpecifiersManifestSuffix}`, "utf8").catch(() => null);
-  if (sidecar !== null) {
-    try {
-      const parsed = JSON.parse(sidecar);
-      if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) {
-        return parsed;
-      }
-    } catch {}
+async function replaceHostNatives(packages, log) {
+  const manifests = new Map;
+  for (const [name, dirs] of packages) {
+    const json = await readPackageJson(dirs[0]);
+    if (json)
+      manifests.set(name, json);
   }
-  const source = await readFile(file, "utf8").catch(() => null);
-  return source === null ? null : importSpecifiers(source, file);
-}
-async function traceNodeModulesClosure(config, manifest, functionPath, framework, warmedModules, pack, log, release = false) {
-  const workspaceRoot = config.workspaceRoot;
-  const specifiers = new Set;
-  const tracedFiles = new Set;
-  const hrefPackageDirs = new Set;
-  const frameworkAliasedSpecifiers = new Set(frameworkOwnedAliases(config, path2.resolve(framework.root)).map(([specifier]) => specifier));
-  await log.step("trace runtime imports", async () => {
-    const queue2 = [];
-    const seen2 = tracedFiles;
-    const enqueue = (file) => {
-      if (!file)
-        return;
-      const resolved = path2.resolve(file);
-      if (seen2.has(resolved) || !existsSync2(resolved))
-        return;
-      seen2.add(resolved);
-      queue2.push(resolved);
-    };
-    if (!release) {
-      for (const route of manifest.routes) {
-        if (route.kind === "handler")
-          enqueue(route.file);
-      }
-      enqueue(findProxyFile(config) ?? undefined);
-      enqueue(path2.join(config.root, "pnext.config.ts"));
-      enqueue(path2.join(config.root, "next.config.js"));
-    }
-    for (const file of warmedModules)
-      enqueue(file);
-    const visit = async (file) => {
-      if (!scriptFilePattern.test(file))
-        return;
-      const found = await artifactSpecifiers(file);
-      if (found === null)
-        return;
-      for (const specifier of found) {
-        if (frameworkAliasedSpecifiers.has(specifier))
-          continue;
-        const absolute = absolutePathFromSpecifier(specifier);
-        if (absolute && isInsideDir(framework.root, absolute))
-          continue;
-        if (absolute) {
-          const name2 = packageNameFromPath(absolute);
-          if (name2) {
-            specifiers.add(name2);
-            hrefPackageDirs.add(packageDirFromPath(absolute, name2));
-          } else if (isInsideDir(config.outPath, absolute))
-            enqueue(absolute);
-          continue;
-        }
-        if (/^(?:node:|bun$|bun:|data:)/.test(specifier))
-          continue;
-        const resolved = resolveImport(config.root, file, specifier, config.workspaceRoot);
-        if (resolved && isInsideDir(workspaceRoot, resolved) && !resolved.includes("node_modules")) {
-          enqueue(resolved);
-        }
-        const installed = specifier.startsWith(".") && resolved && packageNameFromPath(resolved);
-        if (installed) {
-          specifiers.add(installed);
-          hrefPackageDirs.add(packageDirFromPath(resolved, installed));
-        }
-        const name = packageNameFromSpecifier(specifier);
-        if (name)
-          specifiers.add(name);
-      }
-    };
-    const READ_BATCH = 64;
-    for (let frontier = queue2.splice(0);frontier.length > 0; frontier = queue2.splice(0)) {
-      for (let index = 0;index < frontier.length; index += READ_BATCH) {
-        await Promise.all(frontier.slice(index, index + READ_BATCH).map(visit));
-      }
-    }
-    log.log(`traced ${seen2.size} runtime modules`);
-  });
-  const packageDirs = new Map;
-  const nestedCopies = new Map;
-  const workspaceLinks = new Map;
   const hostNatives = new Map;
-  const appDependencies = await declaredDependencies(config.root);
-  const runtimeDependencies = release ? await frameworkRuntimePackages(framework.root) : undefined;
-  const queue = [
-    ...framework.dependencies.filter((name) => !runtimeDependencies || runtimeDependencies.has(name)).map((name) => ({ name, from: framework.root })),
-    ...framework.optionalDependencies.filter((name) => appDependencies.has(name)).map((name) => ({ name, from: framework.root })),
-    ...[...specifiers].map((name) => ({ name, from: workspaceRoot }))
-  ];
-  const seen = new Set;
-  while (queue.length > 0) {
-    const { name, from, owner } = queue.shift();
-    if (seen.has(name))
-      continue;
-    seen.add(name);
-    if (name === framework.packageName) {
-      if (framework.inWorkspace)
-        workspaceLinks.set(name, framework.targetRel);
-      continue;
-    }
-    const dir = resolvePackageDir(name, [from, workspaceRoot, config.root]);
-    if (!dir)
-      continue;
-    const workspaceRelative = path2.relative(workspaceRoot, dir);
-    if (!workspaceRelative.startsWith("..") && !workspaceRelative.startsWith("node_modules")) {
-      workspaceLinks.set(name, workspaceRelative);
-      continue;
-    }
-    const packageJson = await readPackageJson(dir);
-    const platformBound = Boolean(packageJson?.os ?? packageJson?.cpu);
-    if (packageJson && platformBound && !matchesFunctionPlatform(packageJson)) {
-      hostNatives.set(name, { dir, owner });
+  for (const [name, json] of manifests) {
+    if (!(json.os ?? json.cpu) || matchesFunctionPlatform(json))
       continue;
-    }
-    packageDirs.set(name, dir);
-    if (!packageJson)
-      continue;
-    const expand = async (packageDir, packageJson2, target) => {
-      const self = { name: packageJson2?.name ?? name, version: packageJson2?.version ?? "" };
-      for (const dependency of [
-        ...Object.keys(packageJson2?.dependencies ?? {}),
-        ...Object.keys(packageJson2?.optionalDependencies ?? {})
-      ]) {
-        const nested = path2.join(packageDir, "node_modules", dependency);
-        const nestedJson = existsSync2(path2.join(nested, "package.json")) ? await readPackageJson(nested) : undefined;
-        if (!nestedJson || nestedJson.os || nestedJson.cpu) {
-          queue.push({ name: dependency, from: packageDir, owner: self });
-          continue;
-        }
-        const nestedTarget = path2.join(target, "node_modules", dependency);
-        if (nestedCopies.has(nestedTarget))
-          continue;
-        nestedCopies.set(nestedTarget, nested);
-        await expand(nested, nestedJson, nestedTarget);
-      }
-    };
-    await expand(dir, packageJson, path2.join("node_modules", name));
-  }
-  if (hostNatives.size > 0 && !skipDependencyClosure()) {
-    const targets = await log.step(`resolve ${FUNCTION_PLATFORM.os}-${FUNCTION_PLATFORM.cpu} natives (${hostNatives.size} packages)`, () => platformNativePackages(hostNatives, log));
-    for (const [name, dir] of targets)
-      packageDirs.set(name, dir);
-  }
-  const copy = async () => {
-    const entries = skipDependencyClosure() ? [] : [...packageDirs];
-    const batchSize = 16;
-    for (let index = 0;index < entries.length; index += batchSize) {
-      await Promise.all(entries.slice(index, index + batchSize).map(async ([name, dir]) => {
-        const target = path2.join(functionPath, "node_modules", name);
-        await mkdir(path2.dirname(target), { recursive: true });
-        await copyTree(dir, target, pack);
-      }));
-    }
-    for (const [target, dir] of skipDependencyClosure() ? [] : nestedCopies) {
-      await mkdir(path2.dirname(path2.join(functionPath, target)), { recursive: true });
-      await copyTree(dir, path2.join(functionPath, target), pack);
-    }
-    for (const dir of skipDependencyClosure() ? [] : hrefPackageDirs) {
-      const relative = path2.relative(workspaceRoot, dir);
-      const target = path2.join(functionPath, relative);
-      if (relative.startsWith("..") || existsSync2(target))
-        continue;
-      await mkdir(path2.dirname(target), { recursive: true });
-      await copyTree(dir, target, pack);
-    }
-    for (const [name, workspaceRelative] of workspaceLinks) {
-      const linkPath = path2.join(functionPath, "node_modules", name);
-      await mkdir(path2.dirname(linkPath), { recursive: true });
-      const target = path2.relative(path2.dirname(linkPath), path2.join(functionPath, workspaceRelative));
-      if (!existsSync2(linkPath))
-        await symlink(target, linkPath, "dir");
-    }
-  };
-  return {
-    tracedFiles,
-    workspacePackages: [...workspaceLinks.values()],
-    packageCount: packageDirs.size,
-    copy
-  };
-}
-function releaseEntries(config, manifest) {
-  if (!existsSync2(buildIndexFile(config.outPath)))
-    return;
-  const index = readBuildIndex(config.outPath);
-  return [
-    ...Object.values(index.modules),
-    index.nextConfig,
-    index.instrumentation?.file,
-    index.instrumentation?.edge,
-    ...Object.values(index.compat?.cacheHandlers ?? {}),
-    manifest.proxyModule
-  ].filter((artifact) => artifact !== undefined).map((artifact) => path2.resolve(config.outPath, artifact));
-}
-async function frameworkRuntimePackages(frameworkRoot2) {
-  const src = path2.join(frameworkRoot2, "src");
-  const scanners = {
-    ts: new Bun.Transpiler({ loader: "ts" }),
-    tsx: new Bun.Transpiler({ loader: "tsx" })
-  };
-  const queue = [
-    ...runtimeEntryFiles.map((file) => path2.join(src, file)),
-    ...runtimeEntryDirs.flatMap((dir) => listSourceFiles(path2.join(src, dir)).filter((file) => /(?<!\.d)\.tsx?$/.test(file)))
-  ];
-  const seen = new Set(queue);
-  const packages = new Set;
-  for (const file of queue) {
-    const scanner = file.endsWith(".tsx") || file.endsWith(".jsx") ? scanners.tsx : scanners.ts;
-    for (const edge of scanner.scanImports(await readFile(file, "utf8"))) {
-      if (edge.kind !== "import-statement" && edge.kind !== "dynamic-import")
-        continue;
-      if (!edge.path.startsWith(".")) {
-        const name = packageNameFromSpecifier(edge.path);
-        if (name)
-          packages.add(name);
-        continue;
-      }
-      const target = resolveFrom(edge.path, path2.dirname(file));
-      if (target && !seen.has(target) && isInsideDir(src, target) && scriptFilePattern.test(target)) {
-        seen.add(target);
-        queue.push(target);
-      }
-    }
+    const owner = [...manifests].find(([, candidate]) => candidate.optionalDependencies?.[name]);
+    hostNatives.set(name, {
+      dirs: packages.get(name),
+      owner: owner && { name: owner[0], version: owner[1].version ?? "" }
+    });
   }
-  return packages;
-}
-function resolveFrom(specifier, dir) {
-  try {
-    return Bun.resolveSync(specifier, dir);
-  } catch {
+  if (hostNatives.size === 0)
     return;
+  const targets = await platformNativePackages(hostNatives, manifests, log);
+  for (const [name, dir] of targets) {
+    for (const host of hostNatives.get(name)?.dirs ?? []) {
+      const target = path.join(path.dirname(host), name.split("/").at(-1));
+      await rm(host, { recursive: true, force: true });
+      await cp(dir, target, { recursive: true, dereference: true });
+    }
   }
 }
-function listSourceFiles(dir) {
-  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? listSourceFiles(path2.join(dir, entry.name)) : [path2.join(dir, entry.name)]);
-}
-async function platformNativePackages(hostNatives, log) {
+async function platformNativePackages(hostNatives, manifests, log) {
   const owners = new Map;
-  for (const [name, { dir, owner }] of hostNatives) {
-    const spec = owner ?? { name, version: (await readPackageJson(dir))?.version ?? "" };
+  for (const [name, { owner }] of hostNatives) {
+    const spec = owner ?? { name, version: manifests.get(name)?.version ?? "" };
     if (spec.version)
       owners.set(spec.name, spec.version);
   }
   const specs = [...owners].map(([name, version]) => `${name}@${version}`).sort();
-  const fallback = () => new Map([...hostNatives].map(([name, { dir }]) => [name, dir]));
   if (specs.length === 0)
-    return fallback();
+    return new Map;
   try {
     const installed = await crossPlatformInstall(specs);
     const matches = new Map;
     for (const [name, dir] of installed) {
-      const packageJson = await readPackageJson(dir);
-      if (packageJson && matchesFunctionPlatform(packageJson))
+      const json = await readPackageJson(dir);
+      if (json && (json.os ?? json.cpu) && matchesFunctionPlatform(json))
         matches.set(name, dir);
     }
-    if (matches.size === 0) {
+    if (matches.size === 0)
       throw new Error(`no ${FUNCTION_PLATFORM.os} builds in ${specs.join(" ")}`);
-    }
     return matches;
   } catch (error) {
     console.warn(`vercel adapter: could not fetch ${FUNCTION_PLATFORM.os}-${FUNCTION_PLATFORM.cpu} native packages; the function will carry this machine's builds and fail at runtime:`, error);
     log.log("falling back to host native packages");
-    return fallback();
+    return new Map;
   }
 }
 function matchesFunctionPlatform(packageJson) {
@@ -1236,13 +409,13 @@ function matchesFunctionPlatform(packageJson) {
 }
 async function crossPlatformInstall(specs) {
   const key = Bun.hash.xxHash3(`${FUNCTION_PLATFORM.os}-${FUNCTION_PLATFORM.cpu}\x00${specs.join("\x00")}`).toString(16);
-  const dir = path2.join(cacheRoot(), "vercel-natives", key);
-  const modules = path2.join(dir, "node_modules");
-  if (!existsSync2(modules)) {
+  const dir = path.join(cacheRoot(), "vercel-natives", key);
+  const modules = path.join(dir, "node_modules");
+  if (!existsSync(modules)) {
     const staging = `${dir}.${process.pid.toString(36)}`;
     await rm(staging, { recursive: true, force: true });
     await mkdir(staging, { recursive: true });
-    await writeText(path2.join(staging, "package.json"), `{"name":"pnext-natives"}
+    await writeText(path.join(staging, "package.json"), `{"name":"pnext-natives"}
 `);
     const install = Bun.spawn([
       "bun",
@@ -1267,101 +440,25 @@ async function crossPlatformInstall(specs) {
     if (entry.startsWith("."))
       continue;
     if (!entry.startsWith("@")) {
-      installed.set(entry, path2.join(modules, entry));
+      installed.set(entry, path.join(modules, entry));
       continue;
     }
-    for (const scoped of readdirSync(path2.join(modules, entry))) {
-      installed.set(`${entry}/${scoped}`, path2.join(modules, entry, scoped));
+    for (const scoped of readdirSync(path.join(modules, entry))) {
+      installed.set(`${entry}/${scoped}`, path.join(modules, entry, scoped));
     }
   }
   return installed;
 }
-var scriptFilePattern = /\.(?:m?js|cjs|jsx|tsx?)$/;
-var skippedScanDirs = new Set(["node_modules", ".git", ".next", ".pnext", ".turbo", ".vercel"]);
-function* walkTsconfigFiles(root) {
-  const stack = [root];
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const full = path2.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!skippedScanDirs.has(entry.name))
-          stack.push(full);
-      } else if (entry.isFile() && entry.name === "tsconfig.json") {
-        yield full;
-      }
-    }
-  }
-}
-async function declaredDependencies(root) {
-  const packageJson = await readPackageJson(root);
-  return new Set(["dependencies", "optionalDependencies", "devDependencies"].flatMap((field) => Object.keys(packageJson?.[field] ?? {})));
-}
-function absolutePathFromSpecifier(specifier) {
-  if (specifier.startsWith("file://"))
-    return fileURLToPath2(specifier);
-  return path2.isAbsolute(specifier) ? specifier : undefined;
-}
-function packageDirFromPath(file, name) {
-  const posix = toPosixPath(file);
-  const marker = `/node_modules/${name}/`;
-  return posix.slice(0, posix.lastIndexOf(marker) + marker.length - 1);
-}
-function packageNameFromPath(file) {
-  const parts = toPosixPath(file).split("/node_modules/");
-  const tail = parts.at(-1);
-  if (parts.length < 2 || !tail)
-    return;
-  const segments = tail.split("/");
-  return segments[0]?.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
-}
-function packageNameFromSpecifier(specifier) {
-  if (/^[./#]|^file:|^node:|^data:/.test(specifier))
-    return;
-  if (specifier === "bun" || specifier.startsWith("bun:"))
-    return;
-  if (specifier.includes(":"))
-    return;
-  if (specifier.startsWith("@") && !/^@[^/]+\/[^/]+/.test(specifier))
-    return;
-  const parts = specifier.split("/");
-  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-  if (!name || builtinModules.includes(name))
-    return;
-  return name;
-}
-function resolvePackageDir(name, fromDirs) {
-  for (const from of fromDirs) {
-    let dir = path2.resolve(from);
-    while (true) {
-      const candidate = path2.join(dir, "node_modules", name);
-      if (existsSync2(path2.join(candidate, "package.json")))
-        return realDir(candidate);
-      const parent = path2.dirname(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
-  }
-  return;
-}
-function realDir(dir) {
-  try {
-    return statSync(dir).isDirectory() ? realpathSync2(dir) : undefined;
-  } catch {
-    return;
-  }
-}
 async function copyStaticFiles(from, to, shouldCopy = () => true) {
-  const files = (await listFiles(from)).filter((file) => shouldCopy(toPosixPath(path2.relative(from, file))));
-  const directories = new Set(files.map((file) => path2.dirname(path2.join(to, path2.relative(from, file)))));
+  const files = (await listFiles(from)).filter((file) => shouldCopy(toPosixPath(path.relative(from, file))));
+  const directories = new Set(files.map((file) => path.dirname(path.join(to, path.relative(from, file)))));
   await Promise.all([...directories].map((dir) => mkdir(dir, { recursive: true })));
-  await Promise.all(files.map((file) => linkOrCopyFile(file, path2.join(to, path2.relative(from, file)))));
+  await Promise.all(files.map((file) => copyFile(file, path.join(to, path.relative(from, file)), constants.COPYFILE_FICLONE)));
 }
 async function staticOverrides(publicPath, staticFiles) {
   const overrides = {};
   for (const file of await listFiles(publicPath)) {
-    const relative = toPosixPath(path2.relative(publicPath, file));
+    const relative = toPosixPath(path.relative(publicPath, file));
     if (!relative.endsWith("/index.html"))
       continue;
     overrides[relative] = { path: relative.replace(/\/index\.html$/, "") };
@@ -1377,7 +474,7 @@ async function staticOverrides(publicPath, staticFiles) {
 }
 async function immutableAssetRoutes(publicDir, publicAssets = []) {
   const app = new Set(publicAssets);
-  const built = publicAssets.length > 0 ? (await listFiles(publicDir)).map((file) => toPosixPath(path2.relative(publicDir, file))).filter((relative) => !app.has(relative) && immutableAssetPath(relative)) : [];
+  const built = publicAssets.length > 0 ? (await listFiles(publicDir)).map((file) => toPosixPath(path.relative(publicDir, file))).filter((relative) => !app.has(relative) && immutableAssetPath(relative)) : [];
   const patterns = immutableAssetPatterns(built, publicAssets);
   return routeSources(patterns, (source) => `^/(?:${source})`).map((src) => ({
     src,
@@ -1424,46 +521,212 @@ function canServeStaticOnVercel(metadata) {
 function routeHeaders(metadata) {
   return metadata.headers.filter(([name]) => name.toLowerCase() !== "content-type");
 }
-var maxRouteSourceLength = 2000;
-function staticHeaderRoutes(staticFiles) {
-  const groups = new Map;
-  for (const [relative, metadata] of Object.entries(staticFiles)) {
-    const extra = routeHeaders(metadata);
-    if (extra.length === 0 || !canServeStaticOnVercel(metadata))
-      continue;
-    const headers = Object.fromEntries(new Headers(extra));
-    const key = JSON.stringify(headers);
-    const group = groups.get(key) ?? { headers, patterns: [] };
-    groups.set(key, group);
-    group.patterns.push(servedPathPattern(relative));
+var maxRouteSourceLength = 2000;
+function staticHeaderRoutes(staticFiles) {
+  const groups = new Map;
+  for (const [relative, metadata] of Object.entries(staticFiles)) {
+    const extra = routeHeaders(metadata);
+    if (extra.length === 0 || !canServeStaticOnVercel(metadata))
+      continue;
+    const headers = Object.fromEntries(new Headers(extra));
+    const key = JSON.stringify(headers);
+    const group = groups.get(key) ?? { headers, patterns: [] };
+    groups.set(key, group);
+    group.patterns.push(servedPathPattern(relative));
+  }
+  return [...groups.values()].flatMap(({ headers, patterns }) => routeSources(patterns, (source) => `^/(?:${source})$`).map((src) => ({
+    src,
+    methods: ["GET", "HEAD"],
+    headers,
+    continue: true,
+    important: true
+  })));
+}
+function routeSources(patterns, wrap) {
+  const sources = [];
+  for (const pattern of patterns) {
+    const last = sources.length - 1;
+    if (last >= 0 && wrap(`${sources[last]}|${pattern}`).length <= maxRouteSourceLength) {
+      sources[last] += `|${pattern}`;
+    } else {
+      sources.push(pattern);
+    }
+  }
+  return sources.map(wrap);
+}
+function servedPathPattern(relative) {
+  if (relative === "index.html")
+    return "(?:index\\.html)?";
+  if (!relative.endsWith("/index.html"))
+    return escapeRegex(relative);
+  return `${escapeRegex(relative.slice(0, -"/index.html".length))}(?:/|/index\\.html)?`;
+}
+
+// src/cli/adapters/vercel-warm.ts
+import { fileURLToPath } from "url";
+
+// src/runtime/release-graph.ts
+import { existsSync as existsSync2, readFileSync, realpathSync } from "fs";
+import path2 from "path";
+var layerDirs = {
+  "server:server": "rsc",
+  "client:client": "ssr"
+};
+var layers = Object.keys(layerDirs);
+var frameworkRoot = realpathSync(path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", ".."));
+
+// src/cli/adapters/vercel-warm.ts
+var DONE_MARKER = "pnext-warm-done:";
+var COMPILED_MARKER = "pnext-warm-compiled";
+var ATTEMPT_TIMEOUT_MS = 10 * 60000;
+var MAX_ATTEMPTS = 3;
+var FULL_MODE_FLAG = "--full";
+function startWarmChild(config, mode = "full") {
+  const children = new Set;
+  let disposed = false;
+  const spawn = () => {
+    if (disposed)
+      return;
+    const child = spawnWarmProcess(config, mode);
+    if (!child)
+      return;
+    children.add(child);
+    child.exited.finally(() => children.delete(child));
+    forwardWarmStderr(child);
+    return child;
+  };
+  const killOnExit = () => kill();
+  const kill = () => {
+    if (disposed)
+      return;
+    disposed = true;
+    process.off("exit", killOnExit);
+    for (const child of children)
+      child.kill();
+    children.clear();
+  };
+  process.once("exit", killOnExit);
+  const first = spawn();
+  return {
+    prewarm(files) {
+      if (!first || files.length === 0)
+        return;
+      try {
+        first.stdin.write(`${JSON.stringify({ prewarm: files })}
+`);
+        first.stdin.flush();
+      } catch {}
+    },
+    finish: (log, onCompiled, facts = { clientReferences: [] }) => warmWithRestarts(first, spawn, mode, log, facts, onCompiled).finally(kill),
+    kill
+  };
+}
+async function forwardWarmStderr(child) {
+  try {
+    const reader = child.stderr.getReader();
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      process.stderr.write(value);
+    }
+  } catch {}
+}
+function spawnWarmProcess(config, mode) {
+  const entry = fileURLToPath(new URL(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/adapters/vercel-warm.ts").href));
+  const argv = mode === "full" ? [config.root, FULL_MODE_FLAG] : [config.root];
+  try {
+    return Bun.spawn([namedBunBinary("pnext-warm"), "--conditions=react-server", entry, ...argv], {
+      cwd: config.root,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env
+    });
+  } catch {
+    return;
+  }
+}
+async function warmWithRestarts(first, spawn, mode, log, facts, onCompiled) {
+  const finished = new Map;
+  const compiled = () => [...finished.values()].filter((file) => Boolean(file));
+  let fired = false;
+  const fireOnCompiled = onCompiled ? () => {
+    if (fired)
+      return;
+    fired = true;
+    onCompiled(compiled());
+  } : undefined;
+  let child = first;
+  for (let attempt = 1;attempt <= MAX_ATTEMPTS && child; attempt++) {
+    const before = finished.size;
+    const failure = await runAttempt(child, {
+      skip: [...finished.keys()],
+      compiled: Object.fromEntries([...finished].filter((entry) => Boolean(entry[1]))),
+      ...facts
+    }, finished, fireOnCompiled);
+    if (!failure) {
+      log.log(`warmed ${compiled().length} modules`);
+      return compiled();
+    }
+    child = finished.size > before && attempt < MAX_ATTEMPTS ? spawn() : undefined;
+    if (child)
+      log.log(`warm-up ${failure} after ${finished.size} files; restarting past them`);
+    else
+      warmIncomplete(failure, finished.size, mode);
   }
-  return [...groups.values()].flatMap(({ headers, patterns }) => routeSources(patterns, (source) => `^/(?:${source})$`).map((src) => ({
-    src,
-    methods: ["GET", "HEAD"],
-    headers,
-    continue: true,
-    important: true
-  })));
+  fireOnCompiled?.();
+  return compiled();
 }
-function routeSources(patterns, wrap) {
-  const sources = [];
-  for (const pattern of patterns) {
-    const last = sources.length - 1;
-    if (last >= 0 && wrap(`${sources[last]}|${pattern}`).length <= maxRouteSourceLength) {
-      sources[last] += `|${pattern}`;
-    } else {
-      sources.push(pattern);
+async function runAttempt(child, request, finished, onCompiled) {
+  try {
+    child.stdin.write(`${JSON.stringify(request)}
+`);
+    child.stdin.end();
+  } catch {}
+  const timeout = setTimeout(() => child.kill("SIGKILL"), ATTEMPT_TIMEOUT_MS);
+  timeout.unref?.();
+  const processLine = (line) => {
+    if (!line)
+      return;
+    if (line === COMPILED_MARKER) {
+      onCompiled?.();
+      return;
+    }
+    if (!line.startsWith(DONE_MARKER)) {
+      console.log(line);
+      return;
+    }
+    const [source, artifact] = line.slice(DONE_MARKER.length).split("\t");
+    if (source)
+      finished.set(source, artifact || undefined);
+  };
+  const reader = child.stdout.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    let newline;
+    while ((newline = buffer.indexOf(`
+`)) >= 0) {
+      processLine(buffer.slice(0, newline));
+      buffer = buffer.slice(newline + 1);
     }
   }
-  return sources.map(wrap);
+  if (buffer)
+    processLine(buffer);
+  const code = await child.exited.finally(() => clearTimeout(timeout));
+  if (code === 0)
+    return;
+  return child.signalCode ? `was killed by ${child.signalCode}` : `exited with code ${code}`;
 }
-function servedPathPattern(relative) {
-  if (relative === "index.html")
-    return "(?:index\\.html)?";
-  if (!relative.endsWith("/index.html"))
-    return escapeRegex(relative);
-  return `${escapeRegex(relative.slice(0, -"/index.html".length))}(?:/|/index\\.html)?`;
+function warmIncomplete(failure, done, mode) {
+  console.warn(`pnext build: module warm-up ${failure} after warming ${done} file(s). ` + (mode === "full" ? "The function ships without the rest of its module cache and may fail to render those " + "routes at request time, where Vercel's filesystem is read-only." : "The production server compiles the rest on the first request that needs them."));
 }
+if (false) {}
 
 // src/cli/build.ts
 import { runWithCacheScope } from "../../../src/request/cache.ts";
@@ -1471,10 +734,10 @@ import { runWithCacheScope } from "../../../src/request/cache.ts";
 // src/cli/build/cache.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync3 } from "fs";
-import { lstat, mkdir as mkdir2, readFile as readFile2, readdir, readlink } from "fs/promises";
+import { lstat, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, readlink } from "fs/promises";
 import path3 from "path";
 var CACHE_VERSION = 2;
-var CACHE_SEGMENTS = ["cache", "build"];
+var CACHE_SEGMENTS = ["build"];
 var SKIP_INPUT_DIRS = new Set([
   ".claude",
   ".git",
@@ -1511,7 +774,7 @@ async function lookupBuildCache(config, options) {
     return { enabled: true, context, inputs, reason: `output (${changed || "unknown"})` };
   }
   try {
-    const manifest = resolveManifest(JSON.parse(await readFile2(path3.join(config.outPath, "manifest.json"), "utf8")), config.outPath, config.root);
+    const manifest = resolveManifest(JSON.parse(await readFile2(buildManifestFile(config.outPath), "utf8")), config.outPath, config.root);
     return { enabled: true, context, inputs, manifest, reason: "hit" };
   } catch {
     return { enabled: true, context, inputs, reason: "manifest" };
@@ -1538,7 +801,7 @@ function cacheEnabled(options) {
   return options.adapter === undefined && options.debugBuildPaths === undefined && options.buildMode === undefined && options.debugPrerender !== true;
 }
 function cacheDir(outPath) {
-  return path3.join(outPath, ...CACHE_SEGMENTS);
+  return path3.join(outCachePath(outPath), ...CACHE_SEGMENTS);
 }
 function recordFile(outPath) {
   return path3.join(cacheDir(outPath), "result.json");
@@ -1605,7 +868,7 @@ async function inputRecords(config, previous) {
 async function collectModuleGraphInputs(config, files) {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile2(path3.join(config.outPath, "cache", "server", "graph.json"), "utf8"));
+    parsed = JSON.parse(await readFile2(path3.join(outCachePath(config.outPath), "server", "graph.json"), "utf8"));
   } catch {
     return;
   }
@@ -1618,7 +881,7 @@ async function collectModuleGraphInputs(config, files) {
   }
 }
 async function collectTree(root, prefix, files, outPath, dir = root) {
-  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
   await Promise.all(entries.map(async (entry) => {
     const file = path3.join(dir, entry.name);
     if (file === outPath || file.startsWith(`${outPath}${path3.sep}`))
@@ -1643,7 +906,7 @@ function addFile(files, key, file) {
 }
 async function outputSnapshot(outPath) {
   const files = new Map;
-  const entries = await readdir(outPath, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir2(outPath, { withFileTypes: true }).catch(() => []);
   await Promise.all(entries.map(async (entry) => {
     if (entry.name === "cache" || entry.name === "dev")
       return;
@@ -1669,7 +932,7 @@ function changedFiles(before, after) {
   return [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((file) => before[file] !== after[file]);
 }
 async function collectOutputTree(root, dir, files) {
-  const entries = await readdir(dir, { withFileTypes: true });
+  const entries = await readdir2(dir, { withFileTypes: true });
   await Promise.all(entries.map(async (entry) => {
     const file = path3.join(dir, entry.name);
     if (entry.isDirectory())
@@ -1686,32 +949,559 @@ function toPosix(file) {
   return path3.sep === "/" ? file : file.split(path3.sep).join("/");
 }
 
-// src/cli/serve/entry.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+// src/cli/serve/standalone.ts
+import { createHash as createHash2 } from "crypto";
+import { constants as constants2, existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, realpathSync as realpathSync2, statSync } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir3, readFile as readFile3, rename as rename2, rm as rm2, writeFile } from "fs/promises";
+import { builtinModules } from "module";
 import path4 from "path";
-var frameworkRoot2 = path4.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve", "..", "..", "..");
-function frameworkVersion() {
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+var frameworkRoot2 = realpathSync2(path4.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve", "..", "..", ".."));
+var frameworkPackage = JSON.parse(readFileSync2(path4.join(frameworkRoot2, "package.json"), "utf8"));
+var runtimeDependencies = new Set(Object.keys(frameworkPackage.dependencies ?? {}));
+var buildOnlyModule = /^(?:build|modules|loader|compile|esbuild|dev|run|typegen|analyze|create)$/;
+var builtins = new Set(builtinModules);
+var scriptFile = /\.(?:[cm]?[jt]sx?)$/;
+function frameworkStartEntry() {
+  return readPrebundleStamp(frameworkRoot2, frameworkFingerprint()) ? path4.join(frameworkRoot2, "dist", "server", "cli", "start.js") : path4.join(frameworkRoot2, "src", "cli", "start.ts");
+}
+function startStandalone(config) {
+  const input = {
+    outPath: config.outPath,
+    root: config.root,
+    workspaceRoot: config.workspaceRoot
+  };
+  const modules = path4.join(config.workspaceRoot, "node_modules");
+  const cacheFile = existsSync4(modules) && path4.join(modules, ".cache", "pnext", `standalone-${frameworkTraceKey()}.json`);
+  if (cacheFile && existsSync4(cacheFile)) {
+    try {
+      return Promise.resolve(JSON.parse(readFileSync2(cacheFile, "utf8")));
+    } catch {}
+  }
+  const framework = new Promise((resolve, reject) => {
+    const worker = new Worker(new URL("./standalone-worker.ts", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve/standalone.ts").href));
+    worker.unref?.();
+    worker.onmessage = (event) => {
+      resolve(event.data);
+      worker.terminate();
+    };
+    worker.onerror = (event) => {
+      reject(new Error(event.message));
+      worker.terminate();
+    };
+    worker.postMessage(input);
+  }).catch(() => traceFramework(input));
+  if (cacheFile)
+    framework.then(async (snapshot) => {
+      await mkdir3(path4.dirname(cacheFile), { recursive: true });
+      const temporary = `${cacheFile}.${process.pid}.tmp`;
+      await writeFile(temporary, JSON.stringify(snapshot));
+      await rename2(temporary, cacheFile);
+    }).catch(() => {
+      return;
+    });
+  return framework;
+}
+function frameworkTraceKey() {
+  const startEntry = frameworkStartEntry();
+  const packages = [...runtimeDependencies, ...frameworkRuntimeSpecifiers()].map((specifier) => {
+    const file = resolveEdge(specifier, startEntry);
+    return file ? `${file}\x00${statSync(file).mtimeMs}` : specifier;
+  });
+  return createHash2("sha256").update(JSON.stringify([frameworkFingerprint(), startEntry, packages])).digest("hex").slice(0, 16);
+}
+async function traceFramework(config) {
+  const tracer = createTracer(config);
+  const startEntry = frameworkStartEntry();
+  await tracer.add([
+    { file: startEntry, app: false },
+    ...frameworkRuntimeSpecifiers().flatMap((specifier) => {
+      const file = resolveEdge(specifier, startEntry);
+      return file ? [{ file, app: false }] : [];
+    })
+  ]);
+  return tracer.snapshot();
+}
+async function writeStandalone(config, framework = startStandalone(config)) {
+  const outPath = config.outPath;
+  const cache = cacheRoot2(outPath);
+  const index = readBuildIndex(outPath);
+  const manifestFile = buildManifestFile(outPath);
+  const manifest = JSON.parse(await readFile3(manifestFile, "utf8"));
+  const startEntry = frameworkStartEntry();
+  const snapshot = await framework;
+  const copier = createCopier(outPath);
+  const rewrittenFramework = new Map(snapshot.rewritten);
+  for (const [dest, source] of snapshot.files)
+    copier.copy(dest, source, rewrittenFramework.get(dest));
+  const tracer = createTracer(config, snapshot, (dest) => copier.copy(dest, tracer.trace.files.get(dest), tracer.trace.rewritten.get(dest)));
+  const { trace, place } = tracer;
+  await tracer.add([
+    ...Object.values(index.modules),
+    ...index.dependencies ?? [],
+    index.nextConfig,
+    index.instrumentation?.file,
+    index.instrumentation?.edge,
+    ...Object.values(index.compat?.cacheHandlers ?? {}),
+    ...Object.values(index.fonts ?? {}).flatMap((font) => font.files),
+    manifest.proxyModule,
+    ...(manifest.actions ?? []).map((action) => action.modulePath)
+  ].flatMap((artifact) => artifact ? [{ file: path4.resolve(outPath, artifact), app: true }] : []));
+  addAppFiles(config, index, trace);
+  tracer.flush();
+  await copier.settle();
+  const cachePrefix = `${toPosixPath(path4.relative(outPath, cache))}/`;
+  const relocate = (value) => {
+    if (typeof value === "string")
+      return value.startsWith(cachePrefix) ? `server/${value.slice(cachePrefix.length)}` : value;
+    if (Array.isArray(value))
+      return value.map(relocate);
+    if (value && typeof value === "object")
+      return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, relocate(item)]));
+    return value;
+  };
+  const indexFile = buildIndexFile(outPath);
+  await writeFile(indexFile, JSON.stringify(relocate(JSON.parse(await readFile3(indexFile, "utf8")))));
+  const shippedManifest = relocate(JSON.parse(await readFile3(manifestFile, "utf8")));
+  for (const route of shippedManifest.routes) {
+    if (route.sourceFiles)
+      route.sourceFiles = route.sourceFiles.filter((file) => !file.startsWith("../"));
+  }
+  await writeFile(manifestFile, `${JSON.stringify(shippedManifest, null, 2)}
+`);
+  await writeFile(path4.join(outPath, "server", "entry.js"), `export * from ${JSON.stringify(relativeSpecifier("server", place(startEntry)))}
+`);
+  await writeFile(path4.join(outPath, "package.json"), `{ "type": "module" }
+`);
+  const origins = Object.fromEntries([...trace.files].filter(([dest]) => dest.startsWith("node_modules/")));
+  const originsFile = standaloneOriginsFile(outPath);
+  await mkdir3(path4.dirname(originsFile), { recursive: true });
+  await writeFile(originsFile, JSON.stringify({ release: outPath, origins }));
+}
+function setFile(trace, dest, source) {
+  if (!trace.files.has(dest))
+    trace.fresh.push(dest);
+  trace.files.set(dest, source);
+}
+function createTracer(config, from, onReady) {
+  const outPath = config.outPath;
+  const cache = cacheRoot2(outPath);
+  const trace = {
+    files: new Map(from?.files),
+    fresh: [],
+    rewritten: new Map(from?.rewritten)
+  };
+  const claims = new Map(from?.claims);
+  const place = createPlacer(outPath, cache, claims);
+  const standalones = new Set(from?.standalones);
+  const shipped = (file) => installed(file) || isInside(frameworkRoot2, file) && !isInside(config.root, file);
+  const seen = new Set(from?.seen);
+  const reads = new Map;
+  const prefetch = (file) => {
+    if (scriptFile.test(file) && !reads.has(file))
+      reads.set(file, readFile3(file, "utf8").catch(() => {
+        return;
+      }));
+  };
+  const queue = [];
+  const enqueue = (file, app) => {
+    if (seen.has(`${app}\x00${file}`))
+      return;
+    queue.push({ file, app });
+    prefetch(file);
+  };
+  const flush = () => {
+    for (const dest of trace.fresh.splice(0))
+      onReady?.(dest);
+  };
+  const run = async (items) => {
+    for (const item of items)
+      enqueue(item.file, item.app);
+    for (let item = queue.shift();item; item = queue.shift(), flush()) {
+      const { file, app } = item;
+      if (seen.has(`${app}\x00${file}`))
+        continue;
+      seen.add(`${app}\x00${file}`);
+      const nested = enclosingStandalone(file, outPath);
+      if (nested) {
+        if (!standalones.has(nested)) {
+          standalones.add(nested);
+          addTree(nested, path4.posix.dirname(path4.posix.dirname(place(path4.join(nested, "server", "entry.js")))), trace);
+        }
+        continue;
+      }
+      const dest = place(file);
+      setFile(trace, dest, file);
+      if (!isInside(outPath, file) && !isInside(cache, file))
+        addPackageFiles(file, trace, place);
+      if (!scriptFile.test(file))
+        continue;
+      const release = isInside(outPath, file) || isInside(cache, file);
+      const framework = !release && isInside(frameworkRoot2, file) && !installedIn(frameworkRoot2, file);
+      prefetch(file);
+      const source = await reads.get(file);
+      if (source === undefined)
+        continue;
+      const edits = new Map;
+      for (const edge of scanEdges(file, source)) {
+        if (edge.url) {
+          const target2 = urlTarget(edge.specifier, file);
+          if (!target2)
+            continue;
+          const appFile = release && !isInside(outPath, target2) && !isInside(cache, target2) && !shipped(target2);
+          if (appFile && scriptFile.test(target2))
+            continue;
+          if (!statSync(target2, { throwIfNoEntry: false })?.isFile())
+            continue;
+          const at = appFile ? toPosixPath(path4.join("server", "assets", path4.relative(config.workspaceRoot, target2))) : place(target2);
+          if (appFile)
+            setFile(trace, at, target2);
+          else
+            enqueue(target2, release);
+          if (release) {
+            const relative = relativeSpecifier(path4.dirname(dest), at);
+            if (relative !== edge.specifier)
+              edits.set(edge.specifier, relative);
+          }
+          continue;
+        }
+        const bare = isPackageSpecifier(edge.specifier);
+        const name = bare ? packageName(edge.specifier) : undefined;
+        if (bare && !name && !edge.specifier.startsWith("#"))
+          continue;
+        if (name && framework && !app && (edge.require || !runtimeDependencies.has(name)))
+          continue;
+        const target = resolveEdge(edge.specifier, file, edge.require);
+        if (!target)
+          continue;
+        if (edge.dynamic && framework && buildOnlyModule.test(moduleName(target)))
+          continue;
+        enqueue(target, release);
+        for (const counterpart of frameworkCounterparts(target))
+          enqueue(counterpart, release);
+        if (release || name && !place(target).startsWith(`node_modules/${name}/`)) {
+          const relative = relativeSpecifier(path4.dirname(dest), place(target));
+          if (relative !== edge.specifier)
+            edits.set(edge.specifier, relative);
+        }
+      }
+      if (edits.size > 0)
+        trace.rewritten.set(dest, rewriteSpecifiers(file, source, edits));
+    }
+    flush();
+  };
+  const snapshot = () => ({
+    files: [...trace.files],
+    rewritten: [...trace.rewritten],
+    seen: [...seen],
+    claims: [...claims],
+    standalones: [...standalones]
+  });
+  return { trace, place, add: run, snapshot, flush };
+}
+var prunedDirNames = [
+  "node_modules",
+  ".git",
+  ".next",
+  ".pnext",
+  ".turbo",
+  ".cache",
+  ".vercel",
+  ".tmp"
+];
+var standaloneEntries = new Set(["server", "static", "node_modules", "package.json"]);
+function addAppFiles(config, index, trace) {
+  const { keep = [], exclude = [] } = config.adapter ?? {};
+  const named = (entries, name) => entries.some((entry) => name === entry || entry.startsWith(".") && name.endsWith(entry));
+  for (const dest of trace.files.keys()) {
+    const segments = dest.split("/");
+    if (dest.startsWith("node_modules/") && segments.some((name) => named(exclude, name)))
+      trace.files.delete(dest);
+  }
+  if (keep.length === 0)
+    return;
+  const compiled = compiledSources(config, index);
+  const outTop = path4.relative(config.root, config.outRootPath).split(path4.sep)[0];
+  const visit = (dir, kept) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      const file = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const pruned = prunedDirNames.includes(entry.name) && !named(keep, entry.name);
+        if (pruned || dir === config.root && entry.name === outTop)
+          continue;
+        visit(file, kept || named(keep, entry.name));
+        continue;
+      }
+      if (!entry.isFile() || compiled.has(file) && !named(keep, entry.name))
+        continue;
+      const env = entry.name.startsWith(".env");
+      if (env ? !keep.includes(entry.name) : !kept && !named(keep, entry.name))
+        continue;
+      const relative = toPosixPath(path4.relative(config.root, file));
+      if (!standaloneEntries.has(relative.split("/")[0]))
+        setFile(trace, relative, file);
+    }
+  };
+  visit(config.root, false);
+}
+function compiledSources(config, index) {
+  flushDevModuleCaches();
+  const graph = compiledSourceGraph(config.outPath, config.workspaceRoot);
+  const queue = Object.keys(index.modules).map((key) => releaseSourceFile(key.slice(key.indexOf(":", key.indexOf(":") + 1) + 1), config.root, config.workspaceRoot));
+  if (index.proxy)
+    queue.push(path4.resolve(config.root, index.proxy.file));
+  for (const name of readdirSync2(config.root))
+    if (/^(?:pnext|next|instrumentation)\.config\.|^instrumentation\./.test(name) && scriptFile.test(name))
+      queue.push(path4.join(config.root, name));
+  const compiled = new Set;
+  for (const file of queue) {
+    if (compiled.has(file))
+      continue;
+    compiled.add(file);
+    queue.push(...graph.get(file) ?? []);
+  }
+  for (const css of index.globalCss)
+    compiled.add(path4.resolve(config.root, css));
+  return compiled;
+}
+function createPlacer(outPath, cache, claims = new Map) {
+  const packageDir = (root, name) => {
+    const owner = claims.get(name);
+    if (owner === undefined)
+      claims.set(name, root);
+    if (owner === undefined || owner === root)
+      return `node_modules/${name}`;
+    const key = createHash2("sha256").update(root).digest("hex").slice(0, 12);
+    return `node_modules/.pnext/${key}/node_modules/${name}`;
+  };
+  return (file) => {
+    if (isInside(cache, file))
+      return toPosixPath(path4.join("server", path4.relative(cache, file)));
+    if (isInside(outPath, file))
+      return toPosixPath(path4.relative(outPath, file));
+    const framework = !installed(frameworkRoot2) && isInside(frameworkRoot2, file) && !installedIn(frameworkRoot2, file);
+    if (framework) {
+      const dir = packageDir(frameworkRoot2, frameworkPackage.name);
+      return `${dir}/${toPosixPath(path4.relative(frameworkRoot2, file))}`;
+    }
+    const posix = toPosixPath(file);
+    const at = posix.lastIndexOf("/node_modules/");
+    if (at !== -1) {
+      const rest = posix.slice(at + "/node_modules/".length).split("/");
+      const length = rest[0].startsWith("@") ? 2 : 1;
+      const name2 = rest.slice(0, length).join("/");
+      const root2 = `${posix.slice(0, at)}/node_modules/${name2}`;
+      return [packageDir(root2, name2), ...rest.slice(length)].join("/");
+    }
+    const root = packageRoot(path4.dirname(file));
+    const name = root && readPackageName(root);
+    if (!root || !name)
+      throw new Error(`pnext build: cannot place ${file} in the standalone output`);
+    return `${packageDir(root, name)}/${toPosixPath(path4.relative(root, file))}`;
+  };
+}
+var standaloneDirs = new Map;
+function enclosingStandalone(file, outPath) {
+  const dir = path4.dirname(file);
+  if (dir === path4.dirname(dir))
+    return;
+  if (standaloneDirs.has(dir))
+    return standaloneDirs.get(dir);
+  const own = dir !== outPath && existsSync4(path4.join(dir, "server", "build-index.json")) && existsSync4(path4.join(dir, "server", "entry.js"));
+  const found = own ? dir : enclosingStandalone(dir, outPath);
+  standaloneDirs.set(dir, found);
+  return found;
+}
+function addTree(root, dest, trace) {
+  const visit = (dir, seen) => {
+    const real = realpathSync2(dir);
+    if (seen.has(real))
+      return;
+    seen.add(real);
+    for (const name of readdirSync2(dir)) {
+      const file = path4.join(dir, name);
+      const stat = statSync(file, { throwIfNoEntry: false });
+      if (stat?.isDirectory())
+        visit(file, seen);
+      else if (stat?.isFile())
+        setFile(trace, `${dest}/${toPosixPath(path4.relative(root, file))}`, realpathSync2(file));
+    }
+  };
+  visit(root, new Set);
+}
+function installed(file) {
+  return toPosixPath(file).includes("/node_modules/");
+}
+function installedIn(root, file) {
+  return path4.relative(root, file).split(path4.sep).includes("node_modules");
+}
+var transpilers = new Map;
+function scanEdges(file, source) {
+  const ext = path4.extname(file);
+  const loader = ext === ".tsx" || ext === ".jsx" ? "tsx" : /\.[cm]?ts$/.test(ext) ? "ts" : "js";
+  let transpiler = transpilers.get(loader);
+  if (!transpiler) {
+    transpiler = new Bun.Transpiler({
+      loader,
+      tsconfig: { compilerOptions: { jsx: "react-jsx", jsxImportSource: "preact" } }
+    });
+    transpilers.set(loader, transpiler);
+  }
+  let imports;
+  try {
+    imports = transpiler.scanImports(source);
+  } catch {
+    return [];
+  }
+  const edges = imports.map((entry) => ({
+    specifier: entry.path,
+    dynamic: entry.kind === "dynamic-import",
+    require: entry.kind === "require-call"
+  }));
+  const refs = importMetaRefs(file, source);
+  for (const url of refs.urls)
+    edges.push({ specifier: url.specifier, dynamic: false, url: true });
+  for (const ref of refs.resolves)
+    edges.push({ specifier: ref.specifier, dynamic: false });
+  if (loader === "tsx")
+    edges.push({ specifier: "preact/jsx-runtime", dynamic: false }, { specifier: "preact/jsx-dev-runtime", dynamic: false });
+  return edges;
+}
+var resolved = new Map;
+function resolveEdge(specifier, from, require2 = false) {
+  if (/^(?:node:|bun:|data:|https?:)/.test(specifier) || specifier === "bun")
+    return;
+  const bare = require2 ? specifier : splitResourceQuery(specifier).path;
+  if (builtins.has(bare))
+    return;
+  const dir = path4.dirname(from);
+  const key = `${dir}\x00${bare}`;
+  if (resolved.has(key))
+    return resolved.get(key);
+  let target;
   try {
-    const pkg = readFileSync3(path4.join(frameworkRoot2, "package.json"), "utf8");
-    return JSON.parse(pkg).version ?? "0";
+    const request = bare.startsWith("file:") ? fileURLToPath2(bare) : bare;
+    target = realpathSync2(Bun.resolveSync(request, dir));
+    if (!statSync(target).isFile())
+      target = undefined;
   } catch {
-    return "0";
+    target = undefined;
   }
+  resolved.set(key, target);
+  return target;
 }
-function serverEntryDir(outPath) {
-  const generation = frameworkFingerprint(path4.join(outPath, "cache", "server"));
-  return path4.join(outPath, "server", `bundle-${frameworkVersion()}-${generation}`);
+function frameworkCounterparts(file) {
+  const counterpart = prebundledFile(file);
+  if (counterpart === file)
+    return [];
+  return [counterpart, path4.join(frameworkRoot2, PREBUNDLE_STAMP)];
 }
-async function emitServerEntry(outPath) {
-  const start = await Bun.file(path4.join(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve", "..", "start.ts")).text();
-  const names = new Bun.Transpiler({ loader: "ts" }).scan(start).exports;
-  const dir = serverEntryDir(outPath);
-  const target = readPrebundleStamp(frameworkRoot2, frameworkFingerprint()) ? "../dist/server/cli/start.js" : "./cli/start.ts";
-  await mkdir3(dir, { recursive: true });
-  await writeFile2(path4.join(dir, "entry.js"), `const pnext = await import(new URL('${target}', import.meta.resolve('@wular/pnext')).href)
-` + `export const { ${names.join(", ")} } = pnext
-`);
+function moduleName(file) {
+  const base = path4.basename(file, path4.extname(file));
+  const chunk = path4.basename(path4.dirname(file)) === "_chunks";
+  return chunk && isInside(path4.join(frameworkRoot2, "dist"), file) ? base.replace(/-[a-z0-9]{8}$/, "") : base;
+}
+function packageName(specifier) {
+  if (specifier.startsWith("#"))
+    return;
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  return name && !builtins.has(name) ? name : undefined;
+}
+function addPackageFiles(file, trace, place) {
+  const inStore = installed(file);
+  for (let dir = path4.dirname(file);dir !== path4.dirname(dir); dir = path4.dirname(dir)) {
+    const manifest = path4.join(dir, "package.json");
+    const found = existsSync4(manifest);
+    if (found)
+      setFile(trace, place(manifest), manifest);
+    if (found && dir === frameworkRoot2) {
+      for (const name of ["tsconfig.json", path4.join("config", "ts", "react.json")]) {
+        const extra = path4.join(dir, name);
+        if (existsSync4(extra))
+          setFile(trace, place(extra), extra);
+      }
+    }
+    const parent = path4.basename(path4.dirname(dir));
+    const packageTop = parent === "node_modules" || parent.startsWith("@") && path4.basename(path4.dirname(path4.dirname(dir))) === "node_modules";
+    if (inStore ? packageTop : found && readPackageName(dir))
+      return;
+  }
+}
+function packageRoot(dir) {
+  for (;dir !== path4.dirname(dir); dir = path4.dirname(dir)) {
+    if (existsSync4(path4.join(dir, "package.json")))
+      return dir;
+  }
+  return;
+}
+function readPackageName(dir) {
+  try {
+    return JSON.parse(readFileSync2(path4.join(dir, "package.json"), "utf8")).name;
+  } catch {
+    return;
+  }
+}
+function relativeSpecifier(fromDir, to) {
+  const relative = toPosixPath(path4.relative(fromDir, to));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function rewriteSpecifiers(file, source, edits) {
+  const refs = importMetaRefs(file, source);
+  const spans = [...moduleSpecifierEdges(source, file), ...refs.urls, ...refs.resolves];
+  const changes = spans.flatMap((span) => {
+    const value = edits.get(span.specifier);
+    return value === undefined ? [] : [{ start: span.start, end: span.end, value: JSON.stringify(value) }];
+  });
+  changes.sort((a, b) => a.start - b.start);
+  return changes.length > 0 ? spliceSource(source, changes) : source;
+}
+function urlTarget(specifier, from) {
+  try {
+    const url = new URL(specifier, pathToFileURL(from));
+    return url.protocol === "file:" ? fileURLToPath2(url) : undefined;
+  } catch {
+    return;
+  }
+}
+function isPackageSpecifier(specifier) {
+  if (specifier === "." || specifier === "..")
+    return false;
+  if (specifier.startsWith("./") || specifier.startsWith("../"))
+    return false;
+  return !path4.isAbsolute(specifier) && !specifier.startsWith("file:");
+}
+function createCopier(outPath) {
+  const dirs = new Map;
+  const copied = new Set;
+  const pending = [];
+  const ensureDir = (dir) => {
+    let made = dirs.get(dir);
+    if (!made) {
+      made = mkdir3(dir, { recursive: true });
+      dirs.set(dir, made);
+    }
+    return made;
+  };
+  const copy = (dest, source, contents) => {
+    if (copied.has(dest))
+      return;
+    copied.add(dest);
+    const target = path4.join(outPath, dest);
+    pending.push(ensureDir(path4.dirname(target)).then(async () => {
+      if (contents !== undefined) {
+        if (target !== source)
+          await rm2(target, { force: true });
+        return writeFile(target, contents);
+      }
+      if (target !== source)
+        await copyFile2(source, target, constants2.COPYFILE_FICLONE);
+    }));
+  };
+  return { copy, settle: () => Promise.all(pending) };
+}
+function isInside(root, file) {
+  return file === root || file.startsWith(`${root}${path4.sep}`);
 }
 
 // src/cli/build.ts
@@ -1765,9 +1555,10 @@ async function runBuild(root, options, lifecycle) {
   const warmMode = options.adapter === "vercel" ? "full" : "compile";
   const warm = startWarmChild(config, warmMode);
   lifecycle.warm = warm;
+  const standalone = startStandalone(config);
   const publicFiles = await log.step("prepare output directory", async () => {
-    await ensureEmptyDir(config.outPath, [devOutSegment, "pnext-pages-compat"]);
-    return copyPublicDir(config.publicPath, path5.join(config.outPath, "public"));
+    await ensureEmptyDir(config.outRootPath, [devOutSegment, "pnext-pages-compat"]);
+    return copyPublicDir(config.publicPath, path5.join(config.outPath, "static"));
   });
   const documentCss = Promise.resolve().then(() => buildGlobalCss(config, { verbose })).then(() => buildNotFoundCss(config, { verbose }));
   documentCss.catch(() => {
@@ -1851,7 +1642,7 @@ async function runBuild(root, options, lifecycle) {
   const clientBundles = log.step(`client bundles (${clientRoutes.length} route${clientRoutes.length === 1 ? "" : "s"})`, () => buildClientEntries({
     config,
     routes: clientRoutes,
-    outDir: path5.join(config.outPath, "public", "assets"),
+    outDir: path5.join(config.outPath, "static", "assets"),
     verbose,
     hasServerActions: actionSources.length > 0,
     pipeline: clientSources
@@ -1879,7 +1670,7 @@ async function runBuild(root, options, lifecycle) {
   await clientBundles;
   const proxyModule = await proxyBuild;
   await partytownLib;
-  await emitStaticClientChunks(config, path5.join(config.outPath, "public", "assets"));
+  await emitStaticClientChunks(config, path5.join(config.outPath, "static", "assets"));
   if (verbose) {
     const sources = sourceCacheStats();
     log.log(`source cache \u2014 ${sources.reads} reads, ${sources.hits} shared, ${sources.files} files \xB7 parses ${JSON.stringify(scanFactsStats())}`);
@@ -2054,7 +1845,7 @@ async function runBuild(root, options, lifecycle) {
             html: rendered.value.html,
             status: rendered.value.status
           });
-          const relative = toPosixPath(path5.relative(path5.join(config.outPath, "public"), file));
+          const relative = toPosixPath(path5.relative(path5.join(config.outPath, "static"), file));
           const revalidateSeconds = combineRevalidate(segmentConfig?.revalidate, rendered.revalidateSeconds);
           const defaultExpireTime = buildCompat().defaultExpireTimeSeconds();
           const effectiveCacheLife = cacheLife ?? (rendered.expireSeconds !== undefined || rendered.staleSeconds !== undefined ? {
@@ -2116,8 +1907,8 @@ Route (app)`);
   await emitProxyServerArtifacts(config, proxyModule);
   if (config.compat?.next) {
     const sourceApp = path5.join(config.appPath, "..", "source-app");
-    const layoutRoot = existsSync4(sourceApp) ? sourceApp : config.appPath;
-    const hasTopLevelRootLayout = ["tsx", "ts", "jsx", "js"].some((ext) => existsSync4(path5.join(layoutRoot, `layout.${ext}`)));
+    const layoutRoot = existsSync5(sourceApp) ? sourceApp : config.appPath;
+    const hasTopLevelRootLayout = ["tsx", "ts", "jsx", "js"].some((ext) => existsSync5(path5.join(layoutRoot, `layout.${ext}`)));
     const pseudos = hasTopLevelRootLayout ? ["_not-found.html", "_global-error.html"] : ["_not-found.html"];
     for (const pseudo of pseudos) {
       if (!(pseudo in staticFiles)) {
@@ -2147,21 +1938,19 @@ Route (app)`);
   };
   await writeBuildManifest(config.outPath, manifest);
   log.log(`wrote manifest.json (${routes.length} route${routes.length === 1 ? "" : "s"})`);
-  await log.step("server entry", () => emitServerEntry(config.outPath));
   for (const hook of getBuildExtensions().completeHooks) {
     await hook({ config, manifest, log });
   }
-  if (options.adapter === "vercel")
-    await log.step("vercel adapter output", () => writeVercelOutput(config, manifest, { verbose, warm }));
-  else {
-    await log.step("warm module cache", () => warm.finish(log, undefined, {
-      globalCss: globalCssSources(config),
-      clientReferences: [...compiledClientReferenceFiles()]
-    }));
-  }
-  if (!existsSync4(buildIndexFile(config.outPath))) {
+  await log.step("warm module cache", () => warm.finish(log, undefined, {
+    globalCss: globalCssSources(config),
+    clientReferences: [...compiledClientReferenceFiles()]
+  }));
+  if (!existsSync5(buildIndexFile(config.outPath))) {
     throw new Error("pnext build: the server compile did not complete (see the error above).");
   }
+  await log.step("standalone output", () => writeStandalone(config, standalone));
+  if (options.adapter === "vercel")
+    await log.step("vercel adapter output", () => writeVercelOutput(config, manifest, { verbose }));
   throwIfModuleGraphFailed();
   const buildDurationMs = performance.now() - startedAt;
   const phases = await settleBuildParallelPhases();
@@ -2207,7 +1996,7 @@ async function logInterceptionPrerenders(config, routes) {
   return prerenders;
 }
 function routeFileExportsStaticParams(file) {
-  if (!existsSync4(file))
+  if (!existsSync5(file))
     return false;
   const source = readTextSync(file);
   return /\bexport\s+(?:async\s+)?function\s+generateStaticParams\b/.test(source) || /\bexport\s+const\s+generateStaticParams\b/.test(source);
@@ -2226,22 +2015,24 @@ function interceptionDisplayRoute(route, filled) {
 }
 async function writeBuildManifest(outPath, manifest) {
   assertManifestServerArtifacts(outPath, manifest);
-  const file = path5.join(outPath, "manifest.json");
-  const temporary = path5.join(outPath, `.manifest-${process.pid}.tmp`);
-  await writeFile3(temporary, serializeBuildManifest(manifest));
-  await rename2(temporary, file);
+  const file = buildManifestFile(outPath);
+  const temporary = `${file}.${process.pid}.tmp`;
+  await mkdir4(path5.dirname(file), { recursive: true });
+  await writeFile2(temporary, serializeBuildManifest(manifest));
+  await rename3(temporary, file);
 }
 function assertManifestServerArtifacts(outPath, manifest) {
   const artifacts = [
     ...manifest.proxyModule ? [manifest.proxyModule] : [],
     ...manifest.actions?.map((action) => action.modulePath) ?? []
   ];
+  const outRoot = path5.dirname(outPath);
   for (const artifact of artifacts) {
     const file = path5.resolve(outPath, artifact);
-    if (file !== outPath && !file.startsWith(`${outPath}${path5.sep}`)) {
+    if (!file.startsWith(`${outRoot}${path5.sep}`)) {
       throw new Error(`Build manifest server artifact escapes output directory: ${artifact}`);
     }
-    if (!existsSync4(file)) {
+    if (!existsSync5(file)) {
       throw new Error(`Build manifest server artifact is missing: ${artifact}`);
     }
   }
@@ -2333,7 +2124,7 @@ async function renderShellWithCacheMeta(config, route, render) {
 var DYNAMIC_EXPIRE_SECONDS = 300;
 function routeDeclaresShortLivedCache(route) {
   for (const file of route.sourceFiles) {
-    if (!existsSync4(file))
+    if (!existsSync5(file))
       continue;
     const source = readTextSync(file);
     for (const literal of source.matchAll(/cacheLife\s*\(\s*\{[^}]*\bexpire\s*:\s*([^,}]+)/gs)) {
@@ -2515,7 +2306,7 @@ async function emitConcreteNextPageArtifacts(config, route, routePath, rendered)
 function staleTimeFromRouteSources(route) {
   let found;
   for (const file of route.sourceFiles) {
-    if (!existsSync4(file))
+    if (!existsSync5(file))
       continue;
     const source = readTextSync(file);
     for (const literal of source.matchAll(/cacheLife\s*\(\s*\{[^}]*\bstale\s*:\s*([^,}]+)/gs)) {
@@ -2533,7 +2324,7 @@ function staleTimeFromRouteSources(route) {
 }
 function readTextSync(file) {
   try {
-    return existsSync4(file) && statSync2(file).isFile() ? readFileSync4(file, "utf8") : "";
+    return existsSync5(file) && statSync2(file).isFile() ? readFileSync3(file, "utf8") : "";
   } catch {
     return "";
   }
@@ -2791,7 +2582,7 @@ function routeSourcesUseHttpFallback(root, route) {
   for (const file of route.sourceFiles) {
     if (!file.startsWith(root) || file.includes(`${path5.sep}node_modules${path5.sep}`))
       continue;
-    if (!existsSync4(file))
+    if (!existsSync5(file))
       continue;
     const source = readTextSync(file);
     if (/\b(?:notFound|forbidden|unauthorized)\s*\(\s*\)/.test(source))
@@ -2803,7 +2594,7 @@ function routeSourcesUseRequestApi(root, route) {
   for (const file of route.sourceFiles) {
     if (!file.startsWith(root) || file.includes(`${path5.sep}node_modules${path5.sep}`))
       continue;
-    if (!existsSync4(file))
+    if (!existsSync5(file))
       continue;
     const source = readTextSync(file).replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
     if (/\b(?:connection|cookies|headers|draftMode)\s*\(\s*\)/.test(source))
@@ -2813,7 +2604,7 @@ function routeSourcesUseRequestApi(root, route) {
 }
 function routeSourcesHaveDynamicHead(route) {
   for (const file of route.sourceFiles) {
-    if (!existsSync4(file))
+    if (!existsSync5(file))
       continue;
     const source = readTextSync(file);
     const match = /export\s+(?:async\s+)?function\s+(?:generateMetadata|generateViewport)\s*\([^)]*\)\s*(?::[^{]+)?\{/.exec(source);
@@ -2890,11 +2681,11 @@ async function renderNotFoundDocuments({
   };
   await documentCss;
   if (await shouldBuildGlobalNotFound(config)) {
-    await log.step("global not-found", async () => writeText(path5.join(config.outPath, "public", "404.html"), await render()));
+    await log.step("global not-found", async () => writeText(path5.join(config.outPath, "static", "404.html"), await render()));
   }
   if (!config.compat?.next)
     return;
-  if (existsSync4(path5.join(config.outPath, "public", "404.html")))
+  if (existsSync5(path5.join(config.outPath, "static", "404.html")))
     return;
   return defaultNotFoundDocument();
 }
@@ -2902,7 +2693,7 @@ async function shouldBuildGlobalNotFound(config) {
   const file = ["tsx", "ts", "jsx", "js"].flatMap((ext) => [
     path5.join(config.appPath, `global-not-found.${ext}`),
     path5.join(config.appPath, `not-found.${ext}`)
-  ]).find((candidate) => existsSync4(candidate));
+  ]).find((candidate) => existsSync5(candidate));
   if (!file)
     return false;
   return !/\bexport\s+const\s+dynamic\s*=\s*['"]force-dynamic['"]/.test(await readText(file));
@@ -2911,21 +2702,21 @@ async function emitProxyServerArtifacts(config, proxyModule) {
   if (!config.compat?.next || !proxyModule)
     return;
   const compiled = path5.resolve(config.outPath, proxyModule);
-  if (!existsSync4(compiled))
+  if (!existsSync5(compiled))
     return;
   const serverDir = path5.join(config.root, ".next", "server");
   await mkdir4(serverDir, { recursive: true });
   const middlewareFile = path5.join(serverDir, "middleware.js");
-  await copyFile2(compiled, middlewareFile);
-  const files = ["middleware.js"].filter((name) => existsSync4(path5.join(serverDir, name)));
-  await writeFile3(path5.join(serverDir, "middleware.js.nft.json"), `${JSON.stringify({ version: 1, files })}
+  await copyFile3(compiled, middlewareFile);
+  const files = ["middleware.js"].filter((name) => existsSync5(path5.join(serverDir, name)));
+  await writeFile2(path5.join(serverDir, "middleware.js.nft.json"), `${JSON.stringify({ version: 1, files })}
 `);
 }
 async function emitNextNotFoundArtifacts(config, fallback404) {
   if (!config.compat?.next)
     return;
-  const source = path5.join(config.outPath, "public", "404.html");
-  const html = existsSync4(source) ? readFileSync4(source, "utf8") : fallback404;
+  const source = path5.join(config.outPath, "static", "404.html");
+  const html = existsSync5(source) ? readFileSync3(source, "utf8") : fallback404;
   if (html === undefined)
     return;
   const serverDir = path5.join(config.root, ".next", "server");
@@ -2933,21 +2724,21 @@ async function emitNextNotFoundArtifacts(config, fallback404) {
   const notFoundDir = path5.join(serverDir, "app", "_not-found");
   await mkdir4(pagesDir, { recursive: true });
   await mkdir4(notFoundDir, { recursive: true });
-  await writeFile3(path5.join(pagesDir, "404.html"), html);
-  await writeFile3(path5.join(serverDir, "app", "_not-found.html"), html);
-  await writeFile3(path5.join(serverDir, "app", "_not-found.rsc"), html);
+  await writeFile2(path5.join(pagesDir, "404.html"), html);
+  await writeFile2(path5.join(serverDir, "app", "_not-found.html"), html);
+  await writeFile2(path5.join(serverDir, "app", "_not-found.rsc"), html);
   const pagesManifestFile = path5.join(serverDir, "pages-manifest.json");
   let pagesManifest = {};
   try {
-    pagesManifest = JSON.parse(readFileSync4(pagesManifestFile, "utf8"));
+    pagesManifest = JSON.parse(readFileSync3(pagesManifestFile, "utf8"));
   } catch {}
   pagesManifest["/404"] = "pages/404.html";
-  await writeFile3(pagesManifestFile, `${JSON.stringify(pagesManifest, null, 2)}
+  await writeFile2(pagesManifestFile, `${JSON.stringify(pagesManifest, null, 2)}
 `);
   const clientReferenceManifest = "page_client-reference-manifest.js";
-  await writeFile3(path5.join(notFoundDir, clientReferenceManifest), `self.__RSC_MANIFEST={}
+  await writeFile2(path5.join(notFoundDir, clientReferenceManifest), `self.__RSC_MANIFEST={}
 `);
-  await writeFile3(path5.join(notFoundDir, "page.js.nft.json"), `${JSON.stringify({ version: 1, files: [clientReferenceManifest] }, null, 2)}
+  await writeFile2(path5.join(notFoundDir, "page.js.nft.json"), `${JSON.stringify({ version: 1, files: [clientReferenceManifest] }, null, 2)}
 `);
 }
 async function collectStaticModuleMetadata(config, routes) {
@@ -2959,7 +2750,7 @@ async function collectStaticModuleMetadata(config, routes) {
     if (route.kind !== "page")
       continue;
     for (const file of findLayouts(config.appPath, route.file)) {
-      if (existsSync4(file))
+      if (existsSync5(file))
         files.add(file);
     }
     files.add(route.file);
@@ -2994,8 +2785,8 @@ async function collectStaticRouteMetadata(config, routes, staticMetadataFiles) {
     for (const params of paramSets) {
       const routePath = fillRoutePath(route.route, params);
       const base = route.interception ? staticMetadataForRouteFromFiles(staticMetadataFiles, config.appPath, route.file, routePath) : staticMetadataForPathFromFiles(staticMetadataFiles, routePath);
-      const resolved = await withDynamicMetadataRoutes(base, config.appPath, route.file, routePath, (file) => importMetadataModule(config, file));
-      metadata[staticRouteMetadataKey(routePath)] = resolved;
+      const resolved2 = await withDynamicMetadataRoutes(base, config.appPath, route.file, routePath, (file) => importMetadataModule(config, file));
+      metadata[staticRouteMetadataKey(routePath)] = resolved2;
     }
   }
   return metadata;
@@ -3052,10 +2843,10 @@ async function buildStaticRouteHandler(config, route, options = {}) {
     const body = await settleBeforeNextTask(response.clone().arrayBuffer());
     if (!body)
       continue;
-    const relative = toPosixPath(path5.relative(path5.join(config.outPath, "public"), file));
+    const relative = toPosixPath(path5.relative(path5.join(config.outPath, "static"), file));
     if (!skipPhysicalWrite) {
       await mkdir4(path5.dirname(file), { recursive: true });
-      await writeFile3(file, new Uint8Array(body));
+      await writeFile2(file, new Uint8Array(body));
     }
     const revalidateSeconds = combineRevalidate(route.segmentConfig?.revalidate, rendered.revalidateSeconds);
     staticFiles[relative] = {
@@ -3087,7 +2878,7 @@ function settleBeforeNextTask(value) {
   });
 }
 async function handlerHasEntirelyCachedIo(route) {
-  if (route.synthetic || !existsSync4(route.file))
+  if (route.synthetic || !existsSync5(route.file))
     return false;
   const source = await readText(route.file);
   if (route.metadataRoute && metadataDefaultUsesCache(source))
@@ -3128,7 +2919,7 @@ function metadataDefaultUsesCache(source) {
   return /\bexport\s+default\s+(?:async\s+)?function\b[^(]*\([^)]*\)\s*(?::[^{]*)?\{\s*(?:\/\/[^\n]*\n\s*|\/\*[\s\S]*?\*\/\s*)*['"]use cache['"]/.test(source);
 }
 async function usesUnstableCache(route) {
-  if (route.synthetic || !existsSync4(route.file))
+  if (route.synthetic || !existsSync5(route.file))
     return false;
   const source = await readText(route.file);
   const localNames = [];
@@ -3154,7 +2945,7 @@ async function staticHandlerDynamicUsage(route) {
   if (route.segmentConfig?.dynamic === "force-static" || route.segmentConfig?.dynamic === "error") {
     return;
   }
-  if (route.synthetic || !existsSync4(route.file))
+  if (route.synthetic || !existsSync5(route.file))
     return;
   const source = await readText(route.file);
   if (/\b(?:request|req)\.url\b/.test(source))
@@ -3262,8 +3053,8 @@ function routeMetadataImageFiles(appPath, routeFile) {
   let dir = path5.dirname(routeFile);
   const root = path5.resolve(appPath);
   while (dir.startsWith(root)) {
-    if (existsSync4(dir)) {
-      for (const entry of readdirSync2(dir)) {
+    if (existsSync5(dir)) {
+      for (const entry of readdirSync3(dir)) {
         if (/^(opengraph-image|twitter-image)\d*\.(tsx?|jsx?|mjs|png|jpe?g|gif|webp|svg)$/.test(entry)) {
           return true;
         }
@@ -3284,7 +3075,7 @@ async function copyStaticMetadataFiles(config, staticFiles, metadataFiles = disc
       continue;
     }
     await mkdir4(path5.dirname(target), { recursive: true });
-    await copyFile2(metadataFile.file, target);
+    await copyFile3(metadataFile.file, target);
     staticFiles[metadataFile.outputPath] = {
       status: 200,
       headers: [
@@ -3296,7 +3087,7 @@ async function copyStaticMetadataFiles(config, staticFiles, metadataFiles = disc
 }
 function staticHtmlPath(outPath, routePath, flatLayout = false) {
   if (routePath === "/")
-    return path5.join(outPath, "public", "index.html");
+    return path5.join(outPath, "static", "index.html");
   const normalized = routePath.replace(/^\/|\/$/g, "");
   if (flatLayout)
     return safePublicPath(outPath, `${normalized}.html`);
@@ -3360,13 +3151,13 @@ function staticRouteHandlerPath(outPath, routePath) {
   return safePublicPath(outPath, routePath.replace(/^\/+/, "") || "index");
 }
 function staticOutputCollision(outPath, file) {
-  const publicPath = path5.join(outPath, "public");
-  if (existsSync4(file) && statSync2(file).isDirectory()) {
+  const publicPath = path5.join(outPath, "static");
+  if (existsSync5(file) && statSync2(file).isDirectory()) {
     return `${toPosixPath(path5.relative(publicPath, file))} already exists as a directory`;
   }
   let dir = path5.dirname(file);
   while (dir !== publicPath && dir !== path5.dirname(dir)) {
-    if (existsSync4(dir)) {
+    if (existsSync5(dir)) {
       if (!statSync2(dir).isDirectory()) {
         return `${toPosixPath(path5.relative(publicPath, dir))} already exists as a file`;
       }
@@ -3407,8 +3198,8 @@ async function requestApiBailoutReason(route) {
 function ownSourceFiles(route) {
   const frameworkRoot3 = path5.resolve(fileURLToPath3(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/build.ts").href), "..", "..");
   return route.sourceFiles.filter((file) => {
-    const resolved = path5.resolve(file);
-    return !resolved.includes(`${path5.sep}node_modules${path5.sep}`) && !resolved.startsWith(frameworkRoot3 + path5.sep);
+    const resolved2 = path5.resolve(file);
+    return !resolved2.includes(`${path5.sep}node_modules${path5.sep}`) && !resolved2.startsWith(frameworkRoot3 + path5.sep);
   });
 }
 async function schedulesDeferredWork(route) {
@@ -3501,7 +3292,7 @@ function realFilePath(file) {
   }
 }
 function safePublicPath(outPath, ...segments) {
-  const publicPath = path5.join(outPath, "public");
+  const publicPath = path5.join(outPath, "static");
   const file = path5.join(publicPath, ...segments);
   const relative = path5.relative(publicPath, file);
   if (relative.startsWith("..") || path5.isAbsolute(relative)) {
@@ -3519,7 +3310,7 @@ async function copyPartytownLib(config) {
     console.warn("pnext build: experimental.nextScriptWorkers is enabled but no Partytown package was found (@qwik.dev/partytown or @builder.io/partytown); worker scripts will 404 the library until it is installed");
     return;
   }
-  const target = path5.join(config.outPath, "public", "_next", "static", "~partytown");
+  const target = path5.join(config.outPath, "static", "_next", "static", "~partytown");
   await mkdir4(target, { recursive: true });
   await copyPublicDir(libDir, target);
 }
@@ -3529,7 +3320,7 @@ function resolvePartytownLibDir(root) {
     try {
       const pkgJson = requireFromRoot.resolve(`${pkg}/package.json`);
       const libDir = path5.join(path5.dirname(pkgJson), "lib");
-      if (existsSync4(libDir) && statSync2(libDir).isDirectory())
+      if (existsSync5(libDir) && statSync2(libDir).isDirectory())
         return libDir;
     } catch {}
   }
@@ -3540,7 +3331,7 @@ async function copyPublicDir(from, to) {
   for (const relative of files) {
     const target = path5.join(to, relative);
     await mkdir4(path5.dirname(target), { recursive: true });
-    await copyFile2(path5.join(from, relative), target);
+    await copyFile3(path5.join(from, relative), target);
   }
   return files;
 }