@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,3341 @@
+// @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-1pzm1hdy.js";
+import {
+  writeTypegen
+} from "./index-38xpdxwd.js";
+import {
+  handleRouteModule,
+  staticRouteParams
+} from "./index-qpwsgt3a.js";
+import {
+  addClientEntryReason,
+  assertNoServerActionsWithoutCompat,
+  materializeRouteFacts,
+  scanRoutes
+} from "./index-jn9rbhrx.js";
+import {
+  devServerModuleHref,
+  resetModuleGraphFailure,
+  setEmitCompiledSpecifiersManifest,
+  setReleaseCompile
+} from "./index-fjv96re1.js";
+import"./index-n4hxpng2.js";
+import"./index-x3yn4ywm.js";
+import {
+  cacheRoot as cacheRoot2,
+  compiledSourceGraph,
+  flushDevModuleCaches,
+  registerServerRuntime
+} from "./index-rjegyfx4.js";
+import"./index-0r5eqfc7.js";
+import"./index-3e075kny.js";
+import {
+  clientEntryName,
+  defaultNotFoundDocument,
+  discoverStaticMetadataFiles,
+  metadataRouteHandlerModule,
+  pprShellPath,
+  pprSubShellPath,
+  readModuleMetadata,
+  readModuleViewport,
+  renderFallbackShell,
+  renderGlobalNotFoundResponse,
+  renderPageWithStatus,
+  renderPartialShell,
+  renderSubShell,
+  staticMetadataCacheControl,
+  staticMetadataForPathFromFiles,
+  staticMetadataForRouteFromFiles,
+  staticMetadataOutputFile,
+  staticParamsFor,
+  staticRouteMetadataKey,
+  withDynamicMetadataRoutes
+} from "./index-x2m17v9c.js";
+import {
+  findLayouts
+} from "./index-8ct7rqy3.js";
+import {
+  findProxyFile,
+  proxyExternalLoadTarget,
+  proxyRoutePatterns,
+  validateProxyFiles
+} from "./index-3ycf5ckv.js";
+import {
+  serverBundleTargetForRuntime,
+  throwIfModuleGraphFailed
+} from "./index-0yjv5v47.js";
+import"./index-yrjkqtfj.js";
+import"./index-jbj7ehef.js";
+import {
+  buildGlobalCss,
+  buildNotFoundCss,
+  buildRouteStylesheets,
+  globalCssSources,
+  prepareRouteCssChunks,
+  warmCssPipeline
+} from "./index-n629dy38.js";
+import {
+  createVerboseLogger
+} from "./index-73z4esab.js";
+import {
+  emittedAssetNames,
+  registerCssRuntime
+} from "./index-d158y67j.js";
+import {
+  nextCompatEnabled
+} from "./index-web361b8.js";
+import"./index-knp0s912.js";
+import {
+  frameworkFingerprint
+} from "./index-gcmj16xy.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-29pq0kax.js";
+import {
+  interceptionMarkerLevels
+} from "./index-cn86z041.js";
+import {
+  ensureEmptyDir,
+  listFiles,
+  readText,
+  resolveManifest,
+  serializeBuildManifest,
+  toPosixPath,
+  writeFileAtomic,
+  writeText
+} from "./index-4da76t62.js";
+import {
+  cacheRoot,
+  namedBunBinary
+} from "./index-cyfednwb.js";
+import"./index-vz0km5qk.js";
+import {
+  bootstrapCompat
+} from "./index-tq3b39a5.js";
+import {
+  devOutSegment,
+  frameworkRuntimeSpecifiers,
+  loadConfig,
+  pathToFileHref
+} from "./index-71885zaq.js";
+import {
+  outCachePath
+} from "./index-bzd2ef7t.js";
+import"./index-jcsjq3d1.js";
+import {
+  PREBUNDLE_STAMP,
+  buildIndexFile,
+  buildManifestFile,
+  prebundledFile,
+  readBuildIndex,
+  readPrebundleStamp,
+  releaseSourceFile,
+  standaloneOriginsFile
+} from "./index-hdbwtdv2.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 {
+  importMetaRefs,
+  moduleSpecifierEdges,
+  scanFactsStats,
+  spliceSource
+} from "./index-x9c55pzy.js";
+import"./index-d1jsmhhk.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import {
+  splitResourceQuery
+} from "./index-jt8e1pje.js";
+import {
+  buildParallelPhaseError,
+  clearBuildParallelPhases,
+  getBuildExtensions,
+  getCompatModeExtensions,
+  getRenderExtensions,
+  runInitHooks,
+  withRouteRuntime
+} from "./index-zqpqyg8p.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+import"./index-4399bvd2.js";
+import"./index-rt9qq1va.js";
+
+// src/cli/build.ts
+import { copyFile as copyFile3, mkdir as mkdir4, rename as rename3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync3, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/cli/adapters/vercel.ts
+import { copyFile, cp, mkdir, readFile, readdir, rename, rm } from "fs/promises";
+import { constants, existsSync, readdirSync } from "fs";
+import path from "path";
+var SERVER_FUNCTION = "_pnext";
+var FUNCTION_PLATFORM = {
+  architecture: "x86_64",
+  os: "linux",
+  cpu: "x64",
+  libc: "glibc"
+};
+var functionDroppedPackages = [/^sharp$/, /^@img\/sharp-libvips/];
+async function writeVercelOutput(config, manifest, options = {}) {
+  const log = createVerboseLogger(options.verbose ?? false, "vercel");
+  const outputPath = path.join(config.root, ".vercel", "output");
+  const staticPath = path.join(config.outPath, "static");
+  const staticFiles = manifest.staticFiles ?? {};
+  await log.step("prepare output directory", () => emptyDir(outputPath));
+  const functionPath = path.join(outputPath, "functions", `${SERVER_FUNCTION}.func`);
+  await writeServerFunction(config.outPath, manifest, functionPath, log);
+  await log.step("copy static files", () => copyStaticFiles(staticPath, path.join(outputPath, "static"), (relative) => !staticFiles[relative] || canServeStaticOnVercel(staticFiles[relative])));
+  const overrides = await staticOverrides(staticPath, staticFiles);
+  const routes = [
+    ...compatStaticRewrite(config, outputPath),
+    ...await immutableAssetRoutes(staticPath, 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(path.join(outputPath, "config.json"), `${JSON.stringify(vercelConfig, null, 2)}
+`);
+}
+async function emptyDir(dir) {
+  const parent = path.dirname(dir);
+  await mkdir(parent, { recursive: true });
+  const staleMarker = `${path.basename(dir)}.stale-`;
+  if (existsSync(dir)) {
+    await rename(dir, path.join(parent, `${staleMarker}${process.pid.toString(36)}-${Date.now().toString(36)}`));
+  }
+  const stale = readdirSync(parent).filter((entry) => entry.startsWith(staleMarker)).map((entry) => path.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 = path.join(outputPath, "static");
+  const names = readdirSyncSafe(path.join(staticDir, "assets")).filter((name) => !existsSync(path.join(staticDir, "_next", "static", name)));
+  if (names.length === 0)
+    return [];
+  const alternation = names.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return [{ src: `^/_next/static/(${alternation})(/.*)?$`, dest: "/assets/$1$2", continue: true }];
+}
+function readdirSyncSafe(dir) {
+  return existsSync(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(standalonePath, manifest, functionPath, log) {
+  await mkdir(path.dirname(functionPath), { recursive: true });
+  await log.step("copy standalone", () => cp(standalonePath, functionPath, { recursive: true, verbatimSymlinks: true }));
+  const modules = path.join(functionPath, "node_modules");
+  const packages = await packageDirs(modules);
+  await Promise.all([...packages].filter(([name]) => functionDroppedPackages.some((pattern) => pattern.test(name))).map(([, dirs]) => Promise.all(dirs.map((dir) => rm(dir, { recursive: true, force: true })))));
+  await log.step("platform natives", () => replaceHostNatives(packages, log));
+  await writeText(path.join(functionPath, "index.mjs"), `import { createRequestHandler } from './server/entry.js';
+
+const handlerPromise = createRequestHandler({ root: import.meta.dirname });
+
+async function handler(request) {
+  return (await handlerPromise)(request);
+}
+
+// Callable for the Node-style launcher, \`fetch\` for the Bun runtime.
+export default Object.assign(handler, { fetch: handler });
+`);
+  const maxDuration = manifest.routes.reduce((max, route) => route.maxDuration ? Math.max(max ?? 0, route.maxDuration) : max, undefined);
+  await writeText(path.join(functionPath, ".vc-config.json"), `${JSON.stringify({
+    runtime: "bun1.4.x",
+    handler: "index.mjs",
+    launcherType: "Nodejs",
+    architecture: FUNCTION_PLATFORM.architecture,
+    useWebApi: true,
+    supportsResponseStreaming: true,
+    ...maxDuration ? { maxDuration } : {}
+  }, null, 2)}
+`);
+}
+async function packageDirs(modules) {
+  const found = new Map;
+  const visit = async (dir, depth) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const full = path.join(dir, entry.name);
+      if (entry.name === ".bun" || entry.name === ".pnpm") {
+        for (const store of await readdir(full, { withFileTypes: true }).catch(() => []))
+          if (store.isDirectory())
+            await visit(path.join(full, store.name, "node_modules"), 0);
+      } else if (entry.name.startsWith("@") && depth === 0) {
+        await visit(full, 1);
+      } else if (existsSync(path.join(full, "package.json"))) {
+        const name = depth === 1 ? `${path.basename(dir)}/${entry.name}` : entry.name;
+        found.set(name, [...found.get(name) ?? [], full]);
+        await visit(path.join(full, "node_modules"), 0);
+      }
+    }
+  };
+  await visit(modules, 0);
+  return found;
+}
+async function readPackageJson(dir) {
+  try {
+    return JSON.parse(await readFile(path.join(dir, "package.json"), "utf8"));
+  } catch {
+    return;
+  }
+}
+async function replaceHostNatives(packages, log) {
+  const manifests = new Map;
+  for (const [name, dirs] of packages) {
+    const json = await readPackageJson(dirs[0]);
+    if (json)
+      manifests.set(name, json);
+  }
+  const hostNatives = new Map;
+  for (const [name, json] of manifests) {
+    if (!(json.os ?? json.cpu) || matchesFunctionPlatform(json))
+      continue;
+    const owner = [...manifests].find(([, candidate]) => candidate.optionalDependencies?.[name]);
+    hostNatives.set(name, {
+      dirs: packages.get(name),
+      owner: owner && { name: owner[0], version: owner[1].version ?? "" }
+    });
+  }
+  if (hostNatives.size === 0)
+    return;
+  const targets = await platformNativePackages(hostNatives, manifests, log);
+  for (const [name, dir] of targets) {
+    for (const host of hostNatives.get(name)?.dirs ?? []) {
+      const target = path.join(path.dirname(host), name.split("/").at(-1));
+      await rm(host, { recursive: true, force: true });
+      await cp(dir, target, { recursive: true, dereference: true });
+    }
+  }
+}
+async function platformNativePackages(hostNatives, manifests, log) {
+  const owners = new Map;
+  for (const [name, { owner }] of hostNatives) {
+    const spec = owner ?? { name, version: manifests.get(name)?.version ?? "" };
+    if (spec.version)
+      owners.set(spec.name, spec.version);
+  }
+  const specs = [...owners].map(([name, version]) => `${name}@${version}`).sort();
+  if (specs.length === 0)
+    return new Map;
+  try {
+    const installed = await crossPlatformInstall(specs);
+    const matches = new Map;
+    for (const [name, dir] of installed) {
+      const json = await readPackageJson(dir);
+      if (json && (json.os ?? json.cpu) && matchesFunctionPlatform(json))
+        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 new Map;
+  }
+}
+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 = path.join(cacheRoot(), "vercel-natives", key);
+  const modules = path.join(dir, "node_modules");
+  if (!existsSync(modules)) {
+    const staging = `${dir}.${process.pid.toString(36)}`;
+    await rm(staging, { recursive: true, force: true });
+    await mkdir(staging, { recursive: true });
+    await writeText(path.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, path.join(modules, entry));
+      continue;
+    }
+    for (const scoped of readdirSync(path.join(modules, entry))) {
+      installed.set(`${entry}/${scoped}`, path.join(modules, entry, scoped));
+    }
+  }
+  return installed;
+}
+async function copyStaticFiles(from, to, shouldCopy = () => true) {
+  const files = (await listFiles(from)).filter((file) => shouldCopy(toPosixPath(path.relative(from, file))));
+  const directories = new Set(files.map((file) => path.dirname(path.join(to, path.relative(from, file)))));
+  await Promise.all([...directories].map((dir) => mkdir(dir, { recursive: true })));
+  await Promise.all(files.map((file) => copyFile(file, path.join(to, path.relative(from, file)), constants.COPYFILE_FICLONE)));
+}
+async function staticOverrides(publicPath, staticFiles) {
+  const overrides = {};
+  for (const file of await listFiles(publicPath)) {
+    const relative = toPosixPath(path.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(path.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/adapters/vercel-warm.ts
+import { fileURLToPath } from "url";
+
+// src/runtime/release-graph.ts
+import { existsSync as existsSync2, readFileSync, realpathSync } from "fs";
+import path2 from "path";
+var layerDirs = {
+  "server:server": "rsc",
+  "client:client": "ssr"
+};
+var layers = Object.keys(layerDirs);
+var frameworkRoot = realpathSync(path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", ".."));
+
+// src/cli/adapters/vercel-warm.ts
+var DONE_MARKER = "pnext-warm-done:";
+var COMPILED_MARKER = "pnext-warm-compiled";
+var ATTEMPT_TIMEOUT_MS = 10 * 60000;
+var MAX_ATTEMPTS = 3;
+var FULL_MODE_FLAG = "--full";
+function startWarmChild(config, mode = "full") {
+  const children = new Set;
+  let disposed = false;
+  const spawn = () => {
+    if (disposed)
+      return;
+    const child = spawnWarmProcess(config, mode);
+    if (!child)
+      return;
+    children.add(child);
+    child.exited.finally(() => children.delete(child));
+    forwardWarmStderr(child);
+    return child;
+  };
+  const killOnExit = () => kill();
+  const kill = () => {
+    if (disposed)
+      return;
+    disposed = true;
+    process.off("exit", killOnExit);
+    for (const child of children)
+      child.kill();
+    children.clear();
+  };
+  process.once("exit", killOnExit);
+  const first = spawn();
+  return {
+    prewarm(files) {
+      if (!first || files.length === 0)
+        return;
+      try {
+        first.stdin.write(`${JSON.stringify({ prewarm: files })}
+`);
+        first.stdin.flush();
+      } catch {}
+    },
+    finish: (log, onCompiled, facts = { clientReferences: [] }) => warmWithRestarts(first, spawn, mode, log, facts, onCompiled).finally(kill),
+    kill
+  };
+}
+async function forwardWarmStderr(child) {
+  try {
+    const reader = child.stderr.getReader();
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      process.stderr.write(value);
+    }
+  } catch {}
+}
+function spawnWarmProcess(config, mode) {
+  const entry = fileURLToPath(new URL(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/adapters/vercel-warm.ts").href));
+  const argv = mode === "full" ? [config.root, FULL_MODE_FLAG] : [config.root];
+  try {
+    return Bun.spawn([namedBunBinary("pnext-warm"), "--conditions=react-server", entry, ...argv], {
+      cwd: config.root,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env
+    });
+  } catch {
+    return;
+  }
+}
+async function warmWithRestarts(first, spawn, mode, log, facts, onCompiled) {
+  const finished = new Map;
+  const compiled = () => [...finished.values()].filter((file) => Boolean(file));
+  let fired = false;
+  const fireOnCompiled = onCompiled ? () => {
+    if (fired)
+      return;
+    fired = true;
+    onCompiled(compiled());
+  } : undefined;
+  let child = first;
+  for (let attempt = 1;attempt <= MAX_ATTEMPTS && child; attempt++) {
+    const before = finished.size;
+    const failure = await runAttempt(child, {
+      skip: [...finished.keys()],
+      compiled: Object.fromEntries([...finished].filter((entry) => Boolean(entry[1]))),
+      ...facts
+    }, finished, fireOnCompiled);
+    if (!failure) {
+      log.log(`warmed ${compiled().length} modules`);
+      return compiled();
+    }
+    child = finished.size > before && attempt < MAX_ATTEMPTS ? spawn() : undefined;
+    if (child)
+      log.log(`warm-up ${failure} after ${finished.size} files; restarting past them`);
+    else
+      warmIncomplete(failure, finished.size, mode);
+  }
+  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/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 as readdir2, readlink } from "fs/promises";
+import path3 from "path";
+var CACHE_VERSION = 2;
+var CACHE_SEGMENTS = ["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(buildManifestFile(config.outPath), "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(outCachePath(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(outCachePath(config.outPath), "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 readdir2(dir, { withFileTypes: true }).catch(() => []);
+  await Promise.all(entries.map(async (entry) => {
+    const file = path3.join(dir, entry.name);
+    if (file === outPath || file.startsWith(`${outPath}${path3.sep}`))
+      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 readdir2(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 readdir2(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/standalone.ts
+import { createHash as createHash2 } from "crypto";
+import { constants as constants2, existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, realpathSync as realpathSync2, statSync } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir3, readFile as readFile3, rename as rename2, rm as rm2, writeFile } from "fs/promises";
+import { builtinModules } from "module";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+var frameworkRoot2 = realpathSync2(path4.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve", "..", "..", ".."));
+var frameworkPackage = JSON.parse(readFileSync2(path4.join(frameworkRoot2, "package.json"), "utf8"));
+var runtimeDependencies = new Set(Object.keys(frameworkPackage.dependencies ?? {}));
+var buildOnlyModule = /^(?:build|modules|loader|compile|esbuild|dev|run|typegen|analyze|create)$/;
+var builtins = new Set(builtinModules);
+var scriptFile = /\.(?:[cm]?[jt]sx?)$/;
+function frameworkStartEntry() {
+  return readPrebundleStamp(frameworkRoot2, frameworkFingerprint()) ? path4.join(frameworkRoot2, "dist", "server", "cli", "start.js") : path4.join(frameworkRoot2, "src", "cli", "start.ts");
+}
+function startStandalone(config) {
+  const input = {
+    outPath: config.outPath,
+    root: config.root,
+    workspaceRoot: config.workspaceRoot
+  };
+  const modules = path4.join(config.workspaceRoot, "node_modules");
+  const cacheFile = existsSync4(modules) && path4.join(modules, ".cache", "pnext", `standalone-${frameworkTraceKey()}.json`);
+  if (cacheFile && existsSync4(cacheFile)) {
+    try {
+      return Promise.resolve(JSON.parse(readFileSync2(cacheFile, "utf8")));
+    } catch {}
+  }
+  const framework = new Promise((resolve, reject) => {
+    const worker = new Worker(new URL("./standalone-worker.ts", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/serve/standalone.ts").href));
+    worker.unref?.();
+    worker.onmessage = (event) => {
+      resolve(event.data);
+      worker.terminate();
+    };
+    worker.onerror = (event) => {
+      reject(new Error(event.message));
+      worker.terminate();
+    };
+    worker.postMessage(input);
+  }).catch(() => traceFramework(input));
+  if (cacheFile)
+    framework.then(async (snapshot) => {
+      await mkdir3(path4.dirname(cacheFile), { recursive: true });
+      const temporary = `${cacheFile}.${process.pid}.tmp`;
+      await writeFile(temporary, JSON.stringify(snapshot));
+      await rename2(temporary, cacheFile);
+    }).catch(() => {
+      return;
+    });
+  return framework;
+}
+function frameworkTraceKey() {
+  const startEntry = frameworkStartEntry();
+  const packages = [...runtimeDependencies, ...frameworkRuntimeSpecifiers()].map((specifier) => {
+    const file = resolveEdge(specifier, startEntry);
+    return file ? `${file}\x00${statSync(file).mtimeMs}` : specifier;
+  });
+  return createHash2("sha256").update(JSON.stringify([frameworkFingerprint(), startEntry, packages])).digest("hex").slice(0, 16);
+}
+async function traceFramework(config) {
+  const tracer = createTracer(config);
+  const startEntry = frameworkStartEntry();
+  await tracer.add([
+    { file: startEntry, app: false },
+    ...frameworkRuntimeSpecifiers().flatMap((specifier) => {
+      const file = resolveEdge(specifier, startEntry);
+      return file ? [{ file, app: false }] : [];
+    })
+  ]);
+  return tracer.snapshot();
+}
+async function writeStandalone(config, framework = startStandalone(config)) {
+  const outPath = config.outPath;
+  const cache = cacheRoot2(outPath);
+  const index = readBuildIndex(outPath);
+  const manifestFile = buildManifestFile(outPath);
+  const manifest = JSON.parse(await readFile3(manifestFile, "utf8"));
+  const startEntry = frameworkStartEntry();
+  const snapshot = await framework;
+  const copier = createCopier(outPath);
+  const rewrittenFramework = new Map(snapshot.rewritten);
+  for (const [dest, source] of snapshot.files)
+    copier.copy(dest, source, rewrittenFramework.get(dest));
+  const tracer = createTracer(config, snapshot, (dest) => copier.copy(dest, tracer.trace.files.get(dest), tracer.trace.rewritten.get(dest)));
+  const { trace, place } = tracer;
+  await tracer.add([
+    ...Object.values(index.modules),
+    ...index.dependencies ?? [],
+    index.nextConfig,
+    index.instrumentation?.file,
+    index.instrumentation?.edge,
+    ...Object.values(index.compat?.cacheHandlers ?? {}),
+    ...Object.values(index.fonts ?? {}).flatMap((font) => font.files),
+    manifest.proxyModule,
+    ...(manifest.actions ?? []).map((action) => action.modulePath)
+  ].flatMap((artifact) => artifact ? [{ file: path4.resolve(outPath, artifact), app: true }] : []));
+  addAppFiles(config, index, trace);
+  tracer.flush();
+  await copier.settle();
+  const cachePrefix = `${toPosixPath(path4.relative(outPath, cache))}/`;
+  const relocate = (value) => {
+    if (typeof value === "string")
+      return value.startsWith(cachePrefix) ? `server/${value.slice(cachePrefix.length)}` : value;
+    if (Array.isArray(value))
+      return value.map(relocate);
+    if (value && typeof value === "object")
+      return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, relocate(item)]));
+    return value;
+  };
+  const indexFile = buildIndexFile(outPath);
+  await writeFile(indexFile, JSON.stringify(relocate(JSON.parse(await readFile3(indexFile, "utf8")))));
+  const shippedManifest = relocate(JSON.parse(await readFile3(manifestFile, "utf8")));
+  for (const route of shippedManifest.routes) {
+    if (route.sourceFiles)
+      route.sourceFiles = route.sourceFiles.filter((file) => !file.startsWith("../"));
+  }
+  await writeFile(manifestFile, `${JSON.stringify(shippedManifest, null, 2)}
+`);
+  await writeFile(path4.join(outPath, "server", "entry.js"), `export * from ${JSON.stringify(relativeSpecifier("server", place(startEntry)))}
+`);
+  await writeFile(path4.join(outPath, "package.json"), `{ "type": "module" }
+`);
+  const origins = Object.fromEntries([...trace.files].filter(([dest]) => dest.startsWith("node_modules/")));
+  const originsFile = standaloneOriginsFile(outPath);
+  await mkdir3(path4.dirname(originsFile), { recursive: true });
+  await writeFile(originsFile, JSON.stringify({ release: outPath, origins }));
+}
+function setFile(trace, dest, source) {
+  if (!trace.files.has(dest))
+    trace.fresh.push(dest);
+  trace.files.set(dest, source);
+}
+function createTracer(config, from, onReady) {
+  const outPath = config.outPath;
+  const cache = cacheRoot2(outPath);
+  const trace = {
+    files: new Map(from?.files),
+    fresh: [],
+    rewritten: new Map(from?.rewritten)
+  };
+  const claims = new Map(from?.claims);
+  const place = createPlacer(outPath, cache, claims);
+  const standalones = new Set(from?.standalones);
+  const shipped = (file) => installed(file) || isInside(frameworkRoot2, file) && !isInside(config.root, file);
+  const seen = new Set(from?.seen);
+  const reads = new Map;
+  const prefetch = (file) => {
+    if (scriptFile.test(file) && !reads.has(file))
+      reads.set(file, readFile3(file, "utf8").catch(() => {
+        return;
+      }));
+  };
+  const queue = [];
+  const enqueue = (file, app) => {
+    if (seen.has(`${app}\x00${file}`))
+      return;
+    queue.push({ file, app });
+    prefetch(file);
+  };
+  const flush = () => {
+    for (const dest of trace.fresh.splice(0))
+      onReady?.(dest);
+  };
+  const run = async (items) => {
+    for (const item of items)
+      enqueue(item.file, item.app);
+    for (let item = queue.shift();item; item = queue.shift(), flush()) {
+      const { file, app } = item;
+      if (seen.has(`${app}\x00${file}`))
+        continue;
+      seen.add(`${app}\x00${file}`);
+      const nested = enclosingStandalone(file, outPath);
+      if (nested) {
+        if (!standalones.has(nested)) {
+          standalones.add(nested);
+          addTree(nested, path4.posix.dirname(path4.posix.dirname(place(path4.join(nested, "server", "entry.js")))), trace);
+        }
+        continue;
+      }
+      const dest = place(file);
+      setFile(trace, dest, file);
+      if (!isInside(outPath, file) && !isInside(cache, file))
+        addPackageFiles(file, trace, place);
+      if (!scriptFile.test(file))
+        continue;
+      const release = isInside(outPath, file) || isInside(cache, file);
+      const framework = !release && isInside(frameworkRoot2, file) && !installedIn(frameworkRoot2, file);
+      prefetch(file);
+      const source = await reads.get(file);
+      if (source === undefined)
+        continue;
+      const edits = new Map;
+      for (const edge of scanEdges(file, source)) {
+        if (edge.url) {
+          const target2 = urlTarget(edge.specifier, file);
+          if (!target2)
+            continue;
+          const appFile = release && !isInside(outPath, target2) && !isInside(cache, target2) && !shipped(target2);
+          if (appFile && scriptFile.test(target2))
+            continue;
+          if (!statSync(target2, { throwIfNoEntry: false })?.isFile())
+            continue;
+          const at = appFile ? toPosixPath(path4.join("server", "assets", path4.relative(config.workspaceRoot, target2))) : place(target2);
+          if (appFile)
+            setFile(trace, at, target2);
+          else
+            enqueue(target2, release);
+          if (release) {
+            const relative = relativeSpecifier(path4.dirname(dest), at);
+            if (relative !== edge.specifier)
+              edits.set(edge.specifier, relative);
+          }
+          continue;
+        }
+        const bare = isPackageSpecifier(edge.specifier);
+        const name = bare ? packageName(edge.specifier) : undefined;
+        if (bare && !name && !edge.specifier.startsWith("#"))
+          continue;
+        if (name && framework && !app && (edge.require || !runtimeDependencies.has(name)))
+          continue;
+        const target = resolveEdge(edge.specifier, file, edge.require);
+        if (!target)
+          continue;
+        if (edge.dynamic && framework && buildOnlyModule.test(moduleName(target)))
+          continue;
+        enqueue(target, release);
+        for (const counterpart of frameworkCounterparts(target))
+          enqueue(counterpart, release);
+        if (release || name && !place(target).startsWith(`node_modules/${name}/`)) {
+          const relative = relativeSpecifier(path4.dirname(dest), place(target));
+          if (relative !== edge.specifier)
+            edits.set(edge.specifier, relative);
+        }
+      }
+      if (edits.size > 0)
+        trace.rewritten.set(dest, rewriteSpecifiers(file, source, edits));
+    }
+    flush();
+  };
+  const snapshot = () => ({
+    files: [...trace.files],
+    rewritten: [...trace.rewritten],
+    seen: [...seen],
+    claims: [...claims],
+    standalones: [...standalones]
+  });
+  return { trace, place, add: run, snapshot, flush };
+}
+var prunedDirNames = [
+  "node_modules",
+  ".git",
+  ".next",
+  ".pnext",
+  ".turbo",
+  ".cache",
+  ".vercel",
+  ".tmp"
+];
+var standaloneEntries = new Set(["server", "static", "node_modules", "package.json"]);
+function addAppFiles(config, index, trace) {
+  const { keep = [], exclude = [] } = config.adapter ?? {};
+  const named = (entries, name) => entries.some((entry) => name === entry || entry.startsWith(".") && name.endsWith(entry));
+  for (const dest of trace.files.keys()) {
+    const segments = dest.split("/");
+    if (dest.startsWith("node_modules/") && segments.some((name) => named(exclude, name)))
+      trace.files.delete(dest);
+  }
+  if (keep.length === 0)
+    return;
+  const compiled = compiledSources(config, index);
+  const outTop = path4.relative(config.root, config.outRootPath).split(path4.sep)[0];
+  const visit = (dir, kept) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      const file = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const pruned = prunedDirNames.includes(entry.name) && !named(keep, entry.name);
+        if (pruned || dir === config.root && entry.name === outTop)
+          continue;
+        visit(file, kept || named(keep, entry.name));
+        continue;
+      }
+      if (!entry.isFile() || compiled.has(file) && !named(keep, entry.name))
+        continue;
+      const env = entry.name.startsWith(".env");
+      if (env ? !keep.includes(entry.name) : !kept && !named(keep, entry.name))
+        continue;
+      const relative = toPosixPath(path4.relative(config.root, file));
+      if (!standaloneEntries.has(relative.split("/")[0]))
+        setFile(trace, relative, file);
+    }
+  };
+  visit(config.root, false);
+}
+function compiledSources(config, index) {
+  flushDevModuleCaches();
+  const graph = compiledSourceGraph(config.outPath, config.workspaceRoot);
+  const queue = Object.keys(index.modules).map((key) => releaseSourceFile(key.slice(key.indexOf(":", key.indexOf(":") + 1) + 1), config.root, config.workspaceRoot));
+  if (index.proxy)
+    queue.push(path4.resolve(config.root, index.proxy.file));
+  for (const name of readdirSync2(config.root))
+    if (/^(?:pnext|next|instrumentation)\.config\.|^instrumentation\./.test(name) && scriptFile.test(name))
+      queue.push(path4.join(config.root, name));
+  const compiled = new Set;
+  for (const file of queue) {
+    if (compiled.has(file))
+      continue;
+    compiled.add(file);
+    queue.push(...graph.get(file) ?? []);
+  }
+  for (const css of index.globalCss)
+    compiled.add(path4.resolve(config.root, css));
+  return compiled;
+}
+function createPlacer(outPath, cache, claims = new Map) {
+  const packageDir = (root, name) => {
+    const owner = claims.get(name);
+    if (owner === undefined)
+      claims.set(name, root);
+    if (owner === undefined || owner === root)
+      return `node_modules/${name}`;
+    const key = createHash2("sha256").update(root).digest("hex").slice(0, 12);
+    return `node_modules/.pnext/${key}/node_modules/${name}`;
+  };
+  return (file) => {
+    if (isInside(cache, file))
+      return toPosixPath(path4.join("server", path4.relative(cache, file)));
+    if (isInside(outPath, file))
+      return toPosixPath(path4.relative(outPath, file));
+    const framework = !installed(frameworkRoot2) && isInside(frameworkRoot2, file) && !installedIn(frameworkRoot2, file);
+    if (framework) {
+      const dir = packageDir(frameworkRoot2, frameworkPackage.name);
+      return `${dir}/${toPosixPath(path4.relative(frameworkRoot2, file))}`;
+    }
+    const posix = toPosixPath(file);
+    const at = posix.lastIndexOf("/node_modules/");
+    if (at !== -1) {
+      const rest = posix.slice(at + "/node_modules/".length).split("/");
+      const length = rest[0].startsWith("@") ? 2 : 1;
+      const name2 = rest.slice(0, length).join("/");
+      const root2 = `${posix.slice(0, at)}/node_modules/${name2}`;
+      return [packageDir(root2, name2), ...rest.slice(length)].join("/");
+    }
+    const root = packageRoot(path4.dirname(file));
+    const name = root && readPackageName(root);
+    if (!root || !name)
+      throw new Error(`pnext build: cannot place ${file} in the standalone output`);
+    return `${packageDir(root, name)}/${toPosixPath(path4.relative(root, file))}`;
+  };
+}
+var standaloneDirs = new Map;
+function enclosingStandalone(file, outPath) {
+  const dir = path4.dirname(file);
+  if (dir === path4.dirname(dir))
+    return;
+  if (standaloneDirs.has(dir))
+    return standaloneDirs.get(dir);
+  const own = dir !== outPath && existsSync4(path4.join(dir, "server", "build-index.json")) && existsSync4(path4.join(dir, "server", "entry.js"));
+  const found = own ? dir : enclosingStandalone(dir, outPath);
+  standaloneDirs.set(dir, found);
+  return found;
+}
+function addTree(root, dest, trace) {
+  const visit = (dir, seen) => {
+    const real = realpathSync2(dir);
+    if (seen.has(real))
+      return;
+    seen.add(real);
+    for (const name of readdirSync2(dir)) {
+      const file = path4.join(dir, name);
+      const stat = statSync(file, { throwIfNoEntry: false });
+      if (stat?.isDirectory())
+        visit(file, seen);
+      else if (stat?.isFile())
+        setFile(trace, `${dest}/${toPosixPath(path4.relative(root, file))}`, realpathSync2(file));
+    }
+  };
+  visit(root, new Set);
+}
+function installed(file) {
+  return toPosixPath(file).includes("/node_modules/");
+}
+function installedIn(root, file) {
+  return path4.relative(root, file).split(path4.sep).includes("node_modules");
+}
+var transpilers = new Map;
+function scanEdges(file, source) {
+  const ext = path4.extname(file);
+  const loader = ext === ".tsx" || ext === ".jsx" ? "tsx" : /\.[cm]?ts$/.test(ext) ? "ts" : "js";
+  let transpiler = transpilers.get(loader);
+  if (!transpiler) {
+    transpiler = new Bun.Transpiler({
+      loader,
+      tsconfig: { compilerOptions: { jsx: "react-jsx", jsxImportSource: "preact" } }
+    });
+    transpilers.set(loader, transpiler);
+  }
+  let imports;
+  try {
+    imports = transpiler.scanImports(source);
+  } catch {
+    return [];
+  }
+  const edges = imports.map((entry) => ({
+    specifier: entry.path,
+    dynamic: entry.kind === "dynamic-import",
+    require: entry.kind === "require-call"
+  }));
+  const refs = importMetaRefs(file, source);
+  for (const url of refs.urls)
+    edges.push({ specifier: url.specifier, dynamic: false, url: true });
+  for (const ref of refs.resolves)
+    edges.push({ specifier: ref.specifier, dynamic: false });
+  if (loader === "tsx")
+    edges.push({ specifier: "preact/jsx-runtime", dynamic: false }, { specifier: "preact/jsx-dev-runtime", dynamic: false });
+  return edges;
+}
+var resolved = new Map;
+function resolveEdge(specifier, from, require2 = false) {
+  if (/^(?:node:|bun:|data:|https?:)/.test(specifier) || specifier === "bun")
+    return;
+  const bare = require2 ? specifier : splitResourceQuery(specifier).path;
+  if (builtins.has(bare))
+    return;
+  const dir = path4.dirname(from);
+  const key = `${dir}\x00${bare}`;
+  if (resolved.has(key))
+    return resolved.get(key);
+  let target;
+  try {
+    const request = bare.startsWith("file:") ? fileURLToPath2(bare) : bare;
+    target = realpathSync2(Bun.resolveSync(request, dir));
+    if (!statSync(target).isFile())
+      target = undefined;
+  } catch {
+    target = undefined;
+  }
+  resolved.set(key, target);
+  return target;
+}
+function frameworkCounterparts(file) {
+  const counterpart = prebundledFile(file);
+  if (counterpart === file)
+    return [];
+  return [counterpart, path4.join(frameworkRoot2, PREBUNDLE_STAMP)];
+}
+function moduleName(file) {
+  const base = path4.basename(file, path4.extname(file));
+  const chunk = path4.basename(path4.dirname(file)) === "_chunks";
+  return chunk && isInside(path4.join(frameworkRoot2, "dist"), file) ? base.replace(/-[a-z0-9]{8}$/, "") : base;
+}
+function packageName(specifier) {
+  if (specifier.startsWith("#"))
+    return;
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  return name && !builtins.has(name) ? name : undefined;
+}
+function addPackageFiles(file, trace, place) {
+  const inStore = installed(file);
+  for (let dir = path4.dirname(file);dir !== path4.dirname(dir); dir = path4.dirname(dir)) {
+    const manifest = path4.join(dir, "package.json");
+    const found = existsSync4(manifest);
+    if (found)
+      setFile(trace, place(manifest), manifest);
+    if (found && dir === frameworkRoot2) {
+      for (const name of ["tsconfig.json", path4.join("config", "ts", "react.json")]) {
+        const extra = path4.join(dir, name);
+        if (existsSync4(extra))
+          setFile(trace, place(extra), extra);
+      }
+    }
+    const parent = path4.basename(path4.dirname(dir));
+    const packageTop = parent === "node_modules" || parent.startsWith("@") && path4.basename(path4.dirname(path4.dirname(dir))) === "node_modules";
+    if (inStore ? packageTop : found && readPackageName(dir))
+      return;
+  }
+}
+function packageRoot(dir) {
+  for (;dir !== path4.dirname(dir); dir = path4.dirname(dir)) {
+    if (existsSync4(path4.join(dir, "package.json")))
+      return dir;
+  }
+  return;
+}
+function readPackageName(dir) {
+  try {
+    return JSON.parse(readFileSync2(path4.join(dir, "package.json"), "utf8")).name;
+  } catch {
+    return;
+  }
+}
+function relativeSpecifier(fromDir, to) {
+  const relative = toPosixPath(path4.relative(fromDir, to));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function rewriteSpecifiers(file, source, edits) {
+  const refs = importMetaRefs(file, source);
+  const spans = [...moduleSpecifierEdges(source, file), ...refs.urls, ...refs.resolves];
+  const changes = spans.flatMap((span) => {
+    const value = edits.get(span.specifier);
+    return value === undefined ? [] : [{ start: span.start, end: span.end, value: JSON.stringify(value) }];
+  });
+  changes.sort((a, b) => a.start - b.start);
+  return changes.length > 0 ? spliceSource(source, changes) : source;
+}
+function urlTarget(specifier, from) {
+  try {
+    const url = new URL(specifier, pathToFileURL(from));
+    return url.protocol === "file:" ? fileURLToPath2(url) : undefined;
+  } catch {
+    return;
+  }
+}
+function isPackageSpecifier(specifier) {
+  if (specifier === "." || specifier === "..")
+    return false;
+  if (specifier.startsWith("./") || specifier.startsWith("../"))
+    return false;
+  return !path4.isAbsolute(specifier) && !specifier.startsWith("file:");
+}
+function createCopier(outPath) {
+  const dirs = new Map;
+  const copied = new Set;
+  const pending = [];
+  const ensureDir = (dir) => {
+    let made = dirs.get(dir);
+    if (!made) {
+      made = mkdir3(dir, { recursive: true });
+      dirs.set(dir, made);
+    }
+    return made;
+  };
+  const copy = (dest, source, contents) => {
+    if (copied.has(dest))
+      return;
+    copied.add(dest);
+    const target = path4.join(outPath, dest);
+    pending.push(ensureDir(path4.dirname(target)).then(async () => {
+      if (contents !== undefined) {
+        if (target !== source)
+          await rm2(target, { force: true });
+        return writeFile(target, contents);
+      }
+      if (target !== source)
+        await copyFile2(source, target, constants2.COPYFILE_FICLONE);
+    }));
+  };
+  return { copy, settle: () => Promise.all(pending) };
+}
+function isInside(root, file) {
+  return file === root || file.startsWith(`${root}${path4.sep}`);
+}
+
+// src/cli/build.ts
+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 standalone = startStandalone(config);
+  const publicFiles = await log.step("prepare output directory", async () => {
+    await ensureEmptyDir(config.outRootPath, [devOutSegment, "pnext-pages-compat"]);
+    return copyPublicDir(config.publicPath, path5.join(config.outPath, "static"));
+  });
+  const documentCss = Promise.resolve().then(() => buildGlobalCss(config, { verbose })).then(() => buildNotFoundCss(config, { verbose }));
+  documentCss.catch(() => {
+    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, "static", "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, "static", "assets"));
+  if (verbose) {
+    const sources = sourceCacheStats();
+    log.log(`source cache \u2014 ${sources.reads} reads, ${sources.hits} shared, ${sources.files} files \xB7 parses ${JSON.stringify(scanFactsStats())}`);
+  }
+  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, "static"), 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 = existsSync5(sourceApp) ? sourceApp : config.appPath;
+    const hasTopLevelRootLayout = ["tsx", "ts", "jsx", "js"].some((ext) => existsSync5(path5.join(layoutRoot, `layout.${ext}`)));
+    const pseudos = hasTopLevelRootLayout ? ["_not-found.html", "_global-error.html"] : ["_not-found.html"];
+    for (const pseudo of pseudos) {
+      if (!(pseudo in staticFiles)) {
+        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"})`);
+  for (const hook of getBuildExtensions().completeHooks) {
+    await hook({ config, manifest, log });
+  }
+  await log.step("warm module cache", () => warm.finish(log, undefined, {
+    globalCss: globalCssSources(config),
+    clientReferences: [...compiledClientReferenceFiles()]
+  }));
+  if (!existsSync5(buildIndexFile(config.outPath))) {
+    throw new Error("pnext build: the server compile did not complete (see the error above).");
+  }
+  await log.step("standalone output", () => writeStandalone(config, standalone));
+  if (options.adapter === "vercel")
+    await log.step("vercel adapter output", () => writeVercelOutput(config, manifest, { verbose }));
+  throwIfModuleGraphFailed();
+  const buildDurationMs = performance.now() - startedAt;
+  const phases = await settleBuildParallelPhases();
+  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 (!existsSync5(file))
+    return false;
+  const source = readTextSync(file);
+  return /\bexport\s+(?:async\s+)?function\s+generateStaticParams\b/.test(source) || /\bexport\s+const\s+generateStaticParams\b/.test(source);
+}
+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 = buildManifestFile(outPath);
+  const temporary = `${file}.${process.pid}.tmp`;
+  await mkdir4(path5.dirname(file), { recursive: true });
+  await writeFile2(temporary, serializeBuildManifest(manifest));
+  await rename3(temporary, file);
+}
+function assertManifestServerArtifacts(outPath, manifest) {
+  const artifacts = [
+    ...manifest.proxyModule ? [manifest.proxyModule] : [],
+    ...manifest.actions?.map((action) => action.modulePath) ?? []
+  ];
+  const outRoot = path5.dirname(outPath);
+  for (const artifact of artifacts) {
+    const file = path5.resolve(outPath, artifact);
+    if (!file.startsWith(`${outRoot}${path5.sep}`)) {
+      throw new Error(`Build manifest server artifact escapes output directory: ${artifact}`);
+    }
+    if (!existsSync5(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 (!existsSync5(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 (!existsSync5(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 existsSync5(file) && statSync2(file).isFile() ? readFileSync3(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 (!existsSync5(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 (!existsSync5(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 (!existsSync5(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, "static", "404.html"), await render()));
+  }
+  if (!config.compat?.next)
+    return;
+  if (existsSync5(path5.join(config.outPath, "static", "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) => existsSync5(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 (!existsSync5(compiled))
+    return;
+  const serverDir = path5.join(config.root, ".next", "server");
+  await mkdir4(serverDir, { recursive: true });
+  const middlewareFile = path5.join(serverDir, "middleware.js");
+  await copyFile3(compiled, middlewareFile);
+  const files = ["middleware.js"].filter((name) => existsSync5(path5.join(serverDir, name)));
+  await writeFile2(path5.join(serverDir, "middleware.js.nft.json"), `${JSON.stringify({ version: 1, files })}
+`);
+}
+async function emitNextNotFoundArtifacts(config, fallback404) {
+  if (!config.compat?.next)
+    return;
+  const source = path5.join(config.outPath, "static", "404.html");
+  const html = existsSync5(source) ? readFileSync3(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 writeFile2(path5.join(pagesDir, "404.html"), html);
+  await writeFile2(path5.join(serverDir, "app", "_not-found.html"), html);
+  await writeFile2(path5.join(serverDir, "app", "_not-found.rsc"), html);
+  const pagesManifestFile = path5.join(serverDir, "pages-manifest.json");
+  let pagesManifest = {};
+  try {
+    pagesManifest = JSON.parse(readFileSync3(pagesManifestFile, "utf8"));
+  } catch {}
+  pagesManifest["/404"] = "pages/404.html";
+  await writeFile2(pagesManifestFile, `${JSON.stringify(pagesManifest, null, 2)}
+`);
+  const clientReferenceManifest = "page_client-reference-manifest.js";
+  await writeFile2(path5.join(notFoundDir, clientReferenceManifest), `self.__RSC_MANIFEST={}
+`);
+  await writeFile2(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 (existsSync5(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 resolved2 = await withDynamicMetadataRoutes(base, config.appPath, route.file, routePath, (file) => importMetadataModule(config, file));
+      metadata[staticRouteMetadataKey(routePath)] = resolved2;
+    }
+  }
+  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, "static"), file));
+    if (!skipPhysicalWrite) {
+      await mkdir4(path5.dirname(file), { recursive: true });
+      await writeFile2(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 || !existsSync5(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 || !existsSync5(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 || !existsSync5(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 (existsSync5(dir)) {
+      for (const entry of readdirSync3(dir)) {
+        if (/^(opengraph-image|twitter-image)\d*\.(tsx?|jsx?|mjs|png|jpe?g|gif|webp|svg)$/.test(entry)) {
+          return true;
+        }
+      }
+    }
+    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 copyFile3(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, "static", "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, "static");
+  if (existsSync5(file) && statSync2(file).isDirectory()) {
+    return `${toPosixPath(path5.relative(publicPath, file))} already exists as a directory`;
+  }
+  let dir = path5.dirname(file);
+  while (dir !== publicPath && dir !== path5.dirname(dir)) {
+    if (existsSync5(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 resolved2 = path5.resolve(file);
+    return !resolved2.includes(`${path5.sep}node_modules${path5.sep}`) && !resolved2.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, "static");
+  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, "static", "_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 (existsSync5(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 copyFile3(path5.join(from, relative), target);
+  }
+  return files;
+}
+export {
+  buildProject,
+  staticHtmlPath
+};