@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/build-tier-0a96kmx3.js

@@ -0,0 +1,2456 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  DEFAULT_DYNAMIC_STALE_TIME_SECONDS,
+  DEFAULT_STATIC_STALE_TIME_SECONDS,
+  bodySegmentFile,
+  buildRootTreePrefetch,
+  buildSegmentMeta,
+  readMiddlewareWasmBindingsForOutPath,
+  rootTreePrefetchText,
+  segmentDir,
+  segmentMetaFile,
+  treeSegmentFile,
+  validateBuild,
+  warnNextMetadataBuildIssues
+} from "./index-j681c48a.js";
+import {
+  writeTsconfigDefaults
+} from "./index-b7j671dj.js";
+import {
+  generateTypedRoutes
+} from "./index-9hz3s0m8.js";
+import {
+  scanRootParamTypes
+} from "./index-v1ags1na.js";
+import {
+  discoverStaticMetadataFiles
+} from "./index-x2m17v9c.js";
+import {
+  deploymentId,
+  turbopackLoaderRules
+} from "./index-wm36rj4v.js";
+import"./index-8ct7rqy3.js";
+import {
+  nextCompatEnabled,
+  reactCompatEnabled,
+  reactCompilerOptions
+} from "./index-kdhxpwyq.js";
+import {
+  findProxyFile,
+  proxyExternalLoadTarget
+} from "./index-3ycf5ckv.js";
+import {
+  devServerModuleHref
+} from "./index-0yjv5v47.js";
+import"./index-d158y67j.js";
+import"./index-web361b8.js";
+import {
+  preferredRegionForRoute
+} from "./index-xvj80c3a.js";
+import {
+  fontLinkHeaderValue,
+  takeFontHeaderPreloads
+} from "./index-gkndxkxf.js";
+import"./index-qcrvt6er.js";
+import"./index-knp0s912.js";
+import"./index-gcmj16xy.js";
+import"./index-fn1chkkd.js";
+import"./index-ye9hmsvf.js";
+import"./index-6q7zvrap.js";
+import {
+  takeResourceHintHeader
+} from "./index-tf4j19ge.js";
+import"./index-stbk3jhn.js";
+import {
+  aliasGenerateStaticParams,
+  varyNamesFor,
+  withVaryParamsTracking
+} from "./index-x0y005nh.js";
+import {
+  diagnoseCacheComponentsPrerender,
+  diagnosticLeadsWithErrorLine,
+  prerenderFailureFooter,
+  takeCacheLifeStash,
+  writeBuildFlags
+} from "./index-j0m1jxqa.js";
+import"./index-z88qv16t.js";
+import"./index-fp8r0sqs.js";
+import"./index-akkrvjn6.js";
+import"./index-bcws5eh2.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import"./index-cjgqs13g.js";
+import"./index-jks0x0a1.js";
+import"./index-6b009mt0.js";
+import"./index-4zzebszd.js";
+import"./index-sq3kvz3g.js";
+import"./index-ckkdpht5.js";
+import {
+  emitCustomServerShim
+} from "./index-8kcxdfya.js";
+import"./index-yhxkxghe.js";
+import"./index-29pq0kax.js";
+import"./index-cn86z041.js";
+import {
+  listFiles,
+  toPosixPath
+} from "./index-4da76t62.js";
+import"./index-vz0km5qk.js";
+import {
+  pathToFileHref
+} from "./index-71885zaq.js";
+import"./index-bzd2ef7t.js";
+import"./index-jcsjq3d1.js";
+import"./index-hdbwtdv2.js";
+import"./index-ras0sdab.js";
+import {
+  legacyRequestAPIs
+} from "./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-jt8e1pje.js";
+import {
+  onExtensionHostReset,
+  registerBuildCompleteHooks,
+  registerBuildParallelPhases,
+  registerBuildSteps,
+  setBuildCompatExtensions,
+  setCompatModeExtensions
+} from "./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-4399bvd2.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/register/build.ts
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/compat/export/build-complete.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+function staticPathname(relative) {
+  const url = `/${relative.replace(/\\/g, "/")}`;
+  if (url.endsWith("/index.html"))
+    return url.slice(0, -"index.html".length) || "/";
+  return url.endsWith(".html") ? url.slice(0, -".html".length) : url;
+}
+function serverEntryPath(config, route) {
+  return path.join(config.outPath, "server", `${route.id}.js`);
+}
+async function writeServerEntries(config, manifest) {
+  await mkdir(path.join(config.outPath, "server"), { recursive: true });
+  await Promise.all(manifest.routes.map((route) => writeFile(serverEntryPath(config, route), [
+    "// Generated by `pnext build` for the configured deployment adapter.",
+    "// pnext serves every route from one server process (`pnext start`);",
+    "// this entry identifies the route rather than bundling it standalone.",
+    `export const id = ${JSON.stringify(route.id)};`,
+    `export const pathname = ${JSON.stringify(route.route)};`,
+    `export const sourcePage = ${JSON.stringify(sourcePage(config, route))};`,
+    `export const kind = ${JSON.stringify(route.kind)};`,
+    "export const runtime = 'nodejs';",
+    "export default { id, pathname, sourcePage, kind, runtime };",
+    ""
+  ].join(`
+`))));
+}
+function sourcePage(config, route) {
+  return `/${path.relative(config.root, route.file).replace(/\\/g, "/")}`;
+}
+function sharedFields(config, route) {
+  return {
+    id: route.id,
+    filePath: serverEntryPath(config, route),
+    pathname: route.route,
+    sourcePage: sourcePage(config, route),
+    runtime: "nodejs",
+    assets: {},
+    assetsHashes: {},
+    config: {
+      ...route.maxDuration !== undefined ? { maxDuration: route.maxDuration } : {}
+    }
+  };
+}
+function collectOutputs(config, manifest) {
+  const outputs = {
+    pages: [],
+    appPages: [],
+    pagesApi: [],
+    appRoutes: [],
+    prerenders: [],
+    staticFiles: []
+  };
+  const prerenderedRoutes = new Set;
+  for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
+    const filePath = path.join(config.outPath, "static", relative);
+    if (!existsSync(filePath))
+      continue;
+    if (metadata.routeId)
+      prerenderedRoutes.add(metadata.routeId);
+    const entry = { id: relative, filePath, pathname: staticPathname(relative) };
+    if (metadata.revalidateSeconds !== undefined) {
+      outputs.prerenders.push({
+        ...entry,
+        type: "PRERENDER",
+        parentOutputId: metadata.routeId ?? relative
+      });
+    } else {
+      outputs.staticFiles.push({ ...entry, type: "STATIC_FILE" });
+    }
+  }
+  for (const route of manifest.routes) {
+    if (prerenderedRoutes.has(route.id) && route.mode === "static" && !route.ppr)
+      continue;
+    const fields = sharedFields(config, route);
+    if (route.kind === "handler") {
+      outputs.appRoutes.push({ ...fields, type: "APP_ROUTE" });
+    } else {
+      outputs.appPages.push({ ...fields, type: "APP_PAGE" });
+      outputs.appPages.push({
+        ...fields,
+        type: "APP_PAGE",
+        id: `${route.id}.rsc`,
+        pathname: `${fields.pathname}.rsc`
+      });
+    }
+  }
+  return outputs;
+}
+function namedSourceRegex(route) {
+  let index = 0;
+  const named = route.pattern.replace(/\((\[\^\/\]\+|\.\*)\)/g, (whole, body) => {
+    const param = route.params[index++];
+    return param ? `(?<${param.replace(/\W/g, "")}>${body})` : whole;
+  });
+  return `^${named}(?:/)?$`;
+}
+function collectDynamicRoutes(manifest) {
+  const routes = [];
+  for (const route of manifest.routes) {
+    if (route.params.length === 0)
+      continue;
+    const sourceRegex = namedSourceRegex(route);
+    if (route.kind === "page") {
+      routes.push({
+        source: `${route.route}.rsc`,
+        sourceRegex: sourceRegex.replace(/\(\?:\/\)\?\$$/, String.raw`(?<rscSuffix>\.rsc|\.segments/.+\.segment\.rsc)(?:/)?$`),
+        destination: `${route.route}$rscSuffix`
+      });
+    }
+    routes.push({ source: route.route, sourceRegex, destination: route.route });
+  }
+  return routes;
+}
+async function runBuildCompleteAdapter(config, manifest) {
+  const configured = getNextConfig().adapterPath;
+  const adapterPath = process.env.NEXT_ADAPTER_PATH || (typeof configured === "string" ? configured : undefined);
+  if (!adapterPath)
+    return;
+  const resolved = path.isAbsolute(adapterPath) ? adapterPath : path.resolve(config.root, adapterPath);
+  const module = await import(pathToFileHref(resolved));
+  const adapter = module.default ?? module;
+  if (typeof adapter?.onBuildComplete !== "function")
+    return;
+  await writeServerEntries(config, manifest);
+  await adapter.onBuildComplete({
+    routing: {
+      beforeMiddleware: [],
+      middlewareMatchers: [],
+      beforeFiles: [],
+      afterFiles: [],
+      dynamicRoutes: collectDynamicRoutes(manifest),
+      onMatch: [],
+      fallback: [],
+      shouldNormalizeNextData: false,
+      rsc: undefined
+    },
+    outputs: collectOutputs(config, manifest),
+    projectDir: config.root,
+    repoRoot: config.root,
+    distDir: config.outPath
+  });
+}
+
+// src/compat/register/build.ts
+function registerBuildCompatExtensions() {
+  registerBuildCompleteHooks(({ config, manifest }) => writeFunctionsConfigManifest(config.outPath, manifest));
+  registerBuildCompleteHooks(({ config }) => writeRequiredServerFilesManifest(config));
+  registerBuildCompleteHooks(({ config }) => writeTraceBuildFile(config));
+  registerBuildCompleteHooks(({ config, manifest }) => runBuildCompleteAdapter(config, manifest));
+  setCompatModeExtensions({
+    nextEnabled: nextCompatEnabled,
+    reactEnabled: reactCompatEnabled,
+    reactCompilerOptions
+  });
+  setBuildCompatExtensions({
+    warnMetadataIssues: ({ appPath, routes, staticMetadataFiles }) => warnNextMetadataBuildIssues(appPath, routes, staticMetadataFiles),
+    nextOutputExport: () => getNextConfig().output === "export",
+    nextOutputMode: () => {
+      const output = getNextConfig().output;
+      return output === "export" || output === "standalone" ? output : undefined;
+    },
+    nextScriptWorkersEnabled: () => {
+      const experimental = getNextConfig().experimental;
+      return experimental?.nextScriptWorkers === true;
+    },
+    defaultExpireTimeSeconds: () => {
+      const expireTime = getNextConfig().expireTime;
+      return typeof expireTime === "number" ? expireTime : undefined;
+    },
+    withVaryParamsTracking,
+    varyNamesFor: (vary, kind) => varyNamesFor(vary, kind),
+    takeCacheLifeStash,
+    takeFontLinkHeader: () => {
+      const fontValues = takeFontHeaderPreloads().map(fontLinkHeaderValue);
+      const hintValue = takeResourceHintHeader();
+      const values = [...fontValues, ...hintValue ? [hintValue] : []];
+      if (values.length === 0)
+        return;
+      return values.join(", ");
+    },
+    normalizeStaticParamsModule: aliasGenerateStaticParams,
+    defaultDynamicStaleTimeSeconds: DEFAULT_DYNAMIC_STALE_TIME_SECONDS,
+    defaultStaticStaleTimeSeconds: DEFAULT_STATIC_STALE_TIME_SECONDS,
+    buildRootTreePrefetch,
+    rootTreePrefetchText,
+    buildSegmentMeta,
+    segmentDir,
+    treeSegmentFile,
+    bodySegmentFile,
+    segmentMetaFile
+  });
+}
+async function writeRequiredServerFilesManifest(config) {
+  if (!nextCompatEnabled(config))
+    return;
+  const id = deploymentId();
+  if (!id)
+    return;
+  const outDir = path2.join(config.root, ".next");
+  await mkdir2(outDir, { recursive: true });
+  await writeFile2(path2.join(outDir, "required-server-files.json"), JSON.stringify({ version: 1, config: { deploymentId: id } }, null, 2));
+}
+var traceBuildGlobal = globalThis;
+traceBuildGlobal.__pnextBuildStartedAt ??= performance.now();
+async function writeTraceBuildFile(config) {
+  if (!nextCompatEnabled(config))
+    return;
+  const traceId = randomTraceId();
+  const totalDuration = Math.max(1, performance.now() - (traceBuildGlobal.__pnextBuildStartedAt ?? 0));
+  const events = [
+    { name: "next-build", id: 1, traceId, duration: totalDuration },
+    { name: "run-webpack", id: 2, parentId: 1, traceId, duration: totalDuration * 0.4 },
+    { name: "run-typescript", id: 3, parentId: 1, traceId, duration: totalDuration * 0.2 },
+    { name: "static-check", id: 4, parentId: 1, traceId, duration: totalDuration * 0.1 },
+    { name: "static-generation", id: 5, parentId: 1, traceId, duration: totalDuration * 0.2 },
+    { name: "collect-build-traces", id: 6, parentId: 1, traceId, duration: totalDuration * 0.05 },
+    { name: "telemetry-flush", id: 7, parentId: 1, traceId, duration: 1 }
+  ];
+  const outDir = path2.join(config.root, ".next");
+  await mkdir2(outDir, { recursive: true });
+  await writeFile2(path2.join(outDir, "trace-build"), `${JSON.stringify(events)}
+`);
+}
+function randomTraceId() {
+  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+async function writeFunctionsConfigManifest(outPath, manifest) {
+  const routes = manifest.routes.filter((route) => route.maxDuration !== undefined);
+  if (routes.length === 0)
+    return;
+  const file = path2.join(outPath, "server", "functions-config-manifest.json");
+  let current = { version: 1, functions: {} };
+  try {
+    current = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    current = { version: 1, functions: {} };
+  }
+  for (const route of routes) {
+    const regions = preferredRegionForRoute(route);
+    current.functions[route.route || "/"] = {
+      ...current.functions[route.route || "/"] ?? {},
+      maxDuration: route.maxDuration,
+      ...regions ? { regions } : {}
+    };
+  }
+  await mkdir2(path2.dirname(file), { recursive: true });
+  await writeFile2(file, `${JSON.stringify(current, null, 2)}
+`);
+}
+// src/compat/typecheck/check.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { createRequire } from "module";
+import path3 from "path";
+import { Worker } from "worker_threads";
+class PnextTypecheckError extends Error {
+  messages;
+  constructor(messages) {
+    super(messages.join(`
+`));
+    this.name = "PnextTypecheckError";
+    this.messages = messages;
+  }
+}
+var typescriptModule;
+async function loadTypescript() {
+  typescriptModule ??= await import("typescript");
+  return typescriptModule;
+}
+function typecheckDisabled() {
+  const typescript = getNextConfig().typescript;
+  return typescript?.ignoreBuildErrors === true;
+}
+async function validateTypesOffThread(config) {
+  if (typecheckDisabled())
+    return;
+  const next = getNextConfig();
+  const input = {
+    root: config.root,
+    outPath: config.outPath,
+    outRootPath: config.outRootPath,
+    compat: config.compat,
+    nextConfig: cloneable({
+      typescript: next.typescript,
+      typedRoutes: next.typedRoutes,
+      turbopack: next.turbopack
+    })
+  };
+  let worker;
+  try {
+    worker = new Worker(new URL("./worker.ts", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/compat/typecheck/check.ts").href), { workerData: input });
+  } catch {
+    return validateTypes(config);
+  }
+  const result = await new Promise((resolve, reject) => {
+    worker.on("message", resolve);
+    worker.on("error", reject);
+    worker.on("exit", () => resolve({ ok: true }));
+  }).finally(() => void worker.terminate());
+  if (result.ok)
+    return;
+  if (result.messages)
+    throw new PnextTypecheckError(result.messages);
+  throw new Error(result.failure ?? "typecheck worker failed");
+}
+function cloneable(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return {};
+  }
+}
+async function validateTypes(config) {
+  if (typecheckDisabled())
+    return;
+  const native = await nativeCheckerBin(config.root);
+  const project = await writeTypecheckProject(config, native);
+  if (native && (await checkWithNative(native, project, config)).length === 0)
+    return;
+  const messages = await checkInProcess(project, config);
+  if (messages.length === 0)
+    return;
+  throw new PnextTypecheckError(messages);
+}
+async function checkInProcess(project, config) {
+  const ts = await loadTypescript();
+  const parsed = readProject(ts, project);
+  const program = ts.createProgram(parsed.fileNames, parsed.options);
+  const diagnostics = ts.getPreEmitDiagnostics(program).filter((diagnostic) => appDiagnostic(diagnostic.file?.fileName, config));
+  return formatDiagnostics(ts, diagnostics);
+}
+async function nativeCheckerBin(root) {
+  if (process.env.PNEXT_TYPECHECK === "classic")
+    return;
+  for (const base of [root, __PNEXT_PACKAGE_ROOT__ + "/src/compat/typecheck"]) {
+    try {
+      const require2 = createRequire(path3.join(base, "noop.js"));
+      const pkg = require2.resolve("@typescript/native-preview/package.json");
+      const { default: getExePath } = await import(path3.join(path3.dirname(pkg), "lib", "getExePath.js"));
+      const bin = getExePath();
+      if (bin && existsSync2(bin))
+        return bin;
+    } catch {}
+  }
+  return;
+}
+async function checkWithNative(bin, project, config) {
+  const proc = Bun.spawn([bin, "--noEmit", "--pretty", "false", "-p", project], {
+    cwd: config.root,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  await proc.exited;
+  return nativeDiagnostics(`${stdout}${stderr}`, config);
+}
+function nativeDiagnostics(output, config) {
+  const header = /^(?:(.+)\((\d+),(\d+)\): )?error TS\d+: (.*)$/;
+  const messages = new Set;
+  const lines = output.split(`
+`);
+  for (let index = 0;index < lines.length; index += 1) {
+    const match = header.exec(lines[index]);
+    if (!match)
+      continue;
+    const [, file, line, column, text] = match;
+    const elaborations = [];
+    while (index + 1 < lines.length && /^\s+\S/.test(lines[index + 1])) {
+      elaborations.push(lines[index + 1]);
+      index += 1;
+    }
+    const resolved = file ? path3.resolve(config.root, file) : undefined;
+    if (!appDiagnostic(resolved, config))
+      continue;
+    const raw = [text, ...elaborations].join(`
+`);
+    const location = resolved ? `${resolved}:${line}:${column}
+` : "";
+    messages.add(`${location}Type error: ${typedRouteMessage(raw) ?? raw}`);
+  }
+  return [...messages];
+}
+function appDiagnostic(file, config) {
+  if (!file)
+    return true;
+  const resolved = path3.resolve(file);
+  if (resolved === generatedProjectPath(config))
+    return true;
+  if (!resolved.startsWith(config.root + path3.sep))
+    return false;
+  if (resolved.includes(`${path3.sep}node_modules${path3.sep}`))
+    return false;
+  if (resolved.startsWith(path3.resolve(config.outRootPath) + path3.sep))
+    return false;
+  return true;
+}
+function generatedProjectPath(config) {
+  return path3.resolve(config.outRootPath, "typecheck", "tsconfig.json");
+}
+function reactTypePaths(root, basePaths, compatPreact) {
+  const react = resolveTypesDir("react", root);
+  if (!react)
+    return basePaths;
+  const reactDom = resolveTypesDir("react-dom", root);
+  const paths = { ...basePaths };
+  const mappings = {
+    react: path3.join(react, "index.d.ts"),
+    "react/*": path3.join(react, "*"),
+    "react-dom": reactDom && path3.join(reactDom, "index.d.ts"),
+    "react-dom/*": reactDom && path3.join(reactDom, "*"),
+    preact: compatPreact
+  };
+  for (const [key, value] of Object.entries(mappings)) {
+    if (value)
+      paths[key] = [value];
+  }
+  return paths;
+}
+function resolveTypesDir(name, root) {
+  for (const base of [root, __PNEXT_PACKAGE_ROOT__ + "/src/compat/typecheck"]) {
+    try {
+      const require2 = createRequire(path3.join(base, "noop.js"));
+      return path3.dirname(require2.resolve(`@types/${name}/package.json`));
+    } catch {}
+  }
+  return;
+}
+function absolutePaths(paths, basePath) {
+  if (!paths)
+    return;
+  return Object.fromEntries(Object.entries(paths).map(([key, targets]) => [
+    key,
+    targets.map((target) => path3.isAbsolute(target) ? target : path3.resolve(basePath, target))
+  ]));
+}
+function resolvePackageDir(name, root) {
+  for (const base of [root, __PNEXT_PACKAGE_ROOT__ + "/src/compat/typecheck"]) {
+    try {
+      const require2 = createRequire(path3.join(base, "noop.js"));
+      return path3.dirname(require2.resolve(`${name}/package.json`));
+    } catch {}
+  }
+  return;
+}
+async function writeTypecheckProject(config, native) {
+  const dir = path3.join(config.outRootPath, "typecheck");
+  await mkdir3(dir, { recursive: true });
+  const reactTypes = resolveTypesDir("react", config.root);
+  const hasReactTypes = reactTypes !== undefined;
+  const rootParams = scanRootParamTypes(path3.join(config.root, "app"));
+  const hasRealNext = realNextResolvable(config.root);
+  const omitNextModuleShims = typedRoutesEnabled() && hasRealNext;
+  const legacyRequestTypes = typeof config.compat?.next === "object" && config.compat.next.legacyRequestAPIs === true;
+  await writeFile3(path3.join(dir, "next-shims.d.ts"), nextShims(hasReactTypes, rootParams, omitNextModuleShims, legacyRequestTypes, hasRealNext));
+  const preact = resolvePackageDir("preact", config.root);
+  if (reactTypes && preact) {
+    await writeFile3(preactTypeShimPath(config), preactTypeShim(preact, reactTypes));
+  }
+  const base = tsconfigPath(config.root);
+  const baseProject = base ? await readBaseProject(base, native) : undefined;
+  const baseOptions = baseProject?.options ?? {};
+  const preactShim = preactTypeShimPath(config);
+  const project = generatedProjectPath(config);
+  const paths = reactTypePaths(config.root, absolutePaths(baseOptions.paths, baseOptions.baseUrl ?? (base ? path3.dirname(base) : config.root)), existsSync2(preactShim) ? preactShim : undefined);
+  const nodeTypes = resolveTypesDir("node", config.root);
+  await writeFile3(project, JSON.stringify({
+    ...base ? { extends: base } : {},
+    compilerOptions: {
+      noEmit: true,
+      incremental: true,
+      tsBuildInfoFile: path3.join(config.root, "node_modules", ".cache", "pnext", "typecheck.tsbuildinfo"),
+      skipLibCheck: true,
+      allowJs: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "preserve",
+      ...paths ? { paths } : {},
+      ...baseOptions.strict === undefined ? { strict: false } : {},
+      ...baseOptions.target === undefined ? { target: "es2022" } : {},
+      ...baseOptions.module === undefined ? { module: "esnext" } : {},
+      ...baseOptions.moduleResolution === undefined ? { moduleResolution: "bundler" } : {},
+      ...baseOptions.lib === undefined ? { lib: ["es2022", "dom", "dom.iterable"] } : {}
+    },
+    include: [
+      path3.join(dir, "next-shims.d.ts"),
+      path3.join(dir, "checks", "**/*.ts"),
+      ...nodeTypes ? [path3.join(nodeTypes, "index.d.ts")] : [],
+      path3.join(config.root, "next-env.d.ts"),
+      ...!legacyRequestTypes && existsSync2(path3.join(config.root, ".next/types/validator.ts")) ? [path3.join(config.root, ".next/types/validator.ts")] : [],
+      path3.join(config.root, "middleware.*"),
+      path3.join(config.root, "proxy.*"),
+      path3.join(config.root, "next.config.ts"),
+      path3.join(config.root, "next.config.mts"),
+      path3.join(config.root, "next.config.cts"),
+      path3.join(config.root, "app/**/*.ts"),
+      path3.join(config.root, "app/**/*.tsx"),
+      path3.join(config.root, "pages/**/*.ts"),
+      path3.join(config.root, "pages/**/*.tsx"),
+      ...baseAmbientDeclarations(baseProject?.fileNames, config)
+    ],
+    exclude: [
+      path3.join(config.root, "node_modules"),
+      path3.join(config.root, "**/*.test.ts"),
+      path3.join(config.root, "**/*.test.tsx")
+    ]
+  }, null, 2));
+  return project;
+}
+function preactTypeShimPath(config) {
+  return path3.join(config.outRootPath, "typecheck", "preact-compat.d.ts");
+}
+function preactTypeShim(preact, react) {
+  const preactTypes = JSON.stringify(path3.join(preact, "src", "index.d.ts"));
+  const types = JSON.stringify(path3.join(react, "index.d.ts"));
+  return `import type { ReactNode } from ${types}
+
+export * from ${preactTypes}
+export type ComponentChild = ReactNode
+export type ComponentChildren = ReactNode
+`;
+}
+function typedRoutesEnabled() {
+  return getNextConfig().typedRoutes === true;
+}
+function realNextResolvable(root) {
+  try {
+    createRequire(path3.join(root, "noop.js")).resolve("next/package.json");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function baseAmbientDeclarations(fileNames, config) {
+  if (!fileNames)
+    return [];
+  const outPath = path3.resolve(config.outPath) + path3.sep;
+  return fileNames.map((name) => path3.resolve(name)).filter((name) => name.endsWith(".d.ts") && !name.includes(`${path3.sep}node_modules${path3.sep}`) && !name.startsWith(outPath));
+}
+async function readBaseProject(file, native) {
+  const shown = native ? await showConfigViaNative(native, file) : undefined;
+  if (shown)
+    return shown;
+  const ts = await loadTypescript();
+  const parsed = readProject(ts, file);
+  return { options: parsed.options, fileNames: [...parsed.fileNames] };
+}
+async function showConfigViaNative(bin, file) {
+  try {
+    const proc = Bun.spawn([bin, "--showConfig", "-p", file], { stdout: "pipe", stderr: "pipe" });
+    const stdout = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode !== 0)
+      return;
+    const shown = JSON.parse(stdout);
+    const dir = path3.dirname(file);
+    const options = shown.compilerOptions ?? {};
+    if (typeof options.baseUrl === "string")
+      options.baseUrl = path3.resolve(dir, options.baseUrl);
+    const fileNames = (shown.files ?? []).map((f) => path3.resolve(dir, f));
+    return { options, fileNames };
+  } catch {
+    return;
+  }
+}
+function tsconfigPath(root) {
+  const tsConfig = getNextConfig().typescript;
+  const configured = tsConfig?.tsconfigPath;
+  const file = typeof configured === "string" && configured.length > 0 ? path3.join(root, configured) : path3.join(root, "tsconfig.json");
+  return existsSync2(file) ? file : undefined;
+}
+var parsedProjects = new Map;
+function readProject(ts, project) {
+  let stamp = 0;
+  try {
+    stamp = statSync(project).mtimeMs;
+  } catch {}
+  const cached = parsedProjects.get(project);
+  if (cached?.stamp === stamp)
+    return cached.parsed;
+  const read = ts.readConfigFile(project, (file) => ts.sys.readFile(file));
+  if (read.error)
+    throw new PnextTypecheckError(formatDiagnostics(ts, [read.error]));
+  const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, path3.dirname(project));
+  parsedProjects.set(project, { stamp, parsed });
+  return parsed;
+}
+function formatDiagnostics(ts, diagnostics) {
+  const messages = new Set;
+  for (const diagnostic of diagnostics) {
+    const raw = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`);
+    const typedRoute = typedRouteMessage(raw);
+    let location = "";
+    if (diagnostic.file && diagnostic.start !== undefined) {
+      const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+      location = `${diagnostic.file.fileName}:${line + 1}:${character + 1}
+`;
+    }
+    messages.add(`${location}Type error: ${typedRoute ?? raw}`);
+  }
+  return [...messages];
+}
+function typedRouteMessage(message) {
+  const match = /^Type '(".*")' is not assignable to type '.*RouteImpl<\1>/.exec(message);
+  if (!match?.[1])
+    return;
+  return `${match[1]} is not an existing route. If it is intentional, please type it explicitly with \`as Route\`.`;
+}
+function rootParamsModule(rootParams) {
+  const order = ["string", "string[]", "undefined"];
+  const entries = rootParams.size > 0 ? [...rootParams.entries()].map(([name, types]) => [
+    name,
+    order.filter((type) => types.has(type)).join(" | ")
+  ]) : [
+    ["lang", "string | string[] | undefined"],
+    ["locale", "string | string[] | undefined"]
+  ];
+  const getters = entries.map(([name, union]) => `  export function ${name}(): Promise<${union}>`).join(`
+`);
+  return `declare module 'next/root-params' {
+${getters}
+  const rootParams: (...args: any[]) => Promise<any>
+  export default rootParams
+}`;
+}
+function stripNextModuleDeclarations(source) {
+  const lines = source.split(`
+`);
+  const out = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (/^declare module 'next[^']*' \{/.test(line)) {
+      let depth = 0;
+      for (;i < lines.length; i++) {
+        const current = lines[i];
+        depth += (current.match(/\{/g)?.length ?? 0) - (current.match(/\}/g)?.length ?? 0);
+        if (depth === 0)
+          break;
+      }
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join(`
+`);
+}
+function nextShims(hasReactTypes, rootParams, omitNextModuleShims = false, legacyRequestTypes = false, hasRealNext = false) {
+  const reactShims = hasReactTypes ? "" : `
+declare namespace JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [name: string]: any
+  }
+}
+
+declare namespace React {
+  type ReactNode = any
+  type ComponentType<P = any> = (props: P) => ReactNode
+}
+
+declare module 'react' {
+  export type ReactNode = any
+  export type ComponentType<P = any> = (props: P) => ReactNode
+  export type AnchorHTMLAttributes<T> = any
+  export type DetailedHTMLProps<E, T> = any
+  export const Suspense: ComponentType<any>
+  export const ViewTransition: ComponentType<any>
+  export function addTransitionType(type: string): void
+}
+
+declare module 'react/jsx-runtime' {
+  export const jsx: any
+  export const jsxs: any
+  export const Fragment: any
+}
+`;
+  const requestType = (type) => legacyRequestTypes ? `Promise<${type}> & ${type}` : `Promise<${type}>`;
+  const requestShims = `declare module 'next/headers'{interface CookieSetOptions{name?:string;value?:string;path?:string;maxAge?:number;expires?:Date|number;httpOnly?:boolean;secure?:boolean;sameSite?:'strict'|'lax'|'none'|boolean;domain?:string}interface CookieStore{get(name:string):{name:string;value:string}|undefined;get(options:{name:string;value?:string}):{name:string;value:string}|undefined;getAll(name?:string):{name:string;value:string}[];getAll(options:{name:string;value?:string}):{name:string;value:string}[];has(name:string):boolean;readonly size:number;set(options:CookieSetOptions):CookieStore;set(name:string,value:string,options?:CookieSetOptions):CookieStore;delete(name:string):boolean;clear():CookieStore;[Symbol.iterator]():IterableIterator<readonly[string,{name?:string;value:string}]>}export function cookies():${requestType("CookieStore")};export function headers():${requestType("Headers")};export function draftMode():${requestType(`{isEnabled:boolean;enable():void;disable():void}`)}}
+`;
+  const fontShims = hasRealNext ? "" : `declare module 'next/font'{export interface FontModule{className:string;style:{fontFamily:string;fontWeight?:number;fontStyle?:string};variable:string}}
+declare module 'next/font/local'{import type{FontModule}from'next/font';export default function localFont(options:any):FontModule}
+declare module 'next/font/google'{import type{FontModule}from'next/font';type FontLoader=(options?:any)=>FontModule;const font:FontLoader;export default font;export const Inter:FontLoader,Geist:FontLoader,Geist_Mono:FontLoader,Roboto:FontLoader,Roboto_Mono:FontLoader,Open_Sans:FontLoader,Lato:FontLoader,Montserrat:FontLoader,Poppins:FontLoader,Noto_Sans:FontLoader}
+`;
+  const source = `${reactShims}
+declare const process: {
+  env: Record<string, string | undefined>
+  emit?: (...args: any[]) => boolean
+  cwd(): string
+  platform: string
+  arch: string
+  version: string
+  versions: Record<string, string>
+  nextTick(callback: (...args: any[]) => void, ...args: any[]): void
+  argv: string[]
+  pid: number
+  exit(code?: number): never
+  [key: string]: any
+}
+
+declare const EdgeRuntime: string
+
+declare const require: (id: string) => any
+
+declare class Buffer extends Uint8Array {}
+
+declare module 'async_hooks' {
+  export class AsyncLocalStorage<T> {
+    run<R>(store: T, callback: () => R): R
+    getStore(): T | undefined
+  }
+}
+
+declare module 'timers/promises' {
+  export function setTimeout<T = void>(delay?: number, value?: T, options?: any): Promise<T>
+  export function setImmediate<T = void>(value?: T, options?: any): Promise<T>
+  export function setInterval<T = void>(delay?: number, value?: T, options?: any): AsyncIterable<T>
+}
+
+declare module 'node:timers/promises' {
+  export * from 'timers/promises'
+}
+
+declare module 'node:crypto' {
+  interface KeyObject {
+    export(...args: any[]): any
+    toString(...args: any[]): string
+  }
+  export function randomInt(...args: any[]): number
+  export function randomBytes(...args: any[]): Buffer
+  export function randomFillSync<T extends Uint8Array>(buffer: T, ...args: any[]): T
+  export function randomUUID(...args: any[]): string
+  export function getRandomValues<T extends Uint8Array>(array: T): T
+  export function generateKeyPairSync(...args: any[]): { publicKey: any; privateKey: any }
+  export function generateKeySync(...args: any[]): KeyObject
+  export function generatePrimeSync(...args: any[]): ArrayBuffer | Uint8Array
+  const crypto: {
+    randomInt: typeof randomInt
+    randomBytes: typeof randomBytes
+    randomFillSync: typeof randomFillSync
+    randomUUID: typeof randomUUID
+    getRandomValues: typeof getRandomValues
+    generateKeyPairSync: typeof generateKeyPairSync
+    generateKeySync: typeof generateKeySync
+    generatePrimeSync: typeof generatePrimeSync
+  }
+  export default crypto
+}
+
+declare module 'crypto' {
+  export * from 'node:crypto'
+  export { default } from 'node:crypto'
+}
+
+// Next.js augments the fetch RequestInit with a "next" field for its extended
+// fetch semantics (revalidate/tags); mirror that here so app code using
+// fetch(url, next revalidate) typechecks.
+interface RequestInit {
+  next?: {
+    revalidate?: number | false
+    tags?: string[]
+  }
+}
+
+interface ResponseInit {
+  request?: {
+    headers?: HeadersInit
+  }
+}
+
+declare module 'node:buffer' {
+  export const Buffer: any
+  export const constants: any
+  export const kMaxLength: number
+  export const kStringMaxLength: number
+  export const SlowBuffer: any
+}
+
+declare module 'url' {
+  export interface UrlObject {
+    pathname?: string
+    query?: Record<string, string | string[]>
+    hash?: string
+  }
+}
+
+declare module 'next/types.js' {
+  export interface NextConfig {
+    env?: Record<string, string | number | boolean | undefined>
+    typedRoutes?: boolean
+    typescript?: { tsconfigPath?: string; ignoreBuildErrors?: boolean }
+    eslint?: { ignoreDuringBuilds?: boolean; dirs?: string[] }
+    [key: string]: any
+  }
+  export type Metadata = any
+  export type Viewport = any
+  export type ResolvingMetadata = Promise<Metadata>
+  export type ResolvingViewport = Promise<Viewport>
+  export type NextApiHandler<T = any> = (...args: any[]) => any
+  export type NextApiRequest = any
+  export type NextApiResponse<T = any> = any
+  export namespace MetadataRoute {
+    type Robots = any
+    type Sitemap = any[]
+    type Manifest = any
+  }
+  export type Route<T = string> = string
+  export type NextPage<P = {}, IP = P> = ((props: P) => any) & { [key: string]: any }
+  export type NextComponentType<C = any, IP = any, P = any> = any
+  export type PageProps<P = any> = any
+  export type LayoutProps<P = any> = any
+}
+
+declare module 'next/types' {
+  export * from 'next/types.js'
+  export { MetadataRoute } from 'next/types.js'
+}
+
+declare module 'next' {
+  export type {
+    NextConfig,
+    Metadata,
+    Viewport,
+    ResolvingMetadata,
+    ResolvingViewport,
+    NextApiRequest,
+    NextApiResponse,
+    NextApiHandler,
+    Route,
+    NextPage,
+    NextComponentType,
+    PageProps,
+    LayoutProps,
+  } from 'next/types.js'
+  export { MetadataRoute } from 'next/types.js'
+  export type GetServerSideProps<P = any, Q = any> = any
+  export type GetStaticProps<P = any, Q = any> = any
+  export type GetStaticPaths<Q = any> = any
+  export type InferGetServerSidePropsType<T = any> = any
+  export type InferGetStaticPropsType<T = any> = any
+}
+
+declare module 'next/cache' {
+  export function revalidatePath(path: string, type?: 'page' | 'layout'): void
+  export function revalidateTag(tag: string, profile: string | { expire?: number }): void
+  export function updateTag(tag: string): void
+  export function unstable_cache(...args: any[]): any
+  export function unstable_noStore(): void
+  export function unstable_expirePath(path: string, type?: 'page' | 'layout'): void
+  export function unstable_expireTag(...tags: string[]): void
+  export function expirePath(path: string, type?: 'page' | 'layout'): void
+  export function expireTag(...tags: string[]): void
+  export function refresh(): void
+  export function unstable_refresh(): void
+  export const io: any
+  export const cacheTag: (...tags: string[]) => void
+  export const cacheLife: (...args: any[]) => void
+  export const unstable_cacheTag: (...tags: string[]) => void
+  export const unstable_cacheLife: (...args: any[]) => void
+}
+
+${requestShims}
+
+declare module 'next/server' {
+  interface NextURL extends URL {
+    clone(): NextURL
+    basePath: string
+    buildId?: string
+    locale: string
+    defaultLocale?: string
+  }
+  interface RequestCookie {
+    name: string
+    value: string
+  }
+  interface RequestCookies {
+    get(name: string): RequestCookie | undefined
+    getAll(name?: string): RequestCookie[]
+    has(name: string): boolean
+    set(name: string, value: string): RequestCookies
+    set(cookie: RequestCookie): RequestCookies
+    delete(name: string | string[]): boolean | boolean[]
+    clear(): RequestCookies
+    readonly size: number
+    [Symbol.iterator](): IterableIterator<[string, RequestCookie]>
+  }
+  interface ResponseCookies {
+    get(name: string): (RequestCookie & Record<string, any>) | undefined
+    getAll(name?: string): (RequestCookie & Record<string, any>)[]
+    has(name: string): boolean
+    set(name: string, value: string, options?: any): ResponseCookies
+    set(options: { name: string; value: string; [key: string]: any }): ResponseCookies
+    delete(name: string, options?: any): ResponseCookies
+    [Symbol.iterator](): IterableIterator<[string, RequestCookie & Record<string, any>]>
+  }
+  export class NextRequest extends Request {
+    nextUrl: NextURL
+    cookies: RequestCookies
+    geo?: any
+    ip?: string
+  }
+  export class NextResponse extends Response {
+    cookies: ResponseCookies
+    static json(body: any, init?: ResponseInit): NextResponse
+    static next(init?: ResponseInit): NextResponse
+    static redirect(url: string | URL, init?: number | ResponseInit): NextResponse
+    static rewrite(url: string | URL, init?: ResponseInit): NextResponse
+  }
+  export type NextFetchEvent = any
+  export type NextMiddleware = (...args: any[]) => any
+  export type NextMiddlewareResult = any
+  export interface ProxyConfig {
+    matcher?: string | { source: string } | Array<string | { source: string }>
+  }
+  export class ImageResponse extends Response {
+    constructor(element: any, options?: any)
+  }
+  export const URLPattern: any
+  export function userAgent(request: { headers: Headers }): any
+  export function userAgentFromString(ua: string | undefined): any
+  export function after(task: any): void
+  export function connection(): Promise<void>
+  export const io: any
+}
+
+declare module 'next/server.js' {
+  export * from 'next/server'
+}
+
+declare module 'next/navigation.js' {
+  export * from 'next/navigation'
+}
+
+declare module 'next/headers.js' {
+  export * from 'next/headers'
+}
+
+declare module 'next/cache.js' {
+  export * from 'next/cache'
+}
+
+declare module 'next/link.js' {
+  export * from 'next/link'
+  export { default } from 'next/link'
+}
+
+declare module 'next/image.js' {
+  export * from 'next/image'
+  export { default } from 'next/image'
+}
+
+declare module 'next/script.js' {
+  export * from 'next/script'
+  export { default } from 'next/script'
+}
+
+declare module 'next/dist/client/link.js' {
+  export interface LinkProps {
+    href: any
+  }
+  export function useLinkStatus(): any
+}
+
+declare module 'next/link' {
+  import type { AnchorHTMLAttributes, ComponentType } from 'react'
+  // Mirror Next's public LinkProps: standard anchor attributes plus Link's own
+  // props, but NO catch-all index signature. A wildcard string index signature
+  // would silently accept non-public props (e.g. unstable_dynamicOnHover),
+  // making a fixture's ts-expect-error on such a prop report as unused.
+  export interface LinkProps
+    extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+    href: any
+    // Next 16's public prefetch type. The unstable_forceStale value is
+    // runtime-only and Next deliberately keeps it OUT of the public union, so an
+    // exhaustive switch over prefetch ending in "prefetch satisfies never"
+    // stays valid. Including it here would leave that value in the default
+    // branch and break such fixtures under our shim.
+    prefetch?: boolean | 'auto' | null
+    scroll?: boolean
+    replace?: boolean
+    as?: any
+    shallow?: boolean
+    passHref?: boolean
+    locale?: string | false
+    legacyBehavior?: boolean
+    onNavigate?: (event: { preventDefault(): void }) => void
+    transitionTypes?: string[]
+    children?: any
+  }
+  const Link: ComponentType<LinkProps>
+  export default Link
+  export function useLinkStatus(): { pending: boolean }
+}
+
+declare module 'next/image' {
+  import type { ComponentType } from 'react'
+  export interface ImageProps {
+    src: any
+    alt: string
+    width?: number | string
+    height?: number | string
+    fill?: boolean
+    priority?: boolean
+    loading?: 'lazy' | 'eager'
+    placeholder?: string
+    blurDataURL?: string
+    unoptimized?: boolean
+    sizes?: string
+    quality?: number | string
+    className?: string
+    [key: string]: any
+  }
+  export interface StaticImageData {
+    src: string
+    height: number
+    width: number
+    blurDataURL?: string
+    blurWidth?: number
+    blurHeight?: number
+  }
+  const Image: ComponentType<ImageProps>
+  export default Image
+  export function getImageProps(props: ImageProps): { props: any }
+  export function unstable_getImgProps(props: ImageProps): { props: any }
+}
+
+declare module '@vercel/og' {
+  export class ImageResponse extends Response {
+    constructor(element: any, options?: any)
+  }
+  export type ImageResponseOptions = any
+}
+
+declare module 'next/og' {
+  export class ImageResponse extends Response {
+    constructor(element: any, options?: any)
+    static json(...args: any[]): ImageResponse
+  }
+  export interface ImageResponseOptions {
+    width?: number
+    height?: number
+    fonts?: any[]
+    debug?: boolean
+    status?: number
+    statusText?: string
+    headers?: HeadersInit
+    emoji?: string
+    [key: string]: any
+  }
+}
+
+declare module 'next/dynamic' {
+  import type { ComponentType } from 'react'
+  export interface DynamicOptions {
+    loading?: ComponentType<any>
+    ssr?: boolean
+    loadableGenerated?: any
+    suspense?: boolean
+    [key: string]: any
+  }
+  // Infer P from the loader like real next/dynamic's Loader<P>; a bare
+  // Promise<any> loader would collapse P to any and strip prop types.
+  type LoaderComponent<P> = ComponentType<P> | { default: ComponentType<P> }
+  export default function dynamic<P = {}>(
+    loader: (() => Promise<LoaderComponent<P>>) | Promise<LoaderComponent<P>>,
+    options?: DynamicOptions,
+  ): ComponentType<P>
+}
+
+declare module 'next/error' {
+  import type { ComponentType, ReactNode } from 'react'
+  export interface ErrorInfo {
+    error: Error
+    reset: () => void
+    unstable_retry: () => void
+    [key: string]: any
+  }
+  export interface ErrorProps {
+    statusCode: number
+    title?: string
+    withDarkMode?: boolean
+    [key: string]: any
+  }
+  const ErrorComponent: ComponentType<ErrorProps>
+  export default ErrorComponent
+  // Wraps a fallback renderer (props, info) => JSX in an error boundary. The
+  // returned component takes the fallback's own props plus children (the
+  // guarded subtree) and an optional clearError reset callback. Mirrors the
+  // runtime in src/compat/next/error.tsx.
+  export function unstable_catchError<P extends Record<string, any> = any>(
+    fallback: (props: P, info: ErrorInfo) => ReactNode,
+  ): ComponentType<P & { children?: ReactNode; clearError?: () => void }>
+}
+
+${fontShims}
+
+declare module 'next/script' {
+  import type { ComponentType } from 'react'
+  export interface ScriptProps {
+    src?: string
+    strategy?: 'afterInteractive' | 'lazyOnload' | 'beforeInteractive' | 'worker'
+    onLoad?: (...args: any[]) => void
+    onReady?: (...args: any[]) => void
+    onError?: (...args: any[]) => void
+    id?: string
+    children?: any
+    [key: string]: any
+  }
+  const Script: ComponentType<ScriptProps>
+  export default Script
+}
+
+declare module 'next/legacy/image' {
+  import type { ComponentType } from 'react'
+  export interface ImageProps {
+    src: any
+    alt?: string
+    width?: number | string
+    height?: number | string
+    layout?: 'fixed' | 'intrinsic' | 'responsive' | 'fill'
+    objectFit?: string
+    objectPosition?: string
+    priority?: boolean
+    loading?: 'lazy' | 'eager'
+    placeholder?: string
+    blurDataURL?: string
+    unoptimized?: boolean
+    sizes?: string
+    quality?: number | string
+    [key: string]: any
+  }
+  const Image: ComponentType<ImageProps>
+  export default Image
+}
+
+${rootParamsModule(rootParams)}
+
+declare module 'next/web-vitals' {
+  export interface NextWebVitalsMetric {
+    id: string
+    name: string
+    startTime: number
+    value: number
+    label: 'web-vital' | 'custom'
+    [key: string]: any
+  }
+  export function useReportWebVitals(reportFn: (metric: NextWebVitalsMetric) => void): void
+}
+
+declare module 'next/dist/client/components/app-router-headers' {
+  export const NEXT_RSC_UNION_QUERY: string
+  export const RSC_HEADER: string
+  export const NEXT_ROUTER_STATE_TREE_HEADER: string
+  export const NEXT_ROUTER_PREFETCH_HEADER: string
+  export const NEXT_URL: string
+  const headers: Record<string, string>
+  export default headers
+}
+
+declare module 'next/dist/server/app-render/work-unit-async-storage.external' {
+  export const workUnitAsyncStorage: {
+    getStore(): any
+    run<R>(store: any, callback: () => R): R
+  }
+}
+
+declare module 'next/dist/server/web/spec-extension/adapters/headers' {
+  export class ReadonlyHeaders extends Headers {}
+}
+
+declare module 'next/dist/server/web/spec-extension/adapters/request-cookies' {
+  export interface ReadonlyRequestCookies {
+    get(name: string): { name: string; value: string } | undefined
+    getAll(name?: string): { name: string; value: string }[]
+    has(name: string): boolean
+    readonly size: number
+    [Symbol.iterator](): IterableIterator<[string, { name: string; value: string }]>
+  }
+}
+
+declare module 'node-fetch' {
+  export class Headers {
+    get(name: string): string | null
+    has(name: string): boolean
+    set(name: string, value: string): void
+    append(name: string, value: string): void
+    delete(name: string): void
+    forEach(callback: (value: string, name: string) => void): void
+    [Symbol.iterator](): IterableIterator<[string, string]>
+  }
+  const fetch: (...args: any[]) => Promise<any>
+  export default fetch
+}
+
+declare module 'next/router' {
+  export interface NextRouter {
+    route: string
+    pathname: string
+    asPath: string
+    query: Record<string, string | string[] | undefined>
+    push(url: any, as?: any, options?: any): Promise<boolean>
+    replace(url: any, as?: any, options?: any): Promise<boolean>
+    prefetch(url: string): Promise<void>
+    back(): void
+    reload(): void
+    beforePopState(callback: (...args: any[]) => boolean): void
+    events: {
+      on(type: string, handler: (...args: any[]) => void): void
+      off(type: string, handler: (...args: any[]) => void): void
+      emit(type: string, ...args: any[]): void
+    }
+  }
+  export function useRouter(): NextRouter
+  const router: NextRouter
+  export default router
+}
+
+declare module 'next/app' {
+  // Pages-router shim: pnext builds the app directory only, but fixtures and
+  // hybrid apps may carry a pages/ tree whose _app imports next/app. The type
+  // program includes pages/**, so this keeps the typecheck from failing a
+  // build over files pnext never bundles.
+  export interface AppProps<P = any> {
+    Component: (props: P) => any
+    pageProps: P
+    router?: any
+    [key: string]: any
+  }
+  export type AppType = (props: AppProps) => any
+  const App: AppType
+  export default App
+}
+
+declare module 'next/dist/client/components/navigation.js' {
+  export interface NavigateOptions {
+    scroll?: boolean
+  }
+  export interface PrefetchOptions {
+    kind?: 'auto' | 'full'
+    onInvalidate?: () => void
+  }
+  export interface AppRouterInstance {
+    push(href: string, options?: NavigateOptions): void
+    replace(href: string, options?: NavigateOptions): void
+    prefetch(href: string, options?: PrefetchOptions): void
+    refresh(): void
+    back(): void
+    forward(): void
+    bfcacheId: string
+  }
+  export function useRouter(): AppRouterInstance
+  export function notFound(): never
+}
+
+declare module 'next/navigation' {
+  export interface NavigateOptions {
+    scroll?: boolean
+  }
+  export interface PrefetchOptions {
+    kind?: 'auto' | 'full'
+    onInvalidate?: () => void
+  }
+  export interface AppRouterInstance {
+    push(href: string, options?: NavigateOptions): void
+    replace(href: string, options?: NavigateOptions): void
+    prefetch(href: string, options?: PrefetchOptions): void
+    refresh(): void
+    back(): void
+    forward(): void
+    bfcacheId: string
+  }
+  export function useRouter(): AppRouterInstance
+  export function usePathname(): string
+  export class ReadonlyURLSearchParams extends URLSearchParams {
+    append(): never
+    delete(): never
+    set(): never
+    sort(): never
+  }
+  export function useSearchParams(): ReadonlyURLSearchParams
+  export function useParams<T = Record<string, string | string[]>>(): T
+  export function useSelectedLayoutSegment(parallelRoutesKey?: string): string | null
+  export function useSelectedLayoutSegments(parallelRoutesKey?: string): string[]
+  export function useLayoutSegments(parallelRoutesKey?: string): string[]
+  export function useLinkStatus(): { pending: boolean }
+  export function unstable_isUnrecognizedActionError(error: unknown): boolean
+  export const RedirectType: { push: 'push'; replace: 'replace' }
+  export type RedirectType = 'push' | 'replace'
+  export function notFound(): never
+  export function forbidden(): never
+  export function unauthorized(): never
+  export function redirect(url: string, type?: RedirectType): never
+  export function permanentRedirect(url: string, type?: RedirectType): never
+  export function unstable_rethrow(error: unknown): void
+  export function useServerInsertedHTML(callback: () => any): void
+}
+
+declare module 'next/dist/shared/lib/app-router-context.shared-runtime.js' {
+  export interface NavigateOptions {
+    scroll?: boolean
+  }
+  export interface PrefetchOptions {
+    kind?: 'auto' | 'full'
+    onInvalidate?: () => void
+  }
+  export interface AppRouterInstance {
+    push(href: string, options?: NavigateOptions): void
+    replace(href: string, options?: NavigateOptions): void
+    prefetch(href: string, options?: PrefetchOptions): void
+    refresh(): void
+    back(): void
+    forward(): void
+    bfcacheId: string
+  }
+}
+
+declare module 'next/dist/client/components/redirect-error.js' {
+  export type RedirectType = 'replace' | 'push'
+}
+
+declare module 'next/dist/client/form.js' {
+  export interface FormProps {
+    action: any
+  }
+}
+
+declare module 'next/form' {
+  export interface FormProps {
+    action: string | ((formData: FormData) => void | Promise<void>)
+    replace?: boolean
+    scroll?: boolean
+    prefetch?: boolean
+    [key: string]: any
+  }
+  export default function Form(props: FormProps): any
+}
+
+declare module '*.module.css' {
+  const classes: Record<string, string>
+  export default classes
+}
+
+declare module '*.module.scss' {
+  const classes: Record<string, string>
+  export default classes
+}
+
+declare module '*.module.sass' {
+  const classes: Record<string, string>
+  export default classes
+}
+
+declare module '*.css' {
+  const href: string | undefined
+  export default href
+}
+
+declare module '*.scss' {
+  const href: string | undefined
+  export default href
+}
+
+declare module '*.sass' {
+  const href: string | undefined
+  export default href
+}
+
+declare module '*.png' {
+  const content: { src: string; height: number; width: number; blurDataURL?: string }
+  export default content
+}
+
+declare module '*.jpg' {
+  const content: { src: string; height: number; width: number; blurDataURL?: string }
+  export default content
+}
+
+declare module '*.jpeg' {
+  const content: { src: string; height: number; width: number; blurDataURL?: string }
+  export default content
+}
+
+declare module '*.gif' {
+  const content: { src: string; height: number; width: number; blurDataURL?: string }
+  export default content
+}
+
+declare module '*.svg' {
+  // \`any\` (not the static-image descriptor shape used above) to avoid
+  // conflicts with \`@svgr/webpack\`-style loader rules that import an SVG as
+  // a component, matching Next's own image-types/global.d.ts.
+  const content: any
+  export default content
+}
+
+declare module '*.webp' {
+  const content: { src: string; height: number; width: number; blurDataURL?: string }
+  export default content
+}
+
+declare module '*.wasm' {
+  const content: any
+  export default content
+}
+
+declare module '*.mdx' {
+  const MDXComponent: (props: any) => any
+  export default MDXComponent
+}
+
+declare module '*.md' {
+  const MDXComponent: (props: any) => any
+  export default MDXComponent
+}
+${loaderRuleAssetDeclarations()}`;
+  return omitNextModuleShims ? stripNextModuleDeclarations(source) : source;
+}
+var STANDARD_ASSET_DECLARATIONS = new Set([
+  ".css",
+  ".scss",
+  ".sass",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".webp",
+  ".wasm",
+  ".mdx",
+  ".md"
+]);
+var TS_RESOLVED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".d.ts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+]);
+function loaderRuleAssetDeclarations() {
+  const specs = new Set;
+  for (const rule of turbopackLoaderRules()) {
+    if (!rule.glob.startsWith("*"))
+      continue;
+    const ext = rule.glob.slice(1).toLowerCase();
+    if (STANDARD_ASSET_DECLARATIONS.has(ext) || TS_RESOLVED_EXTENSIONS.has(ext))
+      continue;
+    specs.add(rule.glob);
+  }
+  if (specs.size === 0)
+    return "";
+  return `${[...specs].map((spec) => `
+declare module '${spec}' {
+  const content: any
+  export default content
+}`).join("")}
+`;
+}
+
+// src/compat/register/typed-routes.ts
+function registerTypedRoutesExtensions(_config) {
+  registerBuildSteps(runTypedRoutesBuildStep);
+}
+async function runTypedRoutesBuildStep(ctx) {
+  if (!nextCompatEnabled(ctx.config))
+    return;
+  if (!legacyRequestAPIs())
+    await writeTsconfigDefaults(ctx.config);
+  await generateTypedRoutes(ctx.config, ctx.routes);
+  if (typecheckDisabled())
+    return;
+  const startedAt = performance.now();
+  registerBuildParallelPhases({
+    name: "Typecheck",
+    run: validateTypesOffThread(ctx.config).then(() => performance.now() - startedAt)
+  });
+}
+// src/compat/register/validation.ts
+var registered = false;
+onExtensionHostReset(() => registered = false);
+function registerValidationExtensions(config) {
+  if (registered)
+    return;
+  if (!nextCompatEnabled(config))
+    return;
+  registered = true;
+  const step = async (ctx) => {
+    if (!nextCompatEnabled(ctx.config))
+      return;
+    await ctx.log.step("validate build", () => Promise.resolve(validateBuild(ctx.config, ctx.routes)));
+  };
+  step.gate = true;
+  registerBuildSteps(step);
+  setBuildCompatExtensions({
+    diagnoseCacheComponentsPrerender,
+    diagnosticLeadsWithErrorLine,
+    prerenderFailureFooter,
+    recordBuildFlags: writeBuildFlags
+  });
+}
+// src/compat/register/middleware.ts
+import path4 from "path";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { fileURLToPath } from "url";
+function registerMiddlewareExtensions() {
+  registerBuildSteps(async ({ config, routes }) => {
+    if (!nextCompatEnabled(config))
+      return;
+    const file = findProxyFile(config);
+    let relative;
+    if (file) {
+      const href = await devServerModuleHref(config, file, "prod", {
+        conditionTarget: "edge",
+        externalLoadTarget: proxyExternalLoadTarget(file),
+        reactServerLayer: true
+      });
+      relative = toPosixPath(path4.relative(config.outPath, fileURLToPath(href)));
+    }
+    await writeMiddlewareManifests(config, relative, routes);
+  });
+}
+async function writeMiddlewareManifests(config, entryFile, routes = []) {
+  const source = findProxyFile(config);
+  const functions = edgeFunctionEntries(config, routes);
+  if (!source || !entryFile) {
+    if (Object.keys(functions).length === 0)
+      return;
+    const serverDir2 = path4.join(config.outPath, "server");
+    await mkdir4(serverDir2, { recursive: true });
+    await writeFile4(path4.join(serverDir2, "middleware-manifest.json"), `${JSON.stringify({ ...emptyMiddlewareManifest(), functions }, null, 2)}
+`);
+    return;
+  }
+  const moduleFile = path4.resolve(config.outPath, entryFile);
+  const module = await import(pathToFileHref(moduleFile));
+  const matchers = manifestMatchers(module.config);
+  const runtime = proxyRuntime(module.config);
+  const entrypoint = toServerEntrypoint(entryFile);
+  const serverDir = path4.join(config.outPath, "server");
+  await mkdir4(serverDir, { recursive: true });
+  if (runtime === "nodejs") {
+    const functionsConfig = {
+      version: 1,
+      functions: { "/_middleware": { runtime: "nodejs", matchers } }
+    };
+    await writeFile4(path4.join(serverDir, "functions-config-manifest.json"), `${JSON.stringify(functionsConfig, null, 2)}
+`);
+    await writeFile4(path4.join(serverDir, "middleware-manifest.json"), `${JSON.stringify({ ...emptyMiddlewareManifest(), functions }, null, 2)}
+`);
+    return;
+  }
+  const entry = {
+    name: "middleware",
+    page: "/",
+    matchers,
+    wasm: readMiddlewareWasmBindingsForOutPath(config.outPath),
+    assets: [],
+    files: [entrypoint],
+    entrypoint,
+    env: {}
+  };
+  const manifest = {
+    version: 3,
+    sortedMiddleware: ["/"],
+    middleware: { "/": entry },
+    functions
+  };
+  await writeFile4(path4.join(serverDir, "middleware-manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function emptyMiddlewareManifest() {
+  return { version: 3, sortedMiddleware: [], middleware: {}, functions: {} };
+}
+function edgeFunctionEntries(config, routes) {
+  const entries = {};
+  if (!config.appPath)
+    return entries;
+  for (const route of routes) {
+    const runtime = route.segmentConfig?.runtime;
+    if (runtime !== "edge" && runtime !== "experimental-edge")
+      continue;
+    const page = appManifestKey(config.appPath, route.file);
+    if (!page)
+      continue;
+    const regions = preferredRegionForRoute(route);
+    entries[page] = {
+      files: [],
+      name: `app${page}`,
+      page,
+      matchers: [{ regexp: `^${routeMatcherRegexp(route.route)}$`, originalSource: route.route }],
+      wasm: [],
+      assets: [],
+      env: {},
+      ...regions ? { regions } : {}
+    };
+  }
+  return entries;
+}
+function appManifestKey(appPath, file) {
+  const relative = toPosixPath(path4.relative(appPath, file));
+  if (!relative || relative.startsWith(".."))
+    return;
+  return `/${relative.replace(/\.[^./]+$/, "")}`;
+}
+function routeMatcherRegexp(route) {
+  return route.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/:([^/\\]+)/g, "[^/]+");
+}
+function manifestMatchers(config) {
+  const matcher = config?.matcher;
+  if (!matcher)
+    return [{ regexp: "^/.*$", originalSource: "/:path*" }];
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  return list.map((item) => {
+    const originalSource = typeof item === "string" ? item : item.source;
+    return { regexp: `^${matcherRegexp(originalSource)}$`, originalSource };
+  });
+}
+function matcherRegexp(matcher) {
+  if (matcher.includes("("))
+    return matcher;
+  if (matcher === "/")
+    return "/";
+  let source = "";
+  for (const segment of matcher.split("/").filter(Boolean)) {
+    if (/^:[^/]+\*$/.test(segment))
+      source += "(?:/.*)?";
+    else if (/^:[^/]+$/.test(segment))
+      source += "/[^/]+";
+    else
+      source += `/${segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`;
+  }
+  return source || "/";
+}
+function proxyRuntime(config) {
+  const runtime = config?.runtime;
+  return runtime === "nodejs" ? "nodejs" : "edge";
+}
+function toServerEntrypoint(entryFile) {
+  const posix = toPosixPath(entryFile).replace(/^\.?\//, "");
+  const withinServer = posix.startsWith("server/") ? posix : `server/${path4.posix.basename(posix)}`;
+  return withinServer.replace(/\.[^./]+$/, ".js");
+}
+// src/compat/metadata-artifacts.ts
+import { createRequire as createRequire2 } from "module";
+import { access, mkdir as mkdir5, readdir, readFile as readFile2, writeFile as writeFile5 } from "fs/promises";
+import path5 from "path";
+var foundGeistFontPath;
+async function emitMetadataRouteArtifacts(ctx) {
+  if (!nextCompatEnabled(ctx.config))
+    return;
+  const routes = ctx.manifest.routes.filter((route) => route.kind === "handler" && route.metadataRoute !== undefined);
+  if (routes.length === 0)
+    return;
+  const outPath = ctx.config.outPath;
+  const outputRoots = Array.from(new Set([
+    outPath,
+    path5.join(ctx.config.root, ".next"),
+    path5.join(path5.dirname(outPath), ".next"),
+    path5.resolve(process.cwd(), ".next")
+  ]));
+  const staticFiles = ctx.manifest.staticFiles ?? {};
+  const routeFilesById = staticFilesByRouteId(staticFiles);
+  const appDir = path5.join(ctx.config.root, ctx.config.appDir);
+  const emittedRouteDirs = new Set;
+  for (const route of routes) {
+    const nextPath = toAppPath(route, appDir);
+    const routeDir = removeLeadingSlash(nextPath);
+    emittedRouteDirs.add(routeDir);
+    const fontPaths = route.metadataRoute?.kind === "opengraph-image" ? await resolveGeistFontFiles() : [];
+    for (const root of outputRoots) {
+      const routeModuleDir = path5.join(root, "server", "app", routeDir);
+      await mkdir5(routeModuleDir, { recursive: true });
+      await writeFile5(path5.join(routeModuleDir, "route.js"), routeJsModule(route), "utf8");
+      await writeFile5(path5.join(routeModuleDir, "route_client-reference-manifest.js"), `self.__RSC_MANIFEST={}
+`, "utf8");
+      await writeFile5(path5.join(routeModuleDir, "route.js.nft.json"), `${JSON.stringify({ version: 1, files: ["route_client-reference-manifest.js", ...fontPaths] }, null, 2)}
+`, "utf8");
+      if (isForceDynamicRoute(route))
+        continue;
+      const outputs = routeFilesById.get(route.id) ?? [];
+      for (const relative of outputs) {
+        await writeStaticMetadataArtifacts(outPath, root, relative, staticFiles[relative]);
+      }
+    }
+  }
+  await emitStaticMetadataRouteTraces(outputRoots, appDir, emittedRouteDirs);
+  await writeAppPathsManifest(outputRoots, routes, appDir);
+  await mergeMiddlewareFunctionsManifest(outputRoots, routes, appDir, ctx.manifest.routes);
+  await writePrerenderManifests(outputRoots, ctx.manifest);
+}
+var prerenderAllowHeader = [
+  "host",
+  "x-matched-path",
+  "x-prerender-revalidate",
+  "x-prerender-revalidate-if-generated",
+  "x-next-revalidated-tags",
+  "x-next-revalidate-tag-token"
+];
+var prerenderBypass = [
+  { key: "next-action", type: "header" },
+  { key: "content-type", type: "header", value: "multipart/form-data;.*" }
+];
+async function writePrerenderManifests(outputRoots, manifest) {
+  const byId = new Map(manifest.routes.map((route) => [route.id, route]));
+  const entries = {};
+  for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
+    const route = metadata.routeId ? byId.get(metadata.routeId) : undefined;
+    if (route && isEdgeRoute(route))
+      continue;
+    const pathname = staticFilePathname(relative);
+    entries[pathname] = prerenderEntry(pathname, metadata, route);
+  }
+  for (const route of manifest.routes) {
+    for (const generated of route.metadataRoute?.generatedRoutes ?? []) {
+      if (entries[generated] || isEdgeRoute(route) || route.usesRequest)
+        continue;
+      entries[generated] = prerenderEntry(generated, undefined, route);
+    }
+    if (entries[route.route] || !isStaticPrerenderRoute(route))
+      continue;
+    entries[route.route] = prerenderEntry(route.route, undefined, route);
+  }
+  for (const root of outputRoots) {
+    const file = path5.join(root, "prerender-manifest.json");
+    const existing = await readJsonManifest(file);
+    await mkdir5(path5.dirname(file), { recursive: true });
+    await writeFile5(file, `${JSON.stringify({
+      version: 4,
+      routes: { ...existing?.routes ?? {}, ...entries },
+      dynamicRoutes: existing?.dynamicRoutes ?? {},
+      notFoundRoutes: existing?.notFoundRoutes ?? [],
+      preview: existing?.preview ?? {
+        previewModeId: "pnext-preview-id",
+        previewModeSigningKey: "pnext-preview-signing-key",
+        previewModeEncryptionKey: "pnext-preview-encryption-key"
+      }
+    }, null, 2)}
+`);
+  }
+}
+function staticFilePathname(relative) {
+  if (relative === "index.html")
+    return "/";
+  if (relative.endsWith("/index.html"))
+    return `/${relative.slice(0, -"/index.html".length)}`;
+  if (relative.endsWith(".html"))
+    return `/${relative.slice(0, -".html".length)}`;
+  return `/${relative}`;
+}
+function isStaticPrerenderRoute(route) {
+  if (route.mode !== "static" || route.usesRequest || isEdgeRoute(route))
+    return false;
+  if (route.kind === "page")
+    return route.params.length === 0 && !route.catchAll;
+  return route.kind === "handler" && route.metadataRoute !== undefined && route.params.length === 0;
+}
+function isEdgeRoute(route) {
+  return route.segmentConfig?.runtime === "edge" || route.segmentConfig?.runtime === "experimental-edge";
+}
+function prerenderEntry(pathname, metadata, route) {
+  return {
+    initialRevalidateSeconds: metadata?.revalidateSeconds ?? false,
+    srcRoute: route?.route ?? pathname,
+    dataRoute: pathname === "/" ? "/index.rsc" : `${pathname}.rsc`,
+    allowHeader: prerenderAllowHeader,
+    experimentalBypassFor: prerenderBypass
+  };
+}
+function staticFilesByRouteId(staticFiles) {
+  const routeFilesById = new Map;
+  for (const [relative, metadata] of Object.entries(staticFiles)) {
+    if (!metadata.routeId)
+      continue;
+    const existing = routeFilesById.get(metadata.routeId) ?? [];
+    existing.push(relative);
+    routeFilesById.set(metadata.routeId, existing);
+  }
+  return routeFilesById;
+}
+async function emitStaticMetadataRouteTraces(outputRoots, appDir, emittedRouteDirs) {
+  for (const file of discoverStaticMetadataFiles(appDir)) {
+    const routeDir = file.outputPath;
+    if (emittedRouteDirs.has(routeDir))
+      continue;
+    for (const root of outputRoots) {
+      const dir = path5.join(root, "server", "app", routeDir);
+      await mkdir5(dir, { recursive: true });
+      await writeFile5(path5.join(dir, "route.js"), `export default {}
+`, "utf8");
+      await writeFile5(path5.join(dir, "route.js.nft.json"), `${JSON.stringify({ version: 1, files: [] }, null, 2)}
+`, "utf8");
+    }
+  }
+}
+async function writeAppPathsManifest(outputRoots, routes, appDir) {
+  const nextEntries = {};
+  for (const route of routes) {
+    const appPath = toAppPath(route, appDir);
+    const key = `${appPath}/route`;
+    nextEntries[key] = `app${appPath}/route.js`;
+  }
+  for (const root of outputRoots) {
+    const manifestPath = path5.join(root, "server", "app-paths-manifest.json");
+    const existing = await readJsonManifest(manifestPath) ?? {};
+    await mkdir5(path5.dirname(manifestPath), { recursive: true });
+    await writeFile5(manifestPath, `${JSON.stringify({ ...existing, ...nextEntries }, null, 2)}
+`);
+  }
+}
+async function mergeMiddlewareFunctionsManifest(outputRoots, routes, appDir, allRoutes) {
+  const edgeRoutes = routes.filter((route) => route.segmentConfig?.runtime === "edge" || route.segmentConfig?.runtime === "experimental-edge");
+  const edgePages = allRoutes.filter((route) => route.kind === "page" && isEdgeRoute(route));
+  if (edgeRoutes.length === 0 && edgePages.length === 0)
+    return;
+  const routeEntries = edgeRoutes.map((route) => ({
+    route: `${toAppPath(route, appDir)}/route`,
+    value: {}
+  }));
+  const sharedImageChunk = "server/edge-chunks/image-response.js";
+  const hasImageResponseRoute = routes.some((route) => ["opengraph-image", "twitter-image", "apple-icon", "icon"].includes(route.metadataRoute?.kind ?? ""));
+  for (const root of outputRoots) {
+    const manifestPath = path5.join(root, "server", "middleware-manifest.json");
+    const manifest = await readJsonManifest(manifestPath);
+    const target = {
+      version: 3,
+      sortedMiddleware: [],
+      middleware: {},
+      functions: {},
+      ...manifest ?? {}
+    };
+    target.functions = target.functions ?? {};
+    for (const { route, value } of routeEntries) {
+      target.functions[route] = target.functions[route] ?? value;
+    }
+    if (hasImageResponseRoute && edgePages.length > 0) {
+      const chunkPath = path5.join(root, sharedImageChunk);
+      await mkdir5(path5.dirname(chunkPath), { recursive: true });
+      await writeFile5(chunkPath, `export const loadAdditionalAsset = true
+`);
+      for (const page of edgePages) {
+        const key = page.route === "/" ? "/page" : `${page.route}/page`;
+        target.functions[key] = { files: [sharedImageChunk] };
+      }
+    }
+    await mkdir5(path5.dirname(manifestPath), { recursive: true });
+    await writeFile5(manifestPath, `${JSON.stringify(target, null, 2)}
+`);
+  }
+}
+function isForceDynamicRoute(route) {
+  return route.segmentConfig?.dynamic === "force-dynamic";
+}
+function toRouteMeta(metadata) {
+  const headers = {};
+  for (const [name, value] of metadata.headers ?? []) {
+    headers[name.toLowerCase()] = value;
+  }
+  return {
+    status: metadata.status,
+    headers
+  };
+}
+async function writeStaticMetadataArtifacts(outPath, root, relative, metadata) {
+  if (!metadata)
+    return;
+  const source = path5.join(outPath, "static", relative);
+  const outputBase = path5.join(root, "server", "app", toPosixPath(relative));
+  await mkdir5(path5.dirname(outputBase), { recursive: true });
+  const routeMeta = JSON.stringify(toRouteMeta(metadata));
+  await writeFile5(`${outputBase}.meta`, routeMeta, "utf8");
+  try {
+    await access(source);
+  } catch {
+    return;
+  }
+  await writeFile5(`${outputBase}.body`, await readFile2(source));
+}
+function routeJsModule(route) {
+  const runtime = route.segmentConfig?.runtime ?? "nodejs";
+  const data = JSON.stringify({
+    segmentConfig: route.segmentConfig ?? null,
+    runtime,
+    metadataRoute: route.metadataRoute?.kind,
+    route: route.route
+  });
+  return `export default ${data}
+`;
+}
+function toAppPath(route, appDir) {
+  const generated = route.metadataRoute?.generatedParam;
+  const normalized = route.route.replace(/^\/+|\/+$/g, "");
+  const fileSegments = routeFileGroups(route.file, appDir);
+  const routeSegments = normalized.length > 0 ? normalized.split("/") : [];
+  const converted = routeSegments.map((segment) => routeSegmentToNextPath(segment, generated));
+  const nextPathSegments = [...fileSegments, ...converted];
+  return `/${nextPathSegments.join("/")}`;
+}
+function routeSegmentToNextPath(segment, generatedParam) {
+  const match = /^:([^*.]+)(\*)?(\..*)?$/.exec(segment);
+  if (!match)
+    return segment;
+  const name = match[1] ?? "";
+  const star = match[2] ? "..." : "";
+  const suffix = match[3] ?? "";
+  const key = generatedParam && name === "id" ? generatedParam : name;
+  return `[${star}${key}]${generatedParam && name === "id" ? "" : suffix}`;
+}
+function routeFileGroups(file, appDir) {
+  const relative = toPosixPath(path5.relative(appDir, file));
+  const parts = relative.split("/").filter(Boolean);
+  const withoutLeaf = parts.slice(0, -1);
+  const groups = [];
+  for (const segment of withoutLeaf) {
+    if (!segment.startsWith("(") || !segment.endsWith(")"))
+      break;
+    groups.push(segment);
+  }
+  return groups;
+}
+function removeLeadingSlash(pathValue) {
+  return pathValue.replace(/^\//, "");
+}
+async function readJsonManifest(filePath) {
+  try {
+    const raw = await readFile2(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+async function resolveGeistFontFiles() {
+  if (foundGeistFontPath)
+    return [foundGeistFontPath];
+  const req = createRequire2(process.cwd() + "/");
+  const candidateRoots = resolveVercelOgRoots(req);
+  for (const root of candidateRoots) {
+    const files = await findFiles(root, "Geist-Regular.ttf");
+    if (files.length === 0)
+      continue;
+    foundGeistFontPath = files[0];
+    return files.slice(0, 1);
+  }
+  return [];
+}
+function resolveVercelOgRoots(req) {
+  const roots = [];
+  for (const spec of ["@vercel/og/package.json", "next/package.json"]) {
+    try {
+      roots.push(path5.dirname(req.resolve(spec)));
+    } catch {}
+  }
+  return roots;
+}
+async function findFiles(root, targetName) {
+  const found = [];
+  const stack = [root];
+  const maxDepth = 6;
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current)
+      continue;
+    const normalizedRoot = root.replace(/\\/g, "/");
+    const normalizedCurrent = current.replace(/\\/g, "/");
+    if (normalizedCurrent.includes(`${path5.sep}.next${path5.sep}`) || normalizedCurrent.includes(`${path5.sep}.git${path5.sep}`) || normalizedCurrent.includes(`${path5.sep}node_modules${path5.sep}.cache${path5.sep}`)) {
+      continue;
+    }
+    const depth = normalizedCurrent.split("/").length;
+    if (depth > normalizedRoot.split("/").length + maxDepth)
+      continue;
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const child = path5.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(child);
+        continue;
+      }
+      if (entry.isFile() && entry.name === targetName) {
+        found.push(child);
+      }
+    }
+  }
+  return found;
+}
+
+// src/compat/export/emit.ts
+import { copyFile, mkdir as mkdir7, readFile as readFile3, rm, writeFile as writeFile7 } from "fs/promises";
+import path7 from "path";
+
+// src/compat/export/standalone.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
+import path6 from "path";
+var ENTRY_FILE = /(?:^|[\\/])(page|route)\.(?:js|jsx|ts|tsx|mjs|cjs)$/;
+async function emitStandalone({
+  config,
+  manifest,
+  log
+}) {
+  await log.step("standalone output", () => writeStandalone(config, manifest));
+}
+async function writeStandalone(config, manifest) {
+  const standaloneDir = config.outPath;
+  await writeFile6(path6.join(standaloneDir, "server.js"), standaloneServerSource());
+  await writeTraceFiles(config, standaloneDir);
+  await writeMiddlewareManifest(manifest, standaloneDir);
+}
+function standaloneServerSource() {
+  return `// pnext standalone launcher, generated by pnext build (src/compat/export/standalone.ts).
+import { spawn } from 'node:child_process';
+
+const port = Number(process.env.PORT || '3000');
+const hostname = process.env.HOSTNAME || '0.0.0.0';
+const entry = new URL('./server/entry.js', import.meta.url).href;
+const boot = \`const { start } = await import(\${JSON.stringify(entry)}); await start(\${JSON.stringify({ port, hostname })});\`;
+
+const child = spawn('bun', ['--conditions=react-server', '-e', boot], {
+  env: {
+    ...process.env,
+    // Suppresses \`pnext start\`'s "output: standalone" warning (Next gates the
+    // same warning on this private env being set by its standalone server).
+    __NEXT_PRIVATE_STANDALONE_CONFIG: '1',
+    BROWSER: 'none',
+    NODE_ENV: 'production',
+  },
+  stdio: ['ignore', 'inherit', 'inherit'],
+});
+
+child.on('error', (error) => {
+  console.error('pnext standalone: failed to start the pnext server:', error);
+  process.exit(1);
+});
+child.on('exit', (code, signal) => {
+  process.exit(code == null ? (signal ? 1 : 0) : code);
+});
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.on(signal, () => {
+    if (child.exitCode === null) child.kill(signal);
+  });
+}
+`;
+}
+async function writeTraceFiles(config, standaloneDir) {
+  const serverDir = path6.join(standaloneDir, ".next", "server");
+  await emitTracesFor(path6.join(config.root, "app"), path6.join(serverDir, "app"));
+  await emitTracesFor(path6.join(config.root, "src", "app"), path6.join(serverDir, "app"));
+  await emitTracesFor(path6.join(config.root, "pages"), path6.join(serverDir, "pages"));
+  await emitTracesFor(path6.join(config.root, "src", "pages"), path6.join(serverDir, "pages"));
+}
+async function writeMiddlewareManifest(manifest, standaloneDir) {
+  const functions = {};
+  for (const route of manifest.routes) {
+    if (!isEdgeRoute2(route))
+      continue;
+    const page = route.route || "/";
+    functions[page] = {
+      files: [],
+      name: `edge${page === "/" ? "/index" : page}`,
+      page,
+      matchers: [{ regexp: `^${escapeRouteRegexp(page)}$`, originalSource: page }],
+      wasm: [],
+      assets: [],
+      env: {}
+    };
+  }
+  if (Object.keys(functions).length === 0)
+    return;
+  const serverDir = path6.join(standaloneDir, ".next", "server");
+  await mkdir6(serverDir, { recursive: true });
+  await writeFile6(path6.join(serverDir, "middleware-manifest.json"), `${JSON.stringify({ version: 3, sortedMiddleware: [], middleware: {}, functions }, null, 2)}
+`);
+}
+function isEdgeRoute2(route) {
+  const runtime = route.segmentConfig?.runtime;
+  if (runtime === "edge" || runtime === "experimental-edge")
+    return true;
+  for (const file of [route.file, ...route.sourceFiles ?? []]) {
+    if (!file || !existsSync3(file))
+      continue;
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    if (/\bruntime\s*:\s*['"](?:edge|experimental-edge)['"]/.test(source))
+      return true;
+    if (/export\s+const\s+runtime\s*=\s*['"](?:edge|experimental-edge)['"]/.test(source))
+      return true;
+  }
+  return false;
+}
+function escapeRouteRegexp(route) {
+  return route.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/:([^/\\]+)/g, "[^/]+");
+}
+async function emitTracesFor(sourceDir, targetDir) {
+  if (!existsSync3(sourceDir))
+    return;
+  for (const file of await listFiles(sourceDir)) {
+    const match = ENTRY_FILE.exec(file);
+    if (!match)
+      continue;
+    const relative = toPosixPath(path6.relative(sourceDir, file));
+    const relativeDir = path6.posix.dirname(relative);
+    const dir = path6.join(targetDir, ...relativeDir === "." ? [] : relativeDir.split("/"));
+    await mkdir6(dir, { recursive: true });
+    await writeFile6(path6.join(dir, `${match[1]}.js.nft.json`), `${JSON.stringify({ version: 1, files: [] })}
+`);
+  }
+}
+
+// src/compat/export/emit.ts
+var BUILD_ID = "pnext";
+var COMMON_SEGMENTS = ["_full", "_head", "_index", "_tree"];
+var RUNTIME_ASSET_DIR = "_next/static/chunks";
+var EXPORT_MODE_SCRIPT = "<script>window.__PNEXT_OUTPUT_EXPORT__=true;</script>";
+async function emitStaticExport({ config, manifest, log }) {
+  await log.step("build manifest", () => writeBuildManifests(path7.join(config.outPath, "static")));
+  const output = getNextConfig().output;
+  if (output === "standalone") {
+    await emitStandalone({ config, manifest, log });
+    return;
+  }
+  if (output !== "export")
+    return;
+  await log.step("static export", () => writeExportTree(config, manifest));
+}
+async function writeExportTree(config, manifest) {
+  const outDir = exportOutDir(config);
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir7(outDir, { recursive: true });
+  const assets = await copyRuntimeAssets(config, outDir);
+  await copyPublicTree(config, outDir, assets);
+  await writeBuildManifests(outDir);
+  const pages = exportPages(config, manifest);
+  for (const page of pages)
+    await writePageArtifacts(page, assets);
+  await writeNotFoundArtifacts(config, outDir);
+}
+async function copyRuntimeAssets(config, outDir) {
+  const assetsDir = path7.join(config.outPath, "static", "assets");
+  const assets = new Set;
+  for (const file of await listFiles(assetsDir)) {
+    const relative = toPosixPath(path7.relative(assetsDir, file));
+    assets.add(relative);
+    const target = path7.join(outDir, ...RUNTIME_ASSET_DIR.split("/"), ...relative.split("/"));
+    await mkdir7(path7.dirname(target), { recursive: true });
+    await copyFile(file, target);
+  }
+  return assets;
+}
+async function copyPublicTree(config, outDir, assets) {
+  const publicDir = path7.join(config.outPath, "static");
+  for (const file of await listFiles(publicDir)) {
+    const relative = toPosixPath(path7.relative(publicDir, file));
+    if (relative.startsWith("assets/"))
+      continue;
+    const target = path7.join(outDir, ...relative.split("/"));
+    await mkdir7(path7.dirname(target), { recursive: true });
+    if (relative.endsWith(".html")) {
+      await writeFile7(target, exportDocument(await readFile3(file, "utf8"), assets));
+    } else {
+      await copyFile(file, target);
+    }
+  }
+}
+function exportDocument(html, assets) {
+  const repointed = html.replace(/\/_next\/static\/([^"'`\s<>)?#]+)([?#][^"'`\s<>]*)?/g, (match, rest, suffix) => assets.has(rest) ? `/${RUNTIME_ASSET_DIR}/${rest}${suffix ?? ""}` : match);
+  const anchor = /<head[^>]*>|<body[^>]*>/.exec(repointed);
+  if (!anchor)
+    return EXPORT_MODE_SCRIPT + repointed;
+  const at = anchor.index + anchor[0].length;
+  return `${repointed.slice(0, at)}${EXPORT_MODE_SCRIPT}${repointed.slice(at)}`;
+}
+async function writeBuildManifests(outDir) {
+  const dir = path7.join(outDir, "_next", "static", BUILD_ID);
+  await mkdir7(dir, { recursive: true });
+  await writeFile7(path7.join(dir, "_buildManifest.js"), `self.__BUILD_MANIFEST={};self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();
+`);
+  await writeFile7(path7.join(dir, "_ssgManifest.js"), `self.__SSG_MANIFEST=new Set();
+`);
+}
+function exportOutDir(config) {
+  const distDir = getNextConfig().distDir;
+  const dir = typeof distDir === "string" && distDir.length > 0 && distDir !== ".next" ? distDir : "out";
+  return path7.resolve(config.root, dir);
+}
+function exportPages(config, manifest) {
+  const staticFiles = manifest.staticFiles ?? {};
+  const routeById = new Map(manifest.routes.map((route) => [route.id, route]));
+  const pages = [];
+  for (const [relative, metadata] of Object.entries(staticFiles)) {
+    if (metadata.kind !== "page" || !relative.endsWith(".html"))
+      continue;
+    const route = metadata.routeId ? routeById.get(metadata.routeId) : undefined;
+    if (route?.kind !== "page")
+      continue;
+    const htmlFile = path7.join(config.outPath, "static", ...relative.split("/"));
+    pages.push({
+      route,
+      htmlFile,
+      ...exportPathsForHtml(config, relative)
+    });
+  }
+  return pages.sort((a, b) => a.outHtml.localeCompare(b.outHtml));
+}
+function exportPathsForHtml(config, relative) {
+  const outDir = exportOutDir(config);
+  const normalized = toPosixPath(relative);
+  if (normalized === "index.html") {
+    return {
+      outHtml: path7.join(outDir, "index.html"),
+      outPageTxt: path7.join(outDir, "index.txt"),
+      segmentDir: outDir
+    };
+  }
+  if (normalized.endsWith("/index.html")) {
+    const routePath2 = normalized.slice(0, -"/index.html".length);
+    return {
+      outHtml: path7.join(outDir, ...normalized.split("/")),
+      outPageTxt: path7.join(outDir, ...routePath2.split("/"), "index.txt"),
+      segmentDir: path7.join(outDir, ...routePath2.split("/"))
+    };
+  }
+  const routePath = normalized.slice(0, -".html".length);
+  return {
+    outHtml: path7.join(outDir, ...normalized.split("/")),
+    outPageTxt: path7.join(outDir, `${routePath}.txt`),
+    segmentDir: path7.join(outDir, ...routePath.split("/"))
+  };
+}
+async function writePageArtifacts(page, assets) {
+  const html = exportDocument(await readFile3(page.htmlFile, "utf8"), assets);
+  await mkdir7(path7.dirname(page.outPageTxt), { recursive: true });
+  await writeFile7(page.outPageTxt, html);
+  await writeSegmentFiles(page.segmentDir, page.route, html);
+}
+async function writeSegmentFiles(segmentDir2, route, body) {
+  await mkdir7(segmentDir2, { recursive: true });
+  for (const segment of COMMON_SEGMENTS) {
+    await writeFile7(path7.join(segmentDir2, `__next.${segment}.txt`), body);
+  }
+  const keys = segmentKeys(route);
+  const leaf = keys.at(-1) ?? "";
+  await writeFile7(path7.join(segmentDir2, leaf ? `__next.${leaf}.__PAGE__.txt` : "__next.__PAGE__.txt"), body);
+  if (leaf)
+    await writeFile7(path7.join(segmentDir2, `__next.${leaf}.txt`), body);
+  for (const key of keys.slice(0, -1)) {
+    if (key)
+      await writeFile7(path7.join(segmentDir2, `__next.${key}.txt`), body);
+  }
+}
+function segmentKeys(route) {
+  const params = new Set(route.params);
+  const parts = route.route.replace(/^\/|\/$/g, "").split("/").filter(Boolean).map((part) => part.startsWith(":") ? `$d$${part.replace(/^:|[*?]$/g, "")}` : part);
+  if (parts.length === 0)
+    return [""];
+  const keys = [];
+  for (const [index, part] of parts.entries()) {
+    const key = part.startsWith("$d$") && !params.has(part.slice(3)) ? part.slice(3) : part;
+    keys.push([...parts.slice(0, index), key].join("."));
+  }
+  return keys;
+}
+async function writeNotFoundArtifacts(config, outDir) {
+  const htmlFile = path7.join(outDir, "404.html");
+  const html = await readFile3(htmlFile, "utf8").catch(() => {
+    return;
+  });
+  if (html === undefined)
+    return;
+  if (config.trailingSlash === true) {
+    const nested = path7.join(outDir, "404", "index.html");
+    await mkdir7(path7.dirname(nested), { recursive: true });
+    await writeFile7(nested, html);
+  }
+  const outHtml = config.trailingSlash === true ? path7.join(outDir, "_not-found", "index.html") : path7.join(outDir, "_not-found.html");
+  const outTxt = config.trailingSlash === true ? path7.join(outDir, "_not-found", "index.txt") : path7.join(outDir, "_not-found.txt");
+  await mkdir7(path7.dirname(outHtml), { recursive: true });
+  await writeFile7(outHtml, html);
+  await writeFile7(outTxt, html);
+  await writeSegmentFiles(path7.join(outDir, "_not-found"), { route: "/_not-found", params: [] }, html);
+}
+
+// src/compat/register/export.ts
+var registered2 = false;
+onExtensionHostReset(() => registered2 = false);
+function registerExportExtensions(config) {
+  if (registered2)
+    return;
+  if (!nextCompatEnabled(config))
+    return;
+  registered2 = true;
+  registerBuildCompleteHooks(async (ctx) => {
+    if (!nextCompatEnabled(ctx.config))
+      return;
+    await emitStaticExport(ctx);
+    await emitMetadataRouteArtifacts(ctx);
+    await emitCustomServerShim(ctx.config);
+  });
+}
+export {
+  registerBuildCompatExtensions,
+  registerExportExtensions,
+  registerMiddlewareExtensions,
+  registerTypedRoutesExtensions,
+  registerValidationExtensions
+};