@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/build-t9h0hec3.js

@@ -0,0 +1,3550 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  immutableAssetPath,
+  immutableAssetPrefixes,
+  immutableCacheControl
+} from "./index-rcs322t1.js";
+import {
+  buildClientEntries,
+  emitStaticClientChunks,
+  startClientSources
+} from "./index-nyrba2kr.js";
+import {
+  writeTypegen
+} from "./index-wpfhfbs4.js";
+import {
+  handleRouteModule,
+  staticRouteParams
+} from "./index-qpwsgt3a.js";
+import {
+  addClientEntryReason,
+  assertNoServerActionsWithoutCompat,
+  materializeRouteFacts,
+  scanRoutes
+} from "./index-8k7pfejn.js";
+import {
+  compiledSpecifiersManifestSuffix,
+  devServerModuleHref,
+  resetModuleGraphFailure,
+  setEmitCompiledSpecifiersManifest,
+  setReleaseCompile
+} from "./index-1011cscr.js";
+import"./index-n4hxpng2.js";
+import"./index-x3yn4ywm.js";
+import {
+  compiledSourceGraph,
+  flushDevModuleCaches,
+  registerServerRuntime
+} from "./index-vvmmknm1.js";
+import"./index-91x12ykq.js";
+import"./index-tvqkq6e6.js";
+import {
+  clientEntryName,
+  defaultNotFoundDocument,
+  discoverStaticMetadataFiles,
+  metadataRouteHandlerModule,
+  pprShellPath,
+  pprSubShellPath,
+  readModuleMetadata,
+  readModuleViewport,
+  renderFallbackShell,
+  renderGlobalNotFoundResponse,
+  renderPageWithStatus,
+  renderPartialShell,
+  renderSubShell,
+  staticMetadataCacheControl,
+  staticMetadataForPathFromFiles,
+  staticMetadataForRouteFromFiles,
+  staticMetadataOutputFile,
+  staticParamsFor,
+  staticRouteMetadataKey,
+  withDynamicMetadataRoutes
+} from "./index-3tf1xjsp.js";
+import {
+  findLayouts
+} from "./index-jepjvcrf.js";
+import {
+  findProxyFile,
+  proxyExternalLoadTarget,
+  proxyRoutePatterns,
+  validateProxyFiles
+} from "./index-kq8kpzye.js";
+import {
+  serverBundleTargetForRuntime,
+  throwIfModuleGraphFailed
+} from "./index-3xbr4eyv.js";
+import"./index-rn8dyr1f.js";
+import {
+  buildGlobalCss,
+  buildNotFoundCss,
+  buildRouteStylesheets,
+  globalCssSources,
+  prepareRouteCssChunks,
+  warmCssPipeline
+} from "./index-2dv4y4wd.js";
+import {
+  createVerboseLogger
+} from "./index-73z4esab.js";
+import {
+  emittedAssetNames,
+  registerCssRuntime
+} from "./index-y2jr2n72.js";
+import {
+  nextCompatEnabled
+} from "./index-web361b8.js";
+import"./index-knp0s912.js";
+import {
+  frameworkFingerprint
+} from "./index-c0g2wf3z.js";
+import"./index-ye9hmsvf.js";
+import {
+  setRequestRuntime
+} from "./index-z88qv16t.js";
+import {
+  beginSourceScope,
+  endSourceScope,
+  sourceCacheStats
+} from "./index-fp8r0sqs.js";
+import"./index-cjgqs13g.js";
+import"./index-yhxkxghe.js";
+import"./index-fkp000p1.js";
+import {
+  interceptionMarkerLevels
+} from "./index-p77b4kcx.js";
+import {
+  ensureEmptyDir,
+  listFiles,
+  readText,
+  resolveManifest,
+  serializeBuildManifest,
+  toPosixPath,
+  writeFileAtomic,
+  writeText
+} from "./index-20ppawv7.js";
+import {
+  cacheRoot,
+  namedBunBinary
+} from "./index-cyfednwb.js";
+import"./index-vz0km5qk.js";
+import {
+  bootstrapCompat
+} from "./index-5gyr4emz.js";
+import {
+  readPrebundleStamp,
+  runtimeEntryDirs,
+  runtimeEntryFiles
+} from "./index-y36a0ybw.js";
+import {
+  DEFAULT_OUT_DIR,
+  devOutSegment,
+  loadConfig,
+  pathToFileHref
+} from "./index-x93hv0sc.js";
+import"./index-jcsjq3d1.js";
+import {
+  buildIndexFile,
+  readBuildIndex,
+  releaseSourceFile
+} from "./index-tqn2qnnn.js";
+import {
+  bold,
+  cyan,
+  dim,
+  green
+} from "./index-6kp9r0d9.js";
+import {
+  compiledClientReferenceFiles
+} from "./index-ras0sdab.js";
+import {
+  beginDynamicBailoutProbe,
+  endDynamicBailoutProbe,
+  runWithWorkUnit
+} from "./index-grta8ap3.js";
+import {
+  abortActivePrerenderScopes,
+  beginShellSourceTracking,
+  cacheComponents,
+  endShellSourceTracking
+} from "./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import {
+  importSpecifiers,
+  scanFactsStats
+} from "./index-z4z9zv3b.js";
+import {
+  resolveImport,
+  workspacePackageRoots
+} from "./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import {
+  buildParallelPhaseError,
+  clearBuildParallelPhases,
+  getBuildExtensions,
+  getCompatModeExtensions,
+  getImportAliasExtensions,
+  getRenderExtensions,
+  runInitHooks,
+  withRouteRuntime
+} from "./index-zqpqyg8p.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+import"./index-4399bvd2.js";
+import {
+  __require
+} from "./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 { 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 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",
+  os: "linux",
+  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;
+}
+async function writeVercelOutput(config, manifest, options = {}) {
+  const log = createVerboseLogger(options.verbose ?? false, "vercel");
+  const outputPath = path2.join(config.root, ".vercel", "output");
+  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 routes = [
+    ...compatStaticRewrite(config, outputPath),
+    ...await immutableAssetRoutes(path2.join(config.outPath, "public"), manifest.publicAssets),
+    ...await proxyRoutes(config),
+    ...staticHeaderRoutes(staticFiles),
+    { handle: "filesystem" },
+    { src: "^/.*$", dest: `/${SERVER_FUNCTION}` }
+  ];
+  const vercelConfig = {
+    version: 3,
+    routes,
+    ...Object.keys(overrides).length > 0 ? { overrides } : {}
+  };
+  await writeText(path2.join(outputPath, "config.json"), `${JSON.stringify(vercelConfig, null, 2)}
+`);
+}
+async function emptyDir(dir) {
+  const parent = path2.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 stale = readdirSync(parent).filter((entry) => entry.startsWith(staleMarker)).map((entry) => path2.join(parent, entry));
+  await mkdir(dir, { recursive: true });
+  if (stale.length > 0) {
+    Bun.spawn(["rm", "-rf", ...stale], { stdout: "ignore", stderr: "ignore" });
+  }
+}
+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)));
+  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) : [];
+}
+async function proxyRoutes(config) {
+  const proxyFile = findProxyFile(config);
+  if (!proxyFile)
+    return [];
+  const proxyModule = await import(pathToFileHref(proxyFile));
+  return [...proxyRoutePatterns(proxyModule.config), "^.*(?:%|//).*$"].map((src) => ({
+    src,
+    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}`)};
+
+const handlerPromise = createRequestHandler({
+  root: path.join(import.meta.dirname, ${JSON.stringify(appRel)}),
+});
+
+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));
+}
+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)}
+`);
+  }
+}
+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;
+      }
+      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;
+}
+var bakedPathFileFilter = /\.(?:m?js|cjs|jsx|tsx?|json|html|css)$/;
+var BAKED_PATH_CONCURRENCY = 64;
+async function rewriteBakedPaths(dir, replacements) {
+  if (!existsSync2(dir))
+    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 {}
+  }
+  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 });
+      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);
+      }
+    }
+  }
+  return packages;
+}
+function resolveFrom(specifier, dir) {
+  try {
+    return Bun.resolveSync(specifier, dir);
+  } catch {
+    return;
+  }
+}
+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) {
+  const owners = new Map;
+  for (const [name, { dir, owner }] of hostNatives) {
+    const spec = owner ?? { name, version: (await readPackageJson(dir))?.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();
+  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))
+        matches.set(name, dir);
+    }
+    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();
+  }
+}
+function matchesFunctionPlatform(packageJson) {
+  const matches = (declared, value) => {
+    if (!declared?.length)
+      return true;
+    if (declared.every((entry) => entry.startsWith("!")))
+      return !declared.includes(`!${value}`);
+    return declared.includes(value);
+  };
+  return matches(packageJson.os, FUNCTION_PLATFORM.os) && matches(packageJson.cpu, FUNCTION_PLATFORM.cpu) && matches(packageJson.libc, FUNCTION_PLATFORM.libc);
+}
+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 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"}
+`);
+    const install = Bun.spawn([
+      "bun",
+      "add",
+      "--no-save",
+      "--ignore-scripts",
+      "--silent",
+      `--os=${FUNCTION_PLATFORM.os}`,
+      `--cpu=${FUNCTION_PLATFORM.cpu}`,
+      ...specs
+    ], { cwd: staging, stdout: "ignore", stderr: "pipe" });
+    if (await install.exited !== 0) {
+      const stderr = await new Response(install.stderr).text();
+      await rm(staging, { recursive: true, force: true });
+      throw new Error(stderr.trim() || "bun add failed");
+    }
+    await rm(dir, { recursive: true, force: true });
+    await rename(staging, dir);
+  }
+  const installed = new Map;
+  for (const entry of readdirSync(modules)) {
+    if (entry.startsWith("."))
+      continue;
+    if (!entry.startsWith("@")) {
+      installed.set(entry, path2.join(modules, entry));
+      continue;
+    }
+    for (const scoped of readdirSync(path2.join(modules, entry))) {
+      installed.set(`${entry}/${scoped}`, path2.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)))));
+  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)))));
+}
+async function staticOverrides(publicPath, staticFiles) {
+  const overrides = {};
+  for (const file of await listFiles(publicPath)) {
+    const relative = toPosixPath(path2.relative(publicPath, file));
+    if (!relative.endsWith("/index.html"))
+      continue;
+    overrides[relative] = { path: relative.replace(/\/index\.html$/, "") };
+  }
+  for (const [relative, metadata] of Object.entries(staticFiles)) {
+    if (!canServeStaticOnVercel(metadata))
+      continue;
+    const contentType = metadata.headers.find(([name]) => name.toLowerCase() === "content-type")?.[1];
+    if (contentType)
+      overrides[relative] = { ...overrides[relative], contentType };
+  }
+  return overrides;
+}
+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 patterns = immutableAssetPatterns(built, publicAssets);
+  return routeSources(patterns, (source) => `^/(?:${source})`).map((src) => ({
+    src,
+    headers: { "cache-control": immutableCacheControl },
+    continue: true,
+    important: true
+  }));
+}
+function immutableAssetPatterns(built, publicAssets) {
+  const appDirs = new Set(publicAssets.flatMap(ancestorDirs));
+  const prefixes = [...new Set(immutableAssetPrefixes())];
+  const patterns = prefixes.filter((prefix) => !appDirs.has(prefix)).map(escapeRegex);
+  for (const relative of built) {
+    const prefix = prefixes.find((prefix2) => relative.startsWith(prefix2));
+    if (!prefix || !appDirs.has(prefix))
+      continue;
+    const dir = ancestorDirs(relative).find((dir2) => dir2.length > prefix.length && !appDirs.has(dir2));
+    patterns.push(dir ? escapeRegex(requestPath(dir)) : `${escapeRegex(requestPath(relative))}$`);
+  }
+  return [...new Set(patterns)];
+}
+function requestPath(relative) {
+  return relative.replace(/[\0-\x20"#<>?`{}\x7f-\u{10ffff}]/gu, (char) => encodeURIComponent(char));
+}
+function ancestorDirs(relative) {
+  const parts = relative.split("/").slice(0, -1);
+  return parts.map((_, index) => `${parts.slice(0, index + 1).join("/")}/`);
+}
+var functionOnlyHeaders = new Set([
+  "content-length",
+  "content-encoding",
+  "transfer-encoding",
+  "connection",
+  "set-cookie"
+]);
+function canServeStaticOnVercel(metadata) {
+  if (metadata.status !== 200)
+    return false;
+  const headers = routeHeaders(metadata);
+  if (headers.length === 0)
+    return true;
+  return metadata.revalidateSeconds === undefined && metadata.expireSeconds === undefined && !metadata.tags?.length && headers.every(([name]) => !functionOnlyHeaders.has(name.toLowerCase()));
+}
+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));
+  }
+  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/build.ts
+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 path3 from "path";
+var CACHE_VERSION = 2;
+var CACHE_SEGMENTS = ["cache", "build"];
+var SKIP_INPUT_DIRS = new Set([
+  ".claude",
+  ".git",
+  ".husky",
+  ".next",
+  ".pnext",
+  ".tmp",
+  ".turbo",
+  ".vercel",
+  ".vscode",
+  "node_modules"
+]);
+var SKIP_INPUT_FILE = /(?:^\.DS_Store$|\.(?:log|pid)$)/i;
+var LOCK_FILES = [
+  "bun.lock",
+  "bun.lockb",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+];
+async function lookupBuildCache(config, options) {
+  if (!cacheEnabled(options))
+    return { enabled: false };
+  const record = await readRecord(config.outPath);
+  const inputs = await inputRecords(config, record?.inputs);
+  const context = buildContext();
+  const key = buildKey(context, inputs);
+  if (record?.key !== key)
+    return { enabled: true, context, inputs, reason: "inputs" };
+  const output = await outputSnapshot(config.outPath);
+  if (output.hash !== record.outputHash) {
+    const changed = changedFiles(record.outputs, output.files).slice(0, 3).join(", ");
+    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);
+    return { enabled: true, context, inputs, manifest, reason: "hit" };
+  } catch {
+    return { enabled: true, context, inputs, reason: "manifest" };
+  }
+}
+async function writeBuildCache(config, options, session) {
+  if (!session.enabled || !session.context || !cacheEnabled(options))
+    return;
+  const inputs = await inputRecords(config, session.inputs);
+  const output = await outputSnapshot(config.outPath);
+  const record = {
+    version: CACHE_VERSION,
+    key: buildKey(session.context, inputs),
+    inputs,
+    outputHash: output.hash,
+    outputs: output.files
+  };
+  await mkdir2(cacheDir(config.outPath), { recursive: true });
+  await writeFileAtomic(recordFile(config.outPath), JSON.stringify(record));
+}
+function cacheEnabled(options) {
+  if (process.env.PNEXT_BUILD_CACHE !== "1")
+    return false;
+  return options.adapter === undefined && options.debugBuildPaths === undefined && options.buildMode === undefined && options.debugPrerender !== true;
+}
+function cacheDir(outPath) {
+  return path3.join(outPath, ...CACHE_SEGMENTS);
+}
+function recordFile(outPath) {
+  return path3.join(cacheDir(outPath), "result.json");
+}
+async function readRecord(outPath) {
+  try {
+    const parsed = JSON.parse(await readFile2(recordFile(outPath), "utf8"));
+    if (parsed.version === CACHE_VERSION && parsed.key && parsed.inputs && parsed.outputHash && parsed.outputs) {
+      return parsed;
+    }
+  } catch {}
+  return;
+}
+function buildContext() {
+  const hash = createHash("sha256");
+  hash.update(`pnext-build-cache:${CACHE_VERSION}\x00`);
+  hash.update(frameworkFingerprint());
+  hash.update(`\x00bun:${Bun.version}\x00`);
+  for (const [name, value] of Object.entries(process.env).sort(([a], [b]) => a.localeCompare(b))) {
+    hash.update(`${name}=${value ?? ""}\x00`);
+  }
+  return hash.digest("hex");
+}
+function buildKey(context, inputs) {
+  const hash = createHash("sha256");
+  hash.update(context);
+  for (const [file, record] of Object.entries(inputs).sort(([a], [b]) => a.localeCompare(b))) {
+    hash.update(`${file}\x00${record[2]}\x00`);
+  }
+  return hash.digest("hex");
+}
+async function inputRecords(config, previous) {
+  const files = new Map;
+  await collectTree(config.root, "root", files, config.outPath);
+  await collectModuleGraphInputs(config, files);
+  for (const [prefix, root] of [
+    ["root-deps", config.root],
+    ["workspace-deps", config.workspaceRoot]
+  ]) {
+    for (const name of LOCK_FILES)
+      addFile(files, `${prefix}:${name}`, path3.join(root, name));
+    addFile(files, `${prefix}:node_modules/.package-lock.json`, path3.join(root, "node_modules", ".package-lock.json"));
+  }
+  const frameworkRoot2 = path3.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/build", "..", "..");
+  addFile(files, "framework:package.json", path3.join(frameworkRoot2, "package.json"));
+  for (const name of LOCK_FILES) {
+    addFile(files, `framework:${name}`, path3.join(frameworkRoot2, name));
+    addFile(files, `framework-workspace:${name}`, path3.join(frameworkRoot2, "..", name));
+  }
+  const entries = await Promise.all([...files].map(async ([key, file]) => {
+    const stats = await lstat(file).catch(() => {
+      return;
+    });
+    if (!stats?.isFile() && !stats?.isSymbolicLink())
+      return;
+    const old = previous?.[key];
+    if (old?.[0] === stats.mtimeMs && old[1] === stats.size)
+      return [key, old];
+    const contents = stats.isSymbolicLink() ? Buffer.from(`link:${await readlink(file)}`) : await readFile2(file);
+    return [key, [stats.mtimeMs, stats.size, contentHash(contents)]];
+  }));
+  return Object.fromEntries(entries.filter((entry) => Boolean(entry)));
+}
+async function collectModuleGraphInputs(config, files) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile2(path3.join(config.outPath, "cache", "server", "graph.json"), "utf8"));
+  } catch {
+    return;
+  }
+  const frameworkRoot2 = path3.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/build", "..", "..");
+  for (const source of Object.keys(parsed.files ?? {})) {
+    const value = source.slice(2).split("/").join(path3.sep);
+    const file = source.startsWith("w:") ? path3.resolve(config.workspaceRoot, value) : source.startsWith("f:") ? path3.resolve(frameworkRoot2, value) : source.startsWith("a:") ? value : undefined;
+    if (file)
+      addFile(files, `module:${source}`, file);
+  }
+}
+async function collectTree(root, prefix, files, outPath, dir = root) {
+  const entries = await readdir(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}`))
+      return;
+    if (entry.isDirectory()) {
+      if (!SKIP_INPUT_DIRS.has(entry.name))
+        await collectTree(root, prefix, files, outPath, file);
+      return;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink())
+      return;
+    const relative = path3.relative(root, file);
+    if (SKIP_INPUT_FILE.test(entry.name) || !relative.includes(path3.sep) && /\.html?$/i.test(entry.name)) {
+      return;
+    }
+    addFile(files, `${prefix}:${toPosix(relative)}`, file);
+  }));
+}
+function addFile(files, key, file) {
+  if (existsSync3(file))
+    files.set(key, file);
+}
+async function outputSnapshot(outPath) {
+  const files = new Map;
+  const entries = await readdir(outPath, { withFileTypes: true }).catch(() => []);
+  await Promise.all(entries.map(async (entry) => {
+    if (entry.name === "cache" || entry.name === "dev")
+      return;
+    const file = path3.join(outPath, entry.name);
+    if (entry.isDirectory())
+      await collectOutputTree(outPath, file, files);
+    else if (entry.isFile() || entry.isSymbolicLink()) {
+      files.set(toPosix(entry.name), file);
+    }
+  }));
+  const hash = createHash("sha256");
+  const hashes = {};
+  for (const [name, file] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
+    const stats = await lstat(file);
+    const contents = stats.isSymbolicLink() ? Buffer.from(`link:${await readlink(file)}`) : await readFile2(file);
+    const contentsHash = contentHash(contents);
+    hashes[name] = contentsHash;
+    hash.update(`${name}\x00${contentsHash}\x00`);
+  }
+  return { hash: hash.digest("hex"), files: hashes };
+}
+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 });
+  await Promise.all(entries.map(async (entry) => {
+    const file = path3.join(dir, entry.name);
+    if (entry.isDirectory())
+      await collectOutputTree(root, file, files);
+    else if (entry.isFile() || entry.isSymbolicLink()) {
+      files.set(toPosix(path3.relative(root, file)), file);
+    }
+  }));
+}
+function contentHash(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+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";
+import path4 from "path";
+var frameworkRoot2 = path4.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve", "..", "..", "..");
+function frameworkVersion() {
+  try {
+    const pkg = readFileSync3(path4.join(frameworkRoot2, "package.json"), "utf8");
+    return JSON.parse(pkg).version ?? "0";
+  } catch {
+    return "0";
+  }
+}
+function serverEntryDir(outPath) {
+  const generation = frameworkFingerprint(path4.join(outPath, "cache", "server"));
+  return path4.join(outPath, "server", `bundle-${frameworkVersion()}-${generation}`);
+}
+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
+`);
+}
+
+// src/cli/build.ts
+function nextCompatEnabled2(config) {
+  return getCompatModeExtensions().nextEnabled(config);
+}
+function reactCompatEnabled(config) {
+  return getCompatModeExtensions().reactEnabled(config);
+}
+function buildCompat() {
+  return getBuildExtensions().compat;
+}
+async function buildProject(root, options = {}) {
+  clearBuildParallelPhases();
+  resetModuleGraphFailure();
+  beginSourceScope();
+  const restoreSpecifiersManifest = setEmitCompiledSpecifiersManifest(options.adapter === "vercel");
+  const restoreReleaseCompile = setReleaseCompile(true);
+  const lifecycle = {};
+  try {
+    return await runBuild(root, options, lifecycle);
+  } catch (error) {
+    const phaseError = buildParallelPhaseError();
+    throw phaseError ?? error;
+  } finally {
+    lifecycle.warm?.kill();
+    endSourceScope();
+    restoreSpecifiersManifest();
+    restoreReleaseCompile();
+    flushDevModuleCaches();
+  }
+}
+async function runBuild(root, options, lifecycle) {
+  const verbose = options.verbose ?? false;
+  const log = createVerboseLogger(verbose, "build");
+  const startedAt = performance.now();
+  console.log(`\u26A1 ${bold("pnext")} ${dim(`\u2014 Creating an optimized production build ...
+`)}`);
+  const config = await loadConfig(root);
+  const buildCache = lookupBuildCache(config, options);
+  await bootstrapCompat(config);
+  log.log(`config loaded \u2014 out ${path5.relative(config.root, config.outPath) || "."}`);
+  runInitHooks(config, { build: true });
+  const cached = await buildCache;
+  log.log(`build cache ${cached.reason ?? "disabled"}`);
+  if (cached.manifest) {
+    printBuildSummary(config, cached.manifest.routes, cached.manifest.staticFiles ?? {}, performance.now() - startedAt, Boolean(cached.manifest.proxyModule));
+    return cached.manifest;
+  }
+  warmCssPipeline(config);
+  const warmMode = options.adapter === "vercel" ? "full" : "compile";
+  const warm = startWarmChild(config, warmMode);
+  lifecycle.warm = warm;
+  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"));
+  });
+  const documentCss = Promise.resolve().then(() => buildGlobalCss(config, { verbose })).then(() => buildNotFoundCss(config, { verbose }));
+  documentCss.catch(() => {
+    return;
+  });
+  const partytownLib = log.step("partytown lib", () => copyPartytownLib(config));
+  partytownLib.catch(() => {
+    return;
+  });
+  let routes = await log.step("scan routes", () => scanRoutes(config.appPath, config.workspaceRoot));
+  log.log(`found ${routes.length} route${routes.length === 1 ? "" : "s"}`);
+  if (options.debugBuildPaths) {
+    routes = filterDebugBuildRoutes(config.root, routes, options.debugBuildPaths);
+    log.log(`--debug-build-paths ${options.debugBuildPaths} \u2014 ${routes.length} route${routes.length === 1 ? "" : "s"} kept`);
+  }
+  warm.prewarm(routes.filter((route) => route.kind === "page").map((route) => route.file));
+  const buildState = { actions: [] };
+  const stepContext = { config, routes, manifest: buildState, log };
+  const { steps } = getBuildExtensions();
+  const earlySteps = runBuildSteps(steps.filter((step) => step.early), stepContext);
+  earlySteps.catch(() => {
+    return;
+  });
+  const clientSources = startClientSources(config);
+  await log.step("scan route facts", async () => materializeRouteFacts(routes, (route) => clientSources.warmRoutes([route])));
+  assertNoServerActionsWithoutCompat(routes, nextCompatEnabled2(config), config.root);
+  setRequestRuntime({ config, routes, dev: false });
+  prepareRouteCssChunks(routes);
+  const routeStylesheets = buildRouteStylesheets(config, routes.filter((route) => route.kind !== "handler" && !route.dynamicErrorApi), documentCss, { verbose });
+  const flatExportLayout = nextCompatEnabled2(config) && buildCompat().nextOutputExport() && config.trailingSlash !== true;
+  const proxyBuild = log.step("proxy module", () => buildProxyModule(config));
+  proxyBuild.catch(() => {
+    return;
+  });
+  await runBuildSteps(steps.filter((step) => !step.early && step.gate), stepContext);
+  const staticFiles = {};
+  const staticMetadata = (async () => {
+    const files = await log.step("discover static metadata files", () => Promise.resolve(discoverStaticMetadataFiles(config.appPath)));
+    await log.step("static metadata files", () => copyStaticMetadataFiles(config, staticFiles, files));
+    return files;
+  })();
+  staticMetadata.catch(() => {
+    return;
+  });
+  await earlySteps;
+  const deferredSteps = buildState.deferred ?? Promise.resolve();
+  deferredSteps.catch(() => {
+    return;
+  });
+  const staticMetadataFiles = await staticMetadata;
+  const metadataWarnings = nextCompatEnabled2(config) ? log.step("next metadata warnings", () => buildCompat().warnMetadataIssues({
+    appPath: config.appPath,
+    routes,
+    staticMetadataFiles
+  })) : undefined;
+  metadataWarnings?.catch(() => {
+    return;
+  });
+  const moduleMetadata = log.step("core module metadata", () => collectStaticModuleMetadata(config, routes));
+  moduleMetadata.catch(() => {
+    return;
+  });
+  const actionSources = buildState.actionSources ?? buildState.actions.map((a) => a.sourceKey);
+  const actionFiles = new Set(actionSources.map((source) => realFilePath(path5.resolve(config.root, source))));
+  const actionImporters = new Set((buildState.actionImporters ?? []).map(realFilePath));
+  const realFiles = new Map;
+  const reachesAction = (file) => {
+    let real = realFiles.get(file);
+    if (real === undefined)
+      realFiles.set(file, real = realFilePath(file));
+    return actionFiles.has(real) || actionImporters.has(real);
+  };
+  for (const route of routes) {
+    if (route.kind === "page" && (actionFiles.size > 0 || actionImporters.size > 0) && route.sourceFiles.some(reachesAction)) {
+      addClientEntryReason(route, "actions");
+    }
+  }
+  const clientRoutes = routes.filter((route) => route.kind !== "handler" && (route.client || route.clientReferences.length > 0 || route.needsRouterEntry));
+  for (const route of clientRoutes)
+    route.clientEntry = `assets/${clientEntryName(route)}.js`;
+  const clientBundles = log.step(`client bundles (${clientRoutes.length} route${clientRoutes.length === 1 ? "" : "s"})`, () => buildClientEntries({
+    config,
+    routes: clientRoutes,
+    outDir: path5.join(config.outPath, "public", "assets"),
+    verbose,
+    hasServerActions: actionSources.length > 0,
+    pipeline: clientSources
+  }));
+  clientBundles.catch(() => {
+    return;
+  });
+  const notFoundDocuments = clientBundles.then(async () => renderNotFoundDocuments({
+    config,
+    log,
+    skip: options.buildMode === "compile",
+    documentCss,
+    staticMetadataFiles,
+    staticModuleMetadata: await moduleMetadata
+  }));
+  notFoundDocuments.catch(() => {
+    return;
+  });
+  const remainingSteps = runBuildSteps(steps.filter((step) => !step.early && !step.gate), stepContext).then(() => log.step("typegen", () => writeTypegen(config, routes)));
+  remainingSteps.catch(() => {
+    return;
+  });
+  await remainingSteps;
+  const staticModuleMetadata = await moduleMetadata;
+  await clientBundles;
+  const proxyModule = await proxyBuild;
+  await partytownLib;
+  await emitStaticClientChunks(config, path5.join(config.outPath, "public", "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())}`);
+  }
+  await metadataWarnings;
+  let hadAfterPrerenderError = false;
+  let hadDynamicErrorFailure = false;
+  const descendantHandlerIds = collectDescendantHandlerIds(routes);
+  const isCompile = options.buildMode === "compile";
+  const isGenerate = options.buildMode === "generate";
+  const debugPrerender = options.debugPrerender ?? false;
+  buildCompat().recordBuildFlags(config.outPath, debugPrerender);
+  const generateRouteLines = [];
+  const partialPrerenders = new Set;
+  const generateFailures = [];
+  if (isGenerate)
+    console.log("   Collecting page data ...");
+  await documentCss;
+  for (const route of routes) {
+    if (route.dynamicErrorApi) {
+      console.error(`Error: Route ${toNextRoutePattern(route.route || "/")} with \`dynamic = "error"\` ` + `couldn't be rendered statically because it used ${route.dynamicErrorApi}. ` + `See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
+      hadDynamicErrorFailure = true;
+      continue;
+    }
+    if (route.kind === "handler") {
+      if (isCompile)
+        continue;
+      if (!await staticRouteHandlerCandidate(route))
+        continue;
+      const dynamicUsage = await staticHandlerDynamicUsage(route);
+      if (dynamicUsage) {
+        console.log(`Caught Error: Dynamic server usage: Route ${route.route || "/"} couldn't be rendered statically because it used \`${dynamicUsage}\`.`);
+        continue;
+      }
+      try {
+        Object.assign(staticFiles, await log.step(`route handler ${route.route}`, () => buildStaticRouteHandler(config, route, {
+          skipPhysicalWrite: descendantHandlerIds.has(route.id)
+        })));
+      } catch (error) {
+        rethrowIfProgrammingError(error);
+        if (isAfterPrerenderError(error))
+          hadAfterPrerenderError = true;
+        warnSkippedStatic(route.route, error instanceof Error ? error.message : String(error));
+      }
+      continue;
+    }
+    await routeStylesheets.get(route)?.();
+    if (isCompile)
+      continue;
+    if (isGenerate && cacheComponents() && !route.client && !route.interception) {
+      const diagnosticRoute = toNextRoutePattern(route.route || "/");
+      const diagnostic = buildCompat().diagnoseCacheComponentsPrerender({
+        route: diagnosticRoute,
+        pageFile: route.file,
+        appPath: config.appPath,
+        debugPrerender
+      });
+      if (diagnostic) {
+        console.error(diagnostic);
+        generateFailures.push({
+          route: diagnosticRoute,
+          omitErrorLine: buildCompat().diagnosticLeadsWithErrorLine(diagnostic)
+        });
+        continue;
+      }
+    }
+    if (route.ppr) {
+      await log.step(`ppr shell ${route.route}`, () => buildPprShell(config, route));
+      continue;
+    }
+    if (cacheComponents() && !route.interception && (!route.client || route.params.length === 0 && !route.catchAll)) {
+      const built = await log.step(`cache-components shell ${route.route}`, () => buildCacheComponentsShell(config, route));
+      if (built) {
+        const paramFallback = (route.params.length > 0 || Boolean(route.catchAll)) && !route.hasStaticParams;
+        if (paramFallback || (route.pprHoles?.length ?? 0) > 0 || route.pprMetadata) {
+          partialPrerenders.add(route.id);
+        }
+        if (isGenerate)
+          generateRouteLines.push(`  \u25D0 ${route.route || "/"}`);
+        continue;
+      }
+    }
+    if (cacheComponents() && route.client && (route.params.length > 0 || route.catchAll))
+      continue;
+    const segmentConfig = route.segmentConfig;
+    const forceStatic = segmentConfig?.dynamic === "force-static";
+    if (forceStatic && segmentConfig?.runtime === "edge") {
+      console.warn(`Page "${route.route}" is using runtime = 'edge' which is currently incompatible with dynamic = 'force-static'. Please remove either "runtime" or "force-static" for correct behavior`);
+    }
+    const configForcesDynamic = segmentConfig?.dynamic === "force-dynamic" || segmentConfig?.revalidate === 0 || segmentConfig?.fetchCache === "force-no-store" || segmentConfig?.runtime === "edge" && !forceStatic;
+    let staticParams = null;
+    if (!configForcesDynamic && route.hasStaticParams) {
+      try {
+        staticParams = await log.step(`static params ${route.route}`, () => getRenderExtensions().collectRenderMeta(() => staticParamsFor(config, route), {
+          route: route.route,
+          prerender: true
+        }).then((result) => result.value));
+      } catch (error) {
+        rethrowIfProgrammingError(error);
+        if (!isAfterPrerenderError(error))
+          throw error;
+        console.error(`Failed to collect page data for ${toNextRoutePattern(route.route)}`);
+        console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+        hadAfterPrerenderError = true;
+        continue;
+      }
+    }
+    const validateUnstableCacheScope = !configForcesDynamic && route.usesRequest && !forceStatic && await usesUnstableCache(route);
+    const paramSets = staticParams ? staticParams.paths : validateUnstableCacheScope ? [{}] : configForcesDynamic || route.usesRequest && !forceStatic ? [] : route.mode === "static" && route.params.length === 0 && !route.catchAll ? [{}] : [];
+    if (staticParams)
+      route.prerenderedParams = staticParams.allSets;
+    if (process.env.NEXT_DEBUG_BUILD && paramSets.length === 0 && !staticParams && !configForcesDynamic && route.usesRequest && !forceStatic && route.params.length === 0 && !route.catchAll) {
+      logStaticBailout(route.route || "/", await requestApiBailoutReason(route));
+    }
+    if (paramSets.length === 0) {
+      if (!configForcesDynamic && !forceStatic && route.usesRequest && route.params.length === 0 && !route.catchAll && await schedulesDeferredWork(route)) {
+        await probeDeferredDynamicUsage(config, route, staticMetadataFiles, staticModuleMetadata);
+      }
+      continue;
+    }
+    if (!forceStatic && await needsRequestOriginForMetadataImages(config.appPath, route))
+      continue;
+    await log.step(`prerender ${route.route} (${paramSets.length} page${paramSets.length === 1 ? "" : "s"})`, async () => {
+      for (const rawParams of paramSets) {
+        const params = encodeStaticRouteParams(rawParams);
+        const routePath = fillRoutePath(route.route, rawParams);
+        const file = staticHtmlPath(config.outPath, routePath, flatExportLayout);
+        const collision = staticOutputCollision(config.outPath, file);
+        if (collision) {
+          warnSkippedStatic(routePath, collision);
+          continue;
+        }
+        const url = new URL(`http://pnext.local${routePath}`);
+        try {
+          let cacheLife;
+          let fontLinkHeader;
+          let prerenderVary;
+          const rendered = await runWithWorkUnit("render", async () => {
+            const tracked = await buildCompat().withVaryParamsTracking(() => getRenderExtensions().collectRenderMeta(() => runWithNextBuildPhase(() => withRouteRuntime(route.segmentConfig?.runtime, () => renderPageWithStatus({
+              config,
+              route,
+              params,
+              url,
+              ...route.usesRequest ? { request: new Request(url) } : {},
+              staticMetadataFiles,
+              staticModuleMetadata
+            }))), {
+              fetchCache: segmentConfig?.fetchCache,
+              route: routePath || "/",
+              prerender: true
+            }));
+            const result = tracked.value;
+            prerenderVary = tracked.vary;
+            cacheLife = buildCompat().takeCacheLifeStash();
+            fontLinkHeader = buildCompat().takeFontLinkHeader();
+            return result;
+          });
+          const optedStatic = forceStatic || typeof segmentConfig?.revalidate === "number" || segmentConfig?.revalidate === false;
+          if (rendered.noStore && !optedStatic) {
+            if (process.env.NEXT_DEBUG_BUILD)
+              logStaticBailout(routePath || "/", "no-store fetch");
+            continue;
+          }
+          await writeText(file, rendered.value.html);
+          recordPrerenderVary(route, routePath || "/", prerenderVary);
+          const routeLine = `${dim("  \u25CB")} ${routePath || "/"}`;
+          if (isGenerate)
+            generateRouteLines.push(routeLine);
+          else
+            console.log(routeLine);
+          await emitConcreteNextPageArtifacts(config, route, routePath || "/", {
+            html: rendered.value.html,
+            status: rendered.value.status
+          });
+          const relative = toPosixPath(path5.relative(path5.join(config.outPath, "public"), file));
+          const revalidateSeconds = combineRevalidate(segmentConfig?.revalidate, rendered.revalidateSeconds);
+          const defaultExpireTime = buildCompat().defaultExpireTimeSeconds();
+          const effectiveCacheLife = cacheLife ?? (rendered.expireSeconds !== undefined || rendered.staleSeconds !== undefined ? {
+            ...revalidateSeconds !== undefined ? { revalidateSeconds } : {},
+            ...rendered.expireSeconds !== undefined ? { expireSeconds: rendered.expireSeconds } : {},
+            ...rendered.staleSeconds !== undefined ? { staleSeconds: rendered.staleSeconds } : {}
+          } : revalidateSeconds !== undefined && defaultExpireTime !== undefined ? {
+            revalidateSeconds,
+            expireSeconds: defaultExpireTime
+          } : undefined);
+          const cacheLifeHeaders = cacheLifeResponseHeaders(effectiveCacheLife);
+          const headers = [
+            ...rendered.value.location ? [["location", rendered.value.location]] : [],
+            ...fontLinkHeader ? [["link", fontLinkHeader]] : [],
+            ...cacheLifeHeaders
+          ];
+          staticFiles[relative] = {
+            status: rendered.value.status,
+            headers,
+            routeId: route.id,
+            kind: "page",
+            ...revalidateSeconds !== undefined ? { revalidateSeconds } : {},
+            ...effectiveCacheLife?.expireSeconds !== undefined ? { expireSeconds: effectiveCacheLife.expireSeconds } : {},
+            ...effectiveCacheLife?.staleSeconds !== undefined ? { staleSeconds: effectiveCacheLife.staleSeconds } : {},
+            ...rendered.tags.length > 0 ? { tags: rendered.tags } : {}
+          };
+        } catch (error) {
+          rethrowIfProgrammingError(error);
+          if (isAfterPrerenderError(error))
+            hadAfterPrerenderError = true;
+          warnSkippedStatic(routePath, error instanceof Error ? error.message : String(error));
+        }
+      }
+    });
+  }
+  if (isGenerate && generateFailures.length > 0) {
+    for (const failed of generateFailures) {
+      console.error(buildCompat().prerenderFailureFooter(failed.route, debugPrerender, failed.omitErrorLine));
+    }
+    console.error("Next.js build worker exited with code: 1 and signal: null");
+    process.exit(1);
+  }
+  if (isGenerate) {
+    console.log(`
+Route (app)`);
+    for (const line of generateRouteLines)
+      console.log(line);
+  }
+  throwIfModuleGraphFailed();
+  if (hadAfterPrerenderError) {
+    throw new Error("Build failed because an error was thrown inside `after()` while prerendering.");
+  }
+  if (hadDynamicErrorFailure) {
+    throw new Error('Build failed because a route with `dynamic = "error"` read dynamic data during prerendering.');
+  }
+  const interceptionPrerenders = isCompile ? new Map : await logInterceptionPrerenders(config, routes);
+  const fallback404 = await notFoundDocuments;
+  await emitNextNotFoundArtifacts(config, fallback404);
+  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 pseudos = hasTopLevelRootLayout ? ["_not-found.html", "_global-error.html"] : ["_not-found.html"];
+    for (const pseudo of pseudos) {
+      if (!(pseudo in staticFiles)) {
+        staticFiles[pseudo] = { status: 200, headers: [], kind: "page" };
+      }
+    }
+  }
+  await deferredSteps;
+  const actions = buildState.actions;
+  const publicAssets = publicFiles.filter((relative) => immutableAssetPath(relative));
+  const manifest = {
+    version: 0,
+    root: config.root,
+    appDir: config.appPath,
+    outDir: config.outPath,
+    routes,
+    staticFiles,
+    assetNames: emittedAssetNames(config.outPath),
+    ...publicAssets.length > 0 ? { publicAssets } : {},
+    staticMetadataFiles,
+    ...Object.keys(staticModuleMetadata).length > 0 ? { staticModuleMetadata } : {},
+    ...!config.compat?.next ? {
+      staticRouteMetadata: await log.step("core route metadata", () => collectStaticRouteMetadata(config, routes, staticMetadataFiles))
+    } : {},
+    ...proxyModule ? { proxyModule } : {},
+    ...actions.length > 0 ? { actions } : {}
+  };
+  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))) {
+    throw new Error("pnext build: the server compile did not complete (see the error above).");
+  }
+  throwIfModuleGraphFailed();
+  const buildDurationMs = performance.now() - startedAt;
+  const phases = await settleBuildParallelPhases();
+  flushDevModuleCaches();
+  await writeBuildCache(config, options, cached);
+  printBuildSummary(config, routes, staticFiles, buildDurationMs, Boolean(proxyModule), interceptionPrerenders, partialPrerenders, phases);
+  return manifest;
+}
+async function runBuildSteps(steps, ctx) {
+  for (const [index, step] of steps.entries()) {
+    await ctx.log.step(`build step ${step.name || index}`, () => step(ctx));
+  }
+}
+async function settleBuildParallelPhases() {
+  const phases = getBuildExtensions().parallelPhases;
+  const timings = [];
+  for (const phase of phases)
+    timings.push({ name: phase.name, durationMs: await phase.run });
+  return timings;
+}
+async function logInterceptionPrerenders(config, routes) {
+  const prerenders = new Map;
+  for (const route of routes) {
+    if (route.kind !== "page" || !route.interception)
+      continue;
+    if (!routeFileExportsStaticParams(route.file))
+      continue;
+    let paths;
+    try {
+      const staticParams = await staticParamsFor(config, route);
+      paths = staticParams.paths.map((params) => interceptionDisplayRoute(route, fillRoutePath(route.route, params)));
+    } catch (error) {
+      rethrowIfProgrammingError(error);
+      warnSkippedStatic(route.route, error instanceof Error ? error.message : String(error));
+      continue;
+    }
+    if (paths.length === 0)
+      continue;
+    prerenders.set(route.id, paths);
+    for (const routePath of paths)
+      console.log(`${dim("  \u25CB")} ${routePath}`);
+  }
+  return prerenders;
+}
+function routeFileExportsStaticParams(file) {
+  if (!existsSync4(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);
+}
+function interceptionDisplayRoute(route, filled) {
+  const interception = route.interception;
+  if (!interception)
+    return route.route;
+  const base = interception.base === "/" ? [] : interception.base.split("/").filter(Boolean);
+  const levels = interceptionMarkerLevels(interception.marker);
+  const target = (filled ?? toNextRoutePattern(route.route)).split("/").filter(Boolean);
+  const cut = Number.isFinite(levels) ? Math.max(0, base.length - levels) : 0;
+  const below = target.slice(cut);
+  const segments = [...base, `${interception.marker}${below[0] ?? ""}`, ...below.slice(1)];
+  return `/${segments.join("/")}`;
+}
+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);
+}
+function assertManifestServerArtifacts(outPath, manifest) {
+  const artifacts = [
+    ...manifest.proxyModule ? [manifest.proxyModule] : [],
+    ...manifest.actions?.map((action) => action.modulePath) ?? []
+  ];
+  for (const artifact of artifacts) {
+    const file = path5.resolve(outPath, artifact);
+    if (file !== outPath && !file.startsWith(`${outPath}${path5.sep}`)) {
+      throw new Error(`Build manifest server artifact escapes output directory: ${artifact}`);
+    }
+    if (!existsSync4(file)) {
+      throw new Error(`Build manifest server artifact is missing: ${artifact}`);
+    }
+  }
+}
+function printBuildSummary(config, routes, staticFiles, durationMs, hasMiddleware = false, interceptionPrerenders = new Map, partialPrerenders = new Set, parallelPhases = []) {
+  const pages = routes.filter((route) => route.kind !== "handler").length;
+  const handlers = routes.length - pages;
+  const parts = [`${pages} ${pages === 1 ? "page" : "pages"}`];
+  if (handlers > 0)
+    parts.push(`${handlers} ${handlers === 1 ? "route handler" : "route handlers"}`);
+  const outDir = path5.relative(config.root, config.outPath) || ".";
+  console.log("");
+  console.log("Route (app)");
+  const usedMarkers = new Set;
+  for (const route of routes) {
+    const intercepted = interceptionPrerenders.get(route.id);
+    const marker = route.kind === "handler" ? Object.values(staticFiles).some((file) => file.routeId === route.id) ? "\u25CB" : "\u0192" : intercepted ? "\u25CF" : partialPrerenders.has(route.id) ? "\u25D0" : route.mode === "dynamic" && !route.hasStaticParams ? "\u0192" : route.hasStaticParams ? "\u25CF" : "\u25CB";
+    const label = route.interception ? interceptionDisplayRoute(route) : route.route || "/";
+    usedMarkers.add(marker);
+    console.log(`  ${marker} ${nextCompatEnabled2(config) ? toNextRoutePattern(label) : label}`);
+  }
+  for (const file of staticMetadataSummaryFiles(staticFiles)) {
+    usedMarkers.add("\u25CB");
+    console.log(`  ${dim("\u25CB")} /${file}`);
+  }
+  if (hasMiddleware) {
+    usedMarkers.add("\u0192");
+    console.log("");
+    console.log(`  ${dim("\u0192")} Middleware`);
+  }
+  const legend = [
+    ["\u25CB", "static"],
+    ["\u25CF", "SSG"],
+    ["\u25D0", "partial prerender"],
+    ["\u0192", "dynamic"]
+  ];
+  const legendLine = legend.filter(([marker]) => usedMarkers.has(marker)).map(([marker, meaning]) => `${marker} ${meaning}`).join("   ");
+  if (legendLine)
+    console.log(`
+  ${dim(legendLine)}`);
+  console.log("");
+  console.log(`${green("\u2713")} ${bold("Build complete")} ${dim(`in ${formatBuildDuration(durationMs)}`)}`);
+  for (const phase of parallelPhases) {
+    console.log(`${green("\u2713")} ${bold(`${phase.name} complete`)} ${dim(`in ${formatBuildDuration(phase.durationMs)}`)}`);
+  }
+  console.log(`  ${dim(`${parts.join(", ")} \u2192 ${outDir}`)}`);
+  console.log("");
+  console.log(`  Serve the production build: ${cyan("pnext start")}`);
+  console.log(`  Analyze the build: ${cyan("pnext analyze")}`);
+}
+function staticMetadataSummaryFiles(staticFiles) {
+  return Object.entries(staticFiles).filter(([, metadata]) => metadata.headers.some(([name, value]) => name.toLowerCase() === "cache-control" && value === staticMetadataCacheControl)).map(([file]) => file).sort();
+}
+function formatBuildDuration(durationMs) {
+  const totalSeconds = Math.max(0, durationMs) / 1000;
+  if (totalSeconds < 60)
+    return `${totalSeconds.toFixed(totalSeconds < 10 ? 2 : 1)}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = Math.round(totalSeconds % 60);
+  return `${minutes}m ${seconds}s`;
+}
+async function renderShellWithCacheMeta(config, route, render) {
+  let linkHeader;
+  const tracked = await buildCompat().withVaryParamsTracking(async () => runWithWorkUnit("render", async () => {
+    const rendered = await getRenderExtensions().collectRenderMeta(() => runWithNextBuildPhase(render), {
+      fetchCache: route.segmentConfig?.fetchCache,
+      route: route.route || "/",
+      prerender: true
+    });
+    linkHeader = buildCompat().takeFontLinkHeader();
+    return rendered;
+  }));
+  const result = tracked.value;
+  const cacheLife = result.revalidateSeconds !== undefined || result.expireSeconds !== undefined || result.staleSeconds !== undefined ? {
+    ...result.revalidateSeconds !== undefined ? { revalidateSeconds: result.revalidateSeconds } : {},
+    ...result.expireSeconds !== undefined ? { expireSeconds: result.expireSeconds } : {},
+    ...result.staleSeconds !== undefined ? { staleSeconds: result.staleSeconds } : {}
+  } : undefined;
+  return {
+    prebuilt: result.value,
+    meta: {
+      ...cacheLife ? { cacheLife } : {},
+      tags: result.tags,
+      ...linkHeader ? { linkHeader } : {}
+    },
+    vary: tracked.vary
+  };
+}
+var DYNAMIC_EXPIRE_SECONDS = 300;
+function routeDeclaresShortLivedCache(route) {
+  for (const file of route.sourceFiles) {
+    if (!existsSync4(file))
+      continue;
+    const source = readTextSync(file);
+    for (const literal of source.matchAll(/cacheLife\s*\(\s*\{[^}]*\bexpire\s*:\s*([^,}]+)/gs)) {
+      const value = staticNumberExpression(literal[1]);
+      if (value !== undefined && value < DYNAMIC_EXPIRE_SECONDS)
+        return true;
+    }
+    for (const named of source.matchAll(/cacheLife\s*\(\s*['"]([^'"]+)['"]\s*\)/g)) {
+      const expire = builtInCacheLifeExpire(named[1]);
+      if (expire !== undefined && expire < DYNAMIC_EXPIRE_SECONDS)
+        return true;
+    }
+  }
+  return false;
+}
+async function renderPrefetchBody(config, route, render) {
+  if (!routeDeclaresShortLivedCache(route))
+    return;
+  try {
+    const { prebuilt, vary } = await renderShellWithCacheMeta(config, route, render);
+    return prebuilt ? { prebuilt, vary } : undefined;
+  } catch {
+    return;
+  } finally {
+    abortActivePrerenderScopes();
+  }
+}
+async function buildPprShell(config, route) {
+  const url = new URL(`http://pnext.local${route.route}`);
+  const { prebuilt, meta, vary } = await renderShellWithCacheMeta(config, route, () => renderPartialShell({ config, route, url }));
+  if (!prebuilt) {
+    route.ppr = false;
+    return;
+  }
+  route.pprHoles = prebuilt.holes;
+  route.pprMetadata = prebuilt.metadataDynamic || undefined;
+  persistRouteCacheLife(route, meta.cacheLife);
+  recordRouteCacheTags(route, meta.tags);
+  if (meta.linkHeader)
+    route.linkHeader = meta.linkHeader;
+  const file = pprShellPath(config.outPath, route.id);
+  await mkdir4(path5.dirname(file), { recursive: true });
+  await writeText(file, prebuilt.shell);
+  const prefetchBody = await renderPrefetchBody(config, route, () => renderPartialShell({ config, route, url, prefetchShell: true })) ?? { prebuilt, vary };
+  await emitSegmentArtifacts(config, route, prefetchBody.prebuilt.shell, prefetchBody.prebuilt.holes.length > 0, meta, undefined, prefetchBody.vary, true);
+}
+function recordRouteCacheTags(route, tags) {
+  if (tags.length === 0)
+    return;
+  route.cacheTags = [...new Set([...route.cacheTags ?? [], ...tags])];
+}
+function persistRouteCacheLife(route, life) {
+  if (!life)
+    return;
+  route.cacheLife = {
+    ...life.revalidateSeconds !== undefined ? { revalidateSeconds: life.revalidateSeconds } : {},
+    ...life.expireSeconds !== undefined ? { expireSeconds: life.expireSeconds } : {},
+    ...life.staleSeconds !== undefined ? { staleSeconds: life.staleSeconds } : {}
+  };
+}
+async function emitSegmentArtifacts(config, route, body, postponed, cacheMeta, statusOverride, vary, fallbackParamsRender = false) {
+  const isStatic = route.mode === "static" && !postponed;
+  const compat = buildCompat();
+  const staleTime = staleTimeFromRouteSources(route) ?? (isStatic ? compat.defaultStaticStaleTimeSeconds : compat.defaultDynamicStaleTimeSeconds);
+  const bodySizeBytes = Buffer.byteLength(body);
+  const tree = compat.buildRootTreePrefetch({
+    pathname: route.route,
+    isStatic,
+    staleTimeSeconds: staleTime,
+    routeId: route.id,
+    bodySizeBytes,
+    postponed,
+    runtimePrefetch: route.segmentConfig?.prefetch === "allow-runtime",
+    ...route.pprMetadata === true ? { headOutlined: true, .../[:*]/.test(route.route) ? { headFirst: true } : {} } : {}
+  });
+  const meta = compat.buildSegmentMeta({
+    status: statusOverride ?? 200,
+    staleTime,
+    postponed,
+    bodySizeBytes,
+    prefetchHints: { [route.route]: tree.tree.prefetchHints },
+    ...vary && buildVaryTrusted(route, vary, fallbackParamsRender) ? { vary } : {}
+  });
+  await mkdir4(compat.segmentDir(config.outPath, route.id), { recursive: true });
+  await writeText(compat.treeSegmentFile(config.outPath, route.id), JSON.stringify(tree));
+  await writeText(compat.bodySegmentFile(config.outPath, route.id), body);
+  await writeText(compat.segmentMetaFile(config.outPath, route.id), JSON.stringify(meta));
+  await emitNextSegmentArtifacts(config.root, route, body, compat.rootTreePrefetchText(tree, "flight"), meta, segmentMetaHeaders(cacheMeta));
+}
+function recordPrerenderVary(route, routePath, vary) {
+  if (!vary || !buildVaryTrusted(route, vary, false))
+    return;
+  if (vary.params.length === 0 && !vary.search)
+    return;
+  route.prerenderVary ??= {};
+  route.prerenderVary[routePath] = {
+    vary: buildCompat().varyNamesFor(vary, "body"),
+    layoutVary: buildCompat().varyNamesFor(vary, "layout"),
+    pageVary: buildCompat().varyNamesFor(vary, "page")
+  };
+}
+function buildVaryTrusted(route, vary, fallbackParamsRender) {
+  if (vary.params.length > 0 || vary.search)
+    return true;
+  if (fallbackParamsRender)
+    return true;
+  return route.params.length === 0 && !route.catchAll;
+}
+function segmentMetaHeaders(cacheMeta) {
+  const headers = {};
+  if (!cacheMeta)
+    return headers;
+  for (const [key, value] of cacheLifeResponseHeaders(cacheMeta.cacheLife))
+    headers[key] = value;
+  if (cacheMeta.tags.length > 0)
+    headers["x-next-cache-tags"] = cacheMeta.tags.join(",");
+  return headers;
+}
+async function emitNextSegmentArtifacts(root, route, body, tree, meta, headers = {}) {
+  const appPath = nextAppRoutePath(route.route);
+  const appFile = path5.join(root, ".next", "server", "app", appPath);
+  const segmentsDir = `${appFile}.segments`;
+  const nextMeta = {
+    status: meta.status,
+    headers,
+    staleTime: meta.staleTime,
+    ...meta.postponed ? { postponed: "1" } : {},
+    segmentPaths: meta.segmentPaths,
+    ...meta.segmentSizes ? { segmentSizes: meta.segmentSizes } : {},
+    ...meta.inlinedSegmentPaths ? { inlinedSegmentPaths: meta.inlinedSegmentPaths } : {},
+    ...meta.prefetchHints ? { prefetchHints: meta.prefetchHints } : {}
+  };
+  await mkdir4(segmentsDir, { recursive: true });
+  await writeText(`${appFile}.html`, meta.postponed ? body : `${body}
+  </body></html>`);
+  await writeText(`${appFile}.meta`, JSON.stringify(nextMeta));
+  await writeText(path5.join(segmentsDir, "_tree.segment.rsc"), tree);
+  await writeText(path5.join(segmentsDir, "_full.segment.rsc"), body);
+  await writeText(path5.join(segmentsDir, "_index.segment.rsc"), body);
+  const routeSegment = appPath === "index" ? "__PAGE__" : appPath;
+  await writeNestedSegment(segmentsDir, `${routeSegment}.segment.rsc`, body);
+  await writeNestedSegment(segmentsDir, path5.join(routeSegment, "__PAGE__.segment.rsc"), body);
+}
+async function emitConcreteNextPageArtifacts(config, route, routePath, rendered) {
+  if (!config.compat?.next || !cacheComponents())
+    return;
+  const compat = buildCompat();
+  const postponed = rendered.postponed ?? false;
+  const bodySizeBytes = Buffer.byteLength(rendered.html);
+  const staleTime = staleTimeFromRouteSources(route) ?? compat.defaultStaticStaleTimeSeconds;
+  const tree = compat.buildRootTreePrefetch({
+    pathname: routePath,
+    isStatic: !postponed,
+    staleTimeSeconds: staleTime,
+    routeId: route.id,
+    bodySizeBytes,
+    postponed
+  });
+  const meta = compat.buildSegmentMeta({
+    status: rendered.status,
+    staleTime,
+    postponed,
+    bodySizeBytes
+  });
+  const appFile = path5.join(config.root, ".next", "server", "app", nextAppRoutePath(routePath));
+  const segmentsDir = `${appFile}.segments`;
+  await mkdir4(segmentsDir, { recursive: true });
+  await writeText(`${appFile}.html`, rendered.html);
+  await writeText(`${appFile}.meta`, JSON.stringify({
+    status: meta.status,
+    headers: {},
+    staleTime: meta.staleTime,
+    ...postponed ? { postponed: "1" } : {},
+    segmentPaths: meta.segmentPaths,
+    ...meta.segmentSizes ? { segmentSizes: meta.segmentSizes } : {}
+  }));
+  await writeText(path5.join(segmentsDir, "_tree.segment.rsc"), compat.rootTreePrefetchText(tree, "flight"));
+}
+function staleTimeFromRouteSources(route) {
+  let found;
+  for (const file of route.sourceFiles) {
+    if (!existsSync4(file))
+      continue;
+    const source = readTextSync(file);
+    for (const literal of source.matchAll(/cacheLife\s*\(\s*\{[^}]*\bstale\s*:\s*([^,}]+)/gs)) {
+      const value = staticNumberExpression(literal[1]);
+      if (value !== undefined)
+        found = minDefined(found, value);
+    }
+    for (const named of source.matchAll(/cacheLife\s*\(\s*['"]([^'"]+)['"]\s*\)/g)) {
+      const namedValue = builtInCacheLifeStale(named[1]);
+      if (namedValue !== undefined)
+        found = minDefined(found, namedValue);
+    }
+  }
+  return found;
+}
+function readTextSync(file) {
+  try {
+    return existsSync4(file) && statSync2(file).isFile() ? readFileSync4(file, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+function staticNumberExpression(expression) {
+  const trimmed = expression.trim();
+  if (/^\d+(?:\.\d+)?$/.test(trimmed))
+    return Number(trimmed);
+  const product = trimmed.split("*").map((part) => part.trim());
+  if (product.length > 1 && product.every((part) => /^\d+(?:\.\d+)?$/.test(part))) {
+    return product.reduce((value, part) => value * Number(part), 1);
+  }
+  return;
+}
+function builtInCacheLifeStale(profile) {
+  switch (profile) {
+    case "seconds":
+      return;
+    case "default":
+    case "minutes":
+    case "hours":
+    case "days":
+    case "weeks":
+    case "max":
+      return 300;
+    default:
+      return;
+  }
+}
+function builtInCacheLifeExpire(profile) {
+  switch (profile) {
+    case "seconds":
+      return 60;
+    case "minutes":
+      return 3600;
+    case "hours":
+      return 86400;
+    case "days":
+      return 604800;
+    case "weeks":
+      return 2592000;
+    case "default":
+    case "max":
+      return 31536000;
+    default:
+      return;
+  }
+}
+function minDefined(a, b) {
+  if (a === undefined)
+    return b;
+  if (b === undefined)
+    return a;
+  return Math.min(a, b);
+}
+async function writeNestedSegment(root, relative, body) {
+  const file = path5.join(root, relative);
+  await mkdir4(path5.dirname(file), { recursive: true });
+  await writeText(file, body);
+}
+function nextAppRoutePath(route) {
+  return route.replace(/^\/+/, "") || "index";
+}
+function shellRendersContentOutsideHoles(shell) {
+  const open = /<body[^>]*>/.exec(shell);
+  if (!open)
+    return false;
+  const rest = shell.slice(open.index + open[0].length);
+  const body = rest.split("</body>")[0] ?? "";
+  const outside = stripBalanced(body, "pnext-suspense").replace(/<(script|template|style)[^>]*>[\s\S]*?<\/\1>/g, "").replace(/<!--[\s\S]*?-->/g, "");
+  if (/<(img|svg|video|canvas|input)[\s>]/.test(outside))
+    return true;
+  return outside.replace(/<[^>]*>/g, "").trim().length > 0;
+}
+function shellHolesRenderFallbackContent(shell) {
+  const open = /<body[^>]*>/.exec(shell);
+  if (!open)
+    return false;
+  const body = (shell.slice(open.index + open[0].length).split("</body>")[0] ?? "").replace(/<(script|template|style)[^>]*>[\s\S]*?<\/\1>/g, "").replace(/<!--[\s\S]*?-->/g, "");
+  const outside = stripBalanced(body, "pnext-suspense");
+  const text = (h) => h.replace(/<[^>]*>/g, "").trim().length;
+  const media = (h) => /<(img|svg|video|canvas|input)[\s>]/.test(h);
+  return text(body) - text(outside) > 0 || media(body) && !media(outside);
+}
+function stripBalanced(html, tag) {
+  const open = new RegExp(`<${tag}[\\s>]`, "g");
+  const boundary = new RegExp(`<${tag}[\\s>]|</${tag}>`, "g");
+  let out = "";
+  let cursor = 0;
+  for (let start = open.exec(html);start; start = open.exec(html)) {
+    if (start.index < cursor)
+      continue;
+    out += html.slice(cursor, start.index);
+    boundary.lastIndex = start.index + 1;
+    let depth = 1;
+    let end = html.length;
+    for (let hit = boundary.exec(html);hit; hit = boundary.exec(html)) {
+      depth += hit[0].startsWith("</") ? -1 : 1;
+      if (depth === 0) {
+        end = hit.index + hit[0].length;
+        break;
+      }
+    }
+    cursor = end;
+    open.lastIndex = cursor;
+  }
+  return out + html.slice(cursor);
+}
+async function buildCacheComponentsShell(config, route) {
+  const url = new URL(`http://pnext.local${route.route}`);
+  const hasDynamicParams = route.params.length > 0 || Boolean(route.catchAll);
+  beginShellSourceTracking();
+  let renderResult;
+  try {
+    renderResult = await renderShellWithCacheMeta(config, route, () => hasDynamicParams ? renderFallbackShell({ config, route, url }) : renderPartialShell({ config, route, url }));
+  } finally {
+    abortActivePrerenderScopes();
+  }
+  const { prebuilt, meta } = renderResult;
+  const shellSources = endShellSourceTracking();
+  const baseShellIsEmpty = prebuilt === null || prebuilt.holes.length > 0 && !prebuilt.metadataDynamic && !shellSources.cacheIO && !shellSources.nonParamsRequest && !(meta.cacheLife === undefined && (shellRendersContentOutsideHoles(prebuilt.shell) || shellHolesRenderFallbackContent(prebuilt.shell))) && !(hasDynamicParams && routeSourcesUseRequestApi(config.root, route));
+  if (!baseShellIsEmpty) {
+    route.ppr = true;
+    route.pprHoles = prebuilt.holes;
+    route.pprMetadata = prebuilt.metadataDynamic || undefined;
+    persistRouteCacheLife(route, meta.cacheLife);
+    recordRouteCacheTags(route, meta.tags);
+    if (meta.linkHeader)
+      route.linkHeader = meta.linkHeader;
+    const file = pprShellPath(config.outPath, route.id);
+    await mkdir4(path5.dirname(file), { recursive: true });
+    await writeText(file, prebuilt.shell);
+    let fallbackStatus;
+    if (!hasDynamicParams && routeSourcesUseHttpFallback(config.root, route)) {
+      try {
+        const probe = await runWithWorkUnit("render", () => getRenderExtensions().collectRenderMeta(() => runWithNextBuildPhase(() => renderPageWithStatus({ config, route, params: {}, url })), { route: route.route || "/", prerender: true }).then((result) => result.value));
+        if (probe.status !== 200)
+          fallbackStatus = probe.status;
+      } catch {}
+    }
+    const prefetchBody = await renderPrefetchBody(config, route, () => hasDynamicParams ? renderFallbackShell({ config, route, url, prefetchShell: true }) : renderPartialShell({ config, route, url, prefetchShell: true })) ?? { prebuilt, vary: renderResult.vary };
+    await emitSegmentArtifacts(config, route, prefetchBody.prebuilt.shell, prefetchBody.prebuilt.holes.length > 0, meta, fallbackStatus, prefetchBody.vary, true);
+    if (hasDynamicParams && route.hasStaticParams) {
+      await buildSubShells(config, route);
+    }
+    return true;
+  }
+  if (hasDynamicParams && route.hasStaticParams && (await hasPartialStaticPrefix(config, route) || cacheComponents() && routeSourcesUseRequestApi(config.root, route) && await hasFullStaticParamSet(config, route))) {
+    route.ppr = true;
+    route.pprMetadata = prebuilt?.metadataDynamic || undefined;
+    if (prebuilt) {
+      persistRouteCacheLife(route, meta.cacheLife);
+      recordRouteCacheTags(route, meta.tags);
+      if (meta.linkHeader)
+        route.linkHeader = meta.linkHeader;
+    }
+    await buildSubShells(config, route);
+    return true;
+  }
+  return false;
+}
+async function hasPartialStaticPrefix(config, route) {
+  if (!route.hasStaticParams)
+    return false;
+  let staticParams;
+  try {
+    staticParams = await staticParamsFor(config, route);
+  } catch {
+    return false;
+  }
+  const paramKeys = [...route.params, ...route.catchAll ? [route.catchAll] : []];
+  for (const set of staticParams.allSets) {
+    let filled = 0;
+    while (filled < paramKeys.length && set[paramKeys[filled]] !== undefined)
+      filled++;
+    if (filled > 0 && filled < paramKeys.length)
+      return true;
+  }
+  return false;
+}
+async function hasFullStaticParamSet(config, route) {
+  if (!route.hasStaticParams)
+    return false;
+  let staticParams;
+  try {
+    staticParams = await staticParamsFor(config, route);
+  } catch {
+    return false;
+  }
+  const paramKeys = [...route.params, ...route.catchAll ? [route.catchAll] : []];
+  if (paramKeys.length === 0)
+    return false;
+  return staticParams.allSets.some((set) => paramKeys.every((key) => set[key] !== undefined));
+}
+async function buildSubShells(config, route) {
+  let staticParams;
+  try {
+    staticParams = await staticParamsFor(config, route);
+  } catch {
+    return;
+  }
+  route.prerenderedParams = staticParams.allSets;
+  const paramKeys = [...route.params, ...route.catchAll ? [route.catchAll] : []];
+  const prefixes = new Map;
+  for (const set of staticParams.allSets) {
+    let filled = 0;
+    while (filled < paramKeys.length && set[paramKeys[filled]] !== undefined)
+      filled++;
+    if (filled === 0)
+      continue;
+    const concrete = {};
+    for (let i = 0;i < filled; i++)
+      concrete[paramKeys[i]] = set[paramKeys[i]];
+    const key = subShellKey(concrete);
+    if (!prefixes.has(key))
+      prefixes.set(key, concrete);
+  }
+  if (prefixes.size === 0)
+    return;
+  const subShells = [];
+  for (const [key, concreteParams] of prefixes) {
+    const routePath = fillRoutePath(route.route, concreteParams);
+    const url = new URL(`http://pnext.local${routePath}`);
+    const { value: prebuilt, tags } = await runWithWorkUnit("render", () => getRenderExtensions().collectRenderMeta(() => runWithNextBuildPhase(() => renderSubShell({ config, route, url, concreteParams, paramKeys })), { fetchCache: route.segmentConfig?.fetchCache, route: routePath || "/", prerender: true }));
+    recordRouteCacheTags(route, tags);
+    if (!prebuilt)
+      continue;
+    const file = pprSubShellPath(config.outPath, route.id, key);
+    await mkdir4(path5.dirname(file), { recursive: true });
+    await writeText(file, prebuilt.shell);
+    subShells.push({ key, concreteParams, holes: prebuilt.holes });
+    if (Object.keys(concreteParams).length === paramKeys.length) {
+      try {
+        const probe = await runWithWorkUnit("render", () => getRenderExtensions().collectRenderMeta(() => runWithNextBuildPhase(() => renderPageWithStatus({
+          config,
+          route,
+          params: encodeStaticRouteParams(concreteParams),
+          url
+        })), { route: routePath || "/", prerender: true }).then((result) => result.value));
+        const postponed = prebuilt.holes.length > 0 || prebuilt.metadataDynamic || route.pprMetadata === true || routeSourcesHaveDynamicHead(route);
+        await emitConcreteNextPageArtifacts(config, route, routePath, {
+          html: postponed ? prebuilt.shell : `${prebuilt.shell}
+  </body></html>`,
+          status: probe.status,
+          postponed
+        });
+      } catch {}
+    }
+  }
+  subShells.sort((a, b) => Object.keys(b.concreteParams).length - Object.keys(a.concreteParams).length);
+  if (subShells.length > 0)
+    route.pprSubShells = subShells;
+}
+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))
+      continue;
+    const source = readTextSync(file);
+    if (/\b(?:notFound|forbidden|unauthorized)\s*\(\s*\)/.test(source))
+      return true;
+  }
+  return false;
+}
+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))
+      continue;
+    const source = readTextSync(file).replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+    if (/\b(?:connection|cookies|headers|draftMode)\s*\(\s*\)/.test(source))
+      return true;
+  }
+  return false;
+}
+function routeSourcesHaveDynamicHead(route) {
+  for (const file of route.sourceFiles) {
+    if (!existsSync4(file))
+      continue;
+    const source = readTextSync(file);
+    const match = /export\s+(?:async\s+)?function\s+(?:generateMetadata|generateViewport)\s*\([^)]*\)\s*(?::[^{]+)?\{/.exec(source);
+    if (!match)
+      continue;
+    const body = source.slice(match.index + match[0].length);
+    if (/\bawait\b/.test(body.split(`
+export `)[0] ?? body) && !body.includes("use cache")) {
+      return true;
+    }
+  }
+  return false;
+}
+function filterDebugBuildRoutes(root, routes, patterns) {
+  const matchers = patterns.split(",").map((pattern) => pattern.trim()).filter((pattern) => pattern.length > 0 && !pattern.startsWith("!")).map(debugBuildPathMatcher);
+  if (matchers.length === 0)
+    return routes;
+  return routes.filter((route) => {
+    const relative = toPosixPath(path5.relative(root, route.file));
+    return matchers.some((matcher) => matcher(relative));
+  });
+}
+function debugBuildPathMatcher(pattern) {
+  if (!/[*?]/.test(pattern)) {
+    return (file) => file === pattern || file.endsWith(`/${pattern}`);
+  }
+  const regex = new RegExp(`^${pattern.split(/(\*\*\/|\*\*|\*|\?)/).map((part) => {
+    if (part === "**/")
+      return "(?:.*/)?";
+    if (part === "**")
+      return ".*";
+    if (part === "*")
+      return "[^/]*";
+    if (part === "?")
+      return "[^/]";
+    return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("")}$`);
+  return (file) => regex.test(file);
+}
+function subShellKey(concrete) {
+  return Object.entries(concrete).map(([k, v]) => `${k}-${(Array.isArray(v) ? v.join("_") : v).replace(/[^a-zA-Z0-9_]/g, "_")}`).join(".");
+}
+async function buildProxyModule(config) {
+  await validateProxyFiles(config);
+  const file = findProxyFile(config);
+  if (!file)
+    return;
+  const href = await devServerModuleHref(config, file, "prod", {
+    conditionTarget: "edge",
+    externalLoadTarget: proxyExternalLoadTarget(file),
+    reactServerLayer: true
+  });
+  const compiled = fileURLToPath3(href);
+  return toPosixPath(path5.relative(config.outPath, compiled));
+}
+async function renderNotFoundDocuments({
+  config,
+  log,
+  skip,
+  documentCss,
+  staticMetadataFiles,
+  staticModuleMetadata
+}) {
+  if (skip)
+    return;
+  const render = async () => {
+    const response = await renderGlobalNotFoundResponse({
+      config,
+      url: new URL("http://pnext.local/_not-found"),
+      staticMetadataFiles,
+      staticModuleMetadata
+    });
+    return response.text();
+  };
+  await documentCss;
+  if (await shouldBuildGlobalNotFound(config)) {
+    await log.step("global not-found", async () => writeText(path5.join(config.outPath, "public", "404.html"), await render()));
+  }
+  if (!config.compat?.next)
+    return;
+  if (existsSync4(path5.join(config.outPath, "public", "404.html")))
+    return;
+  return defaultNotFoundDocument();
+}
+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));
+  if (!file)
+    return false;
+  return !/\bexport\s+const\s+dynamic\s*=\s*['"]force-dynamic['"]/.test(await readText(file));
+}
+async function emitProxyServerArtifacts(config, proxyModule) {
+  if (!config.compat?.next || !proxyModule)
+    return;
+  const compiled = path5.resolve(config.outPath, proxyModule);
+  if (!existsSync4(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 })}
+`);
+}
+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;
+  if (html === undefined)
+    return;
+  const serverDir = path5.join(config.root, ".next", "server");
+  const pagesDir = path5.join(serverDir, "pages");
+  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);
+  const pagesManifestFile = path5.join(serverDir, "pages-manifest.json");
+  let pagesManifest = {};
+  try {
+    pagesManifest = JSON.parse(readFileSync4(pagesManifestFile, "utf8"));
+  } catch {}
+  pagesManifest["/404"] = "pages/404.html";
+  await writeFile3(pagesManifestFile, `${JSON.stringify(pagesManifest, null, 2)}
+`);
+  const clientReferenceManifest = "page_client-reference-manifest.js";
+  await writeFile3(path5.join(notFoundDir, clientReferenceManifest), `self.__RSC_MANIFEST={}
+`);
+  await writeFile3(path5.join(notFoundDir, "page.js.nft.json"), `${JSON.stringify({ version: 1, files: [clientReferenceManifest] }, null, 2)}
+`);
+}
+async function collectStaticModuleMetadata(config, routes) {
+  const metadata = {};
+  if (config.compat?.next)
+    return metadata;
+  const files = new Set;
+  for (const route of routes) {
+    if (route.kind !== "page")
+      continue;
+    for (const file of findLayouts(config.appPath, route.file)) {
+      if (existsSync4(file))
+        files.add(file);
+    }
+    files.add(route.file);
+  }
+  if (files.size === 0)
+    return metadata;
+  registerServerRuntime(config, [...files]);
+  registerCssRuntime();
+  for (const file of files) {
+    const href = reactCompatEnabled(config) ? await devServerModuleHref(config, file, "build") : pathToFileHref(file);
+    const module = await import(href);
+    const entry = {};
+    const routeMetadata = await readModuleMetadata(module);
+    const viewport = await readModuleViewport(module);
+    if (routeMetadata)
+      entry.metadata = routeMetadata;
+    if (viewport)
+      entry.viewport = viewport;
+    if (entry.metadata || entry.viewport)
+      metadata[file] = entry;
+  }
+  return metadata;
+}
+async function collectStaticRouteMetadata(config, routes, staticMetadataFiles) {
+  const metadata = {};
+  if (config.compat?.next)
+    return metadata;
+  for (const route of routes) {
+    if (route.kind !== "page" || route.interception)
+      continue;
+    const paramSets = route.prerenderedParams ?? (route.params.length === 0 ? [{}] : []);
+    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;
+    }
+  }
+  return metadata;
+}
+async function importMetadataModule(config, file) {
+  const href = reactCompatEnabled(config) ? await devServerModuleHref(config, file, "build") : pathToFileHref(file);
+  return import(href);
+}
+async function buildStaticRouteHandler(config, route, options = {}) {
+  const skipPhysicalWrite = options.skipPhysicalWrite ?? false;
+  registerServerRuntime(config, route.sourceFiles);
+  const moduleHref = reactCompatEnabled(config) ? await devServerModuleHref(config, route.file, "build", {
+    conditionTarget: serverBundleTargetForRuntime(route.segmentConfig?.runtime)
+  }) : pathToFileHref(route.file);
+  const imported = await import(moduleHref);
+  const routeModule = metadataRouteHandlerModule(imported, route) ?? imported;
+  const module = nextCompatEnabled2(config) ? buildCompat().normalizeStaticParamsModule(routeModule) : routeModule;
+  const paramSets = await staticRouteParams(route, module);
+  const staticFiles = {};
+  if (route.metadataRoute?.generatedParam && paramSets.length > 0) {
+    route.metadataRoute.generatedRoutes = paramSets.map((params) => fillRoutePath(route.route, params, route.metadataRoute?.generatedParam));
+  }
+  const requestBase = route.segmentConfig?.dynamic === "force-static" ? "http://localhost:3000" : "http://pnext.local";
+  for (const params of paramSets) {
+    const routePath = fillRoutePath(route.route, params, route.metadataRoute?.generatedParam);
+    const file = staticRouteHandlerPath(config.outPath, routePath);
+    if (!skipPhysicalWrite) {
+      const collision = staticOutputCollision(config.outPath, file);
+      if (collision) {
+        warnSkippedStatic(routePath, collision);
+        continue;
+      }
+    }
+    const prerender = runWithWorkUnit("render", () => getRenderExtensions().collectRenderMeta(() => runWithCacheScope(() => runWithNextBuildPhase(() => withRouteRuntime(route.segmentConfig?.runtime, () => handleRouteModule(module, new Request(`${requestBase}${routePath}`), params, {
+      routeFile: route.file
+    })))), {
+      fetchCache: route.segmentConfig?.fetchCache,
+      route: routePath || "/",
+      prerender: true,
+      handler: true,
+      dynamicError: route.segmentConfig?.dynamic === "error"
+    }));
+    const early = await settleBeforeNextTask(prerender);
+    const completed = early ?? await prerender;
+    const rendered = early ?? (route.segmentConfig?.dynamic === "force-static" || await handlerHasEntirelyCachedIo(route) ? completed : undefined);
+    if (!rendered)
+      continue;
+    const response = rendered.value;
+    if (response.status >= 500) {
+      throw new Error(`route handler prerender returned ${response.status}`);
+    }
+    if (rendered.noStore && !staticRouteHandlerExplicitlyCached(route))
+      continue;
+    const body = await settleBeforeNextTask(response.clone().arrayBuffer());
+    if (!body)
+      continue;
+    const relative = toPosixPath(path5.relative(path5.join(config.outPath, "public"), file));
+    if (!skipPhysicalWrite) {
+      await mkdir4(path5.dirname(file), { recursive: true });
+      await writeFile3(file, new Uint8Array(body));
+    }
+    const revalidateSeconds = combineRevalidate(route.segmentConfig?.revalidate, rendered.revalidateSeconds);
+    staticFiles[relative] = {
+      status: response.status,
+      headers: [...response.headers.entries()],
+      routeId: route.id,
+      ...revalidateSeconds !== undefined ? { revalidateSeconds } : {},
+      ...rendered.tags.length > 0 ? { tags: rendered.tags } : {}
+    };
+  }
+  return staticFiles;
+}
+function settleBeforeNextTask(value) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled)
+        resolve(undefined);
+    }, 0);
+    value.then((result) => {
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    }, (error) => {
+      settled = true;
+      clearTimeout(timer);
+      reject(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+}
+async function handlerHasEntirelyCachedIo(route) {
+  if (route.synthetic || !existsSync4(route.file))
+    return false;
+  const source = await readText(route.file);
+  if (route.metadataRoute && metadataDefaultUsesCache(source))
+    return true;
+  const getStart = source.search(/\bexport\s+(?:async\s+)?function\s+GET\s*\(/);
+  if (getStart === -1)
+    return false;
+  const afterGet = source.slice(getStart);
+  const nextDeclaration = afterGet.slice(1).search(/^(?:async\s+)?(?:function|const|let)\s+/m);
+  const body = nextDeclaration === -1 ? afterGet : afterGet.slice(0, nextDeclaration + 1);
+  if (/\bnew\s+Date\s*\(\s*\)/.test(body) || /\bDate\s*\.\s*now\s*\(/.test(body)) {
+    return false;
+  }
+  const awaited = [...body.matchAll(/\bawait\s+([A-Za-z_$][\w$]*)\s*\(/g)].map((match) => match[1]);
+  if (awaited.length === 0)
+    return false;
+  const cached = new Set(["import"]);
+  for (const match of source.matchAll(/\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\s*\(/g)) {
+    if (match[2] === "cache" || match[2] === "unstable_cache")
+      cached.add(match[1]);
+  }
+  for (const match of source.matchAll(/\b(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{\s*['"]use cache['"]/g)) {
+    cached.add(match[1]);
+  }
+  for (const name of awaited) {
+    const start = source.search(new RegExp(`\\b(?:const\\s+${name}\\s*=|function\\s+${name}\\s*\\()`));
+    if (start === -1)
+      continue;
+    const tail = source.slice(start);
+    const next = tail.slice(1).search(/^(?:async\s+)?(?:function|const|let)\s+/m);
+    const declaration = next === -1 ? tail : tail.slice(0, next + 1);
+    if (/\bcache\s*:\s*['"]force-cache['"]/.test(declaration))
+      cached.add(name);
+  }
+  return awaited.every((name) => cached.has(name));
+}
+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))
+    return false;
+  const source = await readText(route.file);
+  const localNames = [];
+  const dynamicNames = [];
+  for (const match of source.matchAll(/\bimport\s*\{([^}]*)\}\s*from\s*['"]next\/(cache|headers|server)(?:\.js)?['"]/g)) {
+    for (const item of match[1].split(",")) {
+      const [imported, local] = item.trim().split(/\s+as\s+/);
+      if (match[2] === "cache" && imported === "unstable_cache") {
+        localNames.push(local ?? imported);
+      } else if (match[2] === "headers" && (imported === "cookies" || imported === "headers") || match[2] === "server" && imported === "connection") {
+        dynamicNames.push(local ?? imported);
+      }
+    }
+  }
+  if (dynamicNames.length === 0)
+    return false;
+  const dynamicCall = dynamicNames.join("|");
+  return localNames.some((name) => new RegExp(`\\b${name}\\s*\\(\\s*(?:async\\s*)?(?:\\([^)]*\\)|[A-Za-z_$][\\w$]*)?\\s*=>[\\s\\S]{0,1000}?\\b(?:${dynamicCall})\\s*\\(`).test(source));
+}
+async function staticHandlerDynamicUsage(route) {
+  if (!route.usesRequest)
+    return;
+  if (route.segmentConfig?.dynamic === "force-static" || route.segmentConfig?.dynamic === "error") {
+    return;
+  }
+  if (route.synthetic || !existsSync4(route.file))
+    return;
+  const source = await readText(route.file);
+  if (/\b(?:request|req)\.url\b/.test(source))
+    return "request.url";
+  if (/\bnextUrl\s*\.\s*toString\s*\(/.test(source))
+    return "nextUrl.toString";
+  if (/\bheaders\s*\(/.test(source))
+    return "headers()";
+  if (/\bcookies\s*\(/.test(source))
+    return "cookies()";
+  if (/\bconnection\s*\(/.test(source))
+    return "connection()";
+  return;
+}
+function collectDescendantHandlerIds(routes) {
+  const ids = new Set;
+  const paths = routes.map((route) => ({ route, norm: (route.route || "/").replace(/\/+$/, "") }));
+  for (const { route, norm } of paths) {
+    if (route.kind !== "handler")
+      continue;
+    const hasAncestor = paths.some((other) => other.route !== route && other.norm.length > 0 && norm !== other.norm && norm.startsWith(`${other.norm}/`));
+    if (hasAncestor)
+      ids.add(route.id);
+  }
+  return ids;
+}
+async function staticRouteHandlerCandidate(route) {
+  const config = route.segmentConfig;
+  if (config?.dynamic === "force-dynamic")
+    return false;
+  if (config?.revalidate === 0)
+    return false;
+  if (config?.fetchCache === "force-no-store")
+    return false;
+  if (route.handlerUsesRevalidationApi)
+    return false;
+  if (route.metadataRoute)
+    return !route.usesRequest;
+  if (config?.dynamic === "error")
+    return true;
+  if (config?.dynamic === "force-static")
+    return true;
+  if (staticRouteHandlerExplicitlyCached(route) || route.hasStaticParams)
+    return true;
+  if (route.usesRequest)
+    return false;
+  if (!cacheComponents() || route.mode !== "static")
+    return false;
+  if (!handlerUsesUncachedIo(route))
+    return true;
+  return handlerHasEntirelyCachedIo(route);
+}
+function handlerUsesUncachedIo(route) {
+  const source = readTextSync(route.file);
+  if (!source)
+    return false;
+  return /\bnew Date\s*\(|\bDate\.now\s*\(|\bMath\.random\s*\(/.test(stripUseCacheBodies(source));
+}
+function stripUseCacheBodies(source) {
+  let out = source;
+  for (;; ) {
+    const directive = /\{\s*(['"])use cache(?:\s*:\s*[\w-]+)?\1\s*;?/.exec(out);
+    if (!directive)
+      break;
+    const bodyOpen = directive.index + 1;
+    let balance = 1;
+    let end = out.length;
+    for (let i = bodyOpen;i < out.length; i += 1) {
+      const ch = out[i];
+      if (ch === "{")
+        balance += 1;
+      else if (ch === "}") {
+        balance -= 1;
+        if (balance === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    out = `${out.slice(0, bodyOpen)}${out.slice(end)}`;
+  }
+  return out;
+}
+function staticRouteHandlerExplicitlyCached(route) {
+  const config = route.segmentConfig;
+  return config?.dynamic === "force-static" || config?.revalidate === false || typeof config?.revalidate === "number" && config.revalidate > 0;
+}
+async function needsRequestOriginForMetadataImages(appPath, route) {
+  if (!await routeNullsMetadataBase(route))
+    return false;
+  return routeMetadataImageFiles(appPath, route.file);
+}
+async function routeNullsMetadataBase(route) {
+  const sourceFiles = route.sourceFiles.filter((file) => /\.(tsx?|jsx?|mjs|cjs)$/.test(file));
+  for (const file of sourceFiles) {
+    try {
+      if (/\bmetadataBase\s*:\s*null\b|\bmetadataBase\s*=\s*null\b/.test(await readText(file))) {
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+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 (/^(opengraph-image|twitter-image)\d*\.(tsx?|jsx?|mjs|png|jpe?g|gif|webp|svg)$/.test(entry)) {
+          return true;
+        }
+      }
+    }
+    if (dir === root)
+      break;
+    dir = path5.dirname(dir);
+  }
+  return false;
+}
+async function copyStaticMetadataFiles(config, staticFiles, metadataFiles = discoverStaticMetadataFiles(config.appPath)) {
+  for (const metadataFile of metadataFiles) {
+    const target = staticMetadataOutputFile(config.outPath, metadataFile);
+    const collision = staticOutputCollision(config.outPath, target);
+    if (collision) {
+      warnSkippedStatic(`/${metadataFile.outputPath}`, collision);
+      continue;
+    }
+    await mkdir4(path5.dirname(target), { recursive: true });
+    await copyFile2(metadataFile.file, target);
+    staticFiles[metadataFile.outputPath] = {
+      status: 200,
+      headers: [
+        ["content-type", metadataFile.contentType],
+        ["cache-control", staticMetadataCacheControl]
+      ]
+    };
+  }
+}
+function staticHtmlPath(outPath, routePath, flatLayout = false) {
+  if (routePath === "/")
+    return path5.join(outPath, "public", "index.html");
+  const normalized = routePath.replace(/^\/|\/$/g, "");
+  if (flatLayout)
+    return safePublicPath(outPath, `${normalized}.html`);
+  return safePublicPath(outPath, normalized, "index.html");
+}
+function encodeStaticRouteParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [
+    key,
+    Array.isArray(value) ? value.map(encodeURIComponent) : encodeURIComponent(value)
+  ]));
+}
+function fillRoutePath(route, params, generatedParam) {
+  let value = route;
+  for (const [key, param] of Object.entries(params)) {
+    const segment = Array.isArray(param) ? param.join("/") : param;
+    value = value.replace(`:${key}*`, segment).replace(`:${key}`, segment);
+  }
+  if (generatedParam && params[generatedParam] !== undefined) {
+    const param = params[generatedParam];
+    const segment = Array.isArray(param) ? param.join("/") : param;
+    value = value.replace(":id", segment);
+  }
+  return value;
+}
+async function runWithNextBuildPhase(task) {
+  const previous = process.env.NEXT_PHASE;
+  process.env.NEXT_PHASE = "phase-production-build";
+  try {
+    return await task();
+  } finally {
+    if (previous === undefined)
+      delete process.env.NEXT_PHASE;
+    else
+      process.env.NEXT_PHASE = previous;
+  }
+}
+function cacheLifeResponseHeaders(life) {
+  if (!life)
+    return [];
+  const headers = [];
+  const { revalidateSeconds, expireSeconds, staleSeconds } = life;
+  if (revalidateSeconds !== undefined && expireSeconds !== undefined) {
+    const swr = Math.max(0, expireSeconds - revalidateSeconds);
+    headers.push(["cache-control", `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`]);
+  }
+  if (staleSeconds !== undefined) {
+    headers.push(["x-nextjs-stale-time", String(staleSeconds)]);
+  }
+  return headers;
+}
+function combineRevalidate(segmentRevalidate, collected) {
+  const candidates = [
+    ...typeof segmentRevalidate === "number" && segmentRevalidate > 0 ? [segmentRevalidate] : [],
+    ...collected !== undefined && collected > 0 ? [collected] : []
+  ];
+  if (candidates.length === 0)
+    return;
+  return Math.min(...candidates);
+}
+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()) {
+    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 (!statSync2(dir).isDirectory()) {
+        return `${toPosixPath(path5.relative(publicPath, dir))} already exists as a file`;
+      }
+      break;
+    }
+    dir = path5.dirname(dir);
+  }
+  return null;
+}
+function rethrowIfProgrammingError(error) {
+  if (error instanceof ReferenceError || error instanceof SyntaxError || error instanceof TypeError && isBuildInternalStack(error)) {
+    throw error;
+  }
+}
+function isBuildInternalStack(error) {
+  const stack = error.stack ?? "";
+  const firstFrame = stack.split(`
+`).find((line) => /^\s*at\s/.test(line)) ?? "";
+  return /packages[/\\]pnext[/\\]src[/\\]/.test(firstFrame);
+}
+function logStaticBailout(routePath, reason) {
+  console.log(`Static generation failed due to dynamic usage on ${routePath}, reason: ${reason}`);
+}
+async function requestApiBailoutReason(route) {
+  for (const file of ownSourceFiles(route)) {
+    let source;
+    try {
+      source = await readText(file);
+    } catch {
+      continue;
+    }
+    const match = /\b(headers|cookies|draftMode|connection)\s*\(/.exec(source);
+    if (match?.[1])
+      return match[1];
+  }
+  return "dynamic usage";
+}
+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);
+  });
+}
+async function schedulesDeferredWork(route) {
+  for (const file of ownSourceFiles(route)) {
+    let source;
+    try {
+      source = await readText(file);
+    } catch {
+      continue;
+    }
+    if (/\b(?:setTimeout|setImmediate|queueMicrotask)\s*\(/.test(source))
+      return true;
+  }
+  return false;
+}
+function captureDeferredFailures(record) {
+  const globals = globalThis;
+  const originals = new Map;
+  for (const name of ["setTimeout", "setImmediate", "queueMicrotask"]) {
+    const original = globals[name];
+    if (typeof original !== "function")
+      continue;
+    originals.set(name, original);
+    globals[name] = function patched(callback, ...rest) {
+      if (typeof callback !== "function")
+        return original.call(this, callback, ...rest);
+      const guarded = function guardedCallback(...args) {
+        try {
+          const value = callback.apply(this, args);
+          if (isThenable(value))
+            value.then(undefined, record);
+          return value;
+        } catch (error) {
+          record(error);
+        }
+      };
+      return original.call(this, guarded, ...rest);
+    };
+  }
+  return () => {
+    for (const [name, original] of originals)
+      globals[name] = original;
+  };
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+async function probeDeferredDynamicUsage(config, route, staticMetadataFiles, staticModuleMetadata) {
+  const routePath = toNextRoutePattern(route.route || "/");
+  const failures = [];
+  const restore = captureDeferredFailures((error) => failures.push(error));
+  beginDynamicBailoutProbe(routePath);
+  try {
+    await runWithWorkUnit("render", () => getRenderExtensions().collectRenderMeta(() => runWithNextBuildPhase(() => withRouteRuntime(route.segmentConfig?.runtime, () => renderPageWithStatus({
+      config,
+      route,
+      params: {},
+      url: new URL(`http://pnext.local${route.route || "/"}`),
+      staticMetadataFiles,
+      staticModuleMetadata
+    }))), { route: route.route || "/", prerender: true }));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  } catch {
+    return;
+  } finally {
+    endDynamicBailoutProbe();
+    restore();
+  }
+  for (const failure of failures) {
+    if (!(failure instanceof Error) || failure.name !== "DynamicServerError")
+      continue;
+    console.error(`Error occurred prerendering page "${routePath}". Read more: https://nextjs.org/docs/messages/prerender-error`);
+    console.error(`${failure.name}: ${failure.message}`);
+  }
+}
+function warnSkippedStatic(routePath, reason) {
+  console.warn(`pnext build: skipping static output for ${routePath} (${reason}); the route will be served dynamically`);
+}
+function toNextRoutePattern(route) {
+  return route.replace(/:\.\.\.([^/]+)/g, "[...$1]").replace(/:([^/]+)/g, "[$1]");
+}
+function isAfterPrerenderError(error) {
+  return typeof error === "object" && error !== null && error[Symbol.for("pnext.afterPrerenderError")] === true;
+}
+function realFilePath(file) {
+  try {
+    return realpathSync3.native(file);
+  } catch {
+    return path5.resolve(file);
+  }
+}
+function safePublicPath(outPath, ...segments) {
+  const publicPath = path5.join(outPath, "public");
+  const file = path5.join(publicPath, ...segments);
+  const relative = path5.relative(publicPath, file);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
+    throw new Error(`Static output path escapes public directory: ${segments.join("/")}`);
+  }
+  return file;
+}
+async function copyPartytownLib(config) {
+  if (!nextCompatEnabled2(config))
+    return;
+  if (!buildCompat().nextScriptWorkersEnabled())
+    return;
+  const libDir = resolvePartytownLibDir(config.root);
+  if (!libDir) {
+    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");
+  await mkdir4(target, { recursive: true });
+  await copyPublicDir(libDir, target);
+}
+function resolvePartytownLibDir(root) {
+  const requireFromRoot = createRequire(path5.join(root, "package.json"));
+  for (const pkg of ["@qwik.dev/partytown", "@builder.io/partytown"]) {
+    try {
+      const pkgJson = requireFromRoot.resolve(`${pkg}/package.json`);
+      const libDir = path5.join(path5.dirname(pkgJson), "lib");
+      if (existsSync4(libDir) && statSync2(libDir).isDirectory())
+        return libDir;
+    } catch {}
+  }
+  return null;
+}
+async function copyPublicDir(from, to) {
+  const files = (await listFiles(from)).map((file) => toPosixPath(path5.relative(from, file)));
+  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);
+  }
+  return files;
+}
+export {
+  buildProject,
+  staticHtmlPath
+};