@wular/coder 0.3.18 → 0.4.1

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/build-tier-XJJSL5FR.js

@@ -0,0 +1,2704 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  writeTsconfigDefaults
+} from "./chunk-T3QZT3PG.js";
+import {
+  generateTypedRoutes
+} from "./chunk-6KQSWT6D.js";
+import {
+  DEFAULT_DYNAMIC_STALE_TIME_SECONDS,
+  DEFAULT_STATIC_STALE_TIME_SECONDS,
+  aliasGenerateStaticParams,
+  bodySegmentFile,
+  buildRootTreePrefetch,
+  buildSegmentMeta,
+  diagnoseCacheComponentsPrerender,
+  diagnosticLeadsWithErrorLine,
+  fontLinkHeaderValue,
+  prerenderFailureFooter,
+  readMiddlewareWasmBindingsForOutPath,
+  rootTreePrefetchText,
+  segmentDir,
+  segmentMetaFile,
+  takeCacheLifeStash,
+  takeFontHeaderPreloads,
+  takeResourceHintHeader,
+  treeSegmentFile,
+  validateBuild,
+  varyNamesFor,
+  warnNextMetadataBuildIssues,
+  withVaryParamsTracking,
+  writeBuildFlags
+} from "./chunk-H523KSIH.js";
+import {
+  deploymentId,
+  turbopackLoaderRules
+} from "./chunk-WZX4V6CM.js";
+import {
+  scanRootParamTypes
+} from "./chunk-PA4QEARJ.js";
+import {
+  discoverStaticMetadataFiles
+} from "./chunk-PZ5AXOLW.js";
+import "./chunk-VC5O2SDP.js";
+import "./chunk-62KEQM43.js";
+import "./chunk-SNVPTULL.js";
+import {
+  nextCompatEnabled,
+  reactCompatEnabled,
+  reactCompilerOptions
+} from "./chunk-XUUIDXY5.js";
+import {
+  findProxyFile,
+  proxyExternalLoadTarget
+} from "./chunk-7DCNCW6O.js";
+import {
+  getNextConfig
+} from "./chunk-2ICEVELW.js";
+import {
+  devServerModuleHref
+} from "./chunk-E6IXL2NJ.js";
+import "./chunk-L2IWDUXG.js";
+import {
+  legacyRequestAPIs,
+  pathToFileHref
+} from "./chunk-JESFYECC.js";
+import "./chunk-5RDEILQB.js";
+import "./chunk-JRPJM2XY.js";
+import "./chunk-CCATPVTW.js";
+import "./chunk-HT6KKX6A.js";
+import "./chunk-NQE46AZN.js";
+import {
+  listFiles,
+  toPosixPath
+} from "./chunk-2HFY3DQT.js";
+import {
+  onExtensionHostReset,
+  registerBuildCompleteHooks,
+  registerBuildParallelPhases,
+  registerBuildSteps,
+  setBuildCompatExtensions,
+  setCompatModeExtensions
+} from "./chunk-4P5CMIYT.js";
+import "./chunk-FTJVHFWD.js";
+import "./chunk-3UPROT2C.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/register/build.ts
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "node:fs/promises";
+import path2 from "node:path";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/next/preferred-region.ts
+import { readFileSync } from "node:fs";
+var PREFERRED_REGION_RE = /\bexport\s+const\s+preferredRegion\s*=\s*(\[[^\]]*\]|['"][^'"]*['"])/;
+function preferredRegionForRoute(route) {
+  for (const file of routeSources(route)) {
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const match = PREFERRED_REGION_RE.exec(source);
+    if (!match?.[1]) continue;
+    return parsePreferredRegion(match[1]);
+  }
+  return void 0;
+}
+function routeSources(route) {
+  return [.../* @__PURE__ */ new Set([route.file, ...route.sourceFiles])].filter(Boolean);
+}
+function parsePreferredRegion(literal) {
+  if (literal.startsWith("[")) {
+    return Array.from(literal.matchAll(/['"]([^'"]*)['"]/g), (m) => m[1] ?? "");
+  }
+  return [literal.slice(1, -1)];
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/export/build-complete.ts
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node: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("\n")
+      )
+    )
+  );
+}
+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),
+    // pnext has one runtime: the server process. `edge` is never emitted.
+    runtime: "nodejs",
+    assets: {},
+    assetsHashes: {},
+    config: {
+      ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+    }
+  };
+}
+function collectOutputs(config, manifest) {
+  const outputs = {
+    pages: [],
+    appPages: [],
+    pagesApi: [],
+    appRoutes: [],
+    prerenders: [],
+    staticFiles: []
+  };
+  const prerenderedRoutes = /* @__PURE__ */ new Set();
+  for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
+    const filePath = path.join(config.outPath, "public", relative);
+    if (!existsSync(filePath)) continue;
+    if (metadata.routeId) prerenderedRoutes.add(metadata.routeId);
+    const entry = { id: relative, filePath, pathname: staticPathname(relative) };
+    if (metadata.revalidateSeconds !== void 0) {
+      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 = (
+    // eslint-disable-next-line turbo/no-undeclared-env-vars -- Next's own env override
+    process.env.NEXT_ADAPTER_PATH || (typeof configured === "string" ? configured : void 0)
+  );
+  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: void 0
+    },
+    outputs: collectOutputs(config, manifest),
+    projectDir: config.root,
+    repoRoot: config.root,
+    distDir: config.outPath
+  });
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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 : void 0;
+    },
+    nextScriptWorkersEnabled: () => {
+      const experimental = getNextConfig().experimental;
+      return experimental?.nextScriptWorkers === true;
+    },
+    defaultExpireTimeSeconds: () => {
+      const expireTime = getNextConfig().expireTime;
+      return typeof expireTime === "number" ? expireTime : void 0;
+    },
+    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 void 0;
+      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 !== void 0);
+  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)}
+`);
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/typecheck/check.ts
+import { existsSync as existsSync2, statSync } from "node:fs";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path3 from "node:path";
+import { Worker } from "node:worker_threads";
+var PnextTypecheckError = class extends Error {
+  constructor(messages) {
+    super(messages.join("\n"));
+    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,
+    compat: config.compat,
+    nextConfig: cloneable({
+      typescript: next.typescript,
+      typedRoutes: next.typedRoutes,
+      turbopack: next.turbopack
+    })
+  };
+  let worker;
+  try {
+    worker = new Worker(new URL("./worker.ts", ("file://" + __pnextRoot + "/src/compat/typecheck/check.ts")), { 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 void 0;
+  for (const base of [root, (__pnextRoot + "/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 void 0;
+}
+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 = /* @__PURE__ */ new Set();
+  const lines = output.split("\n");
+  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) : void 0;
+    if (!appDiagnostic(resolved, config)) continue;
+    const raw = [text, ...elaborations].join("\n");
+    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.outPath) + path3.sep)) return false;
+  return true;
+}
+function generatedProjectPath(config) {
+  return path3.resolve(config.outPath, "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, (__pnextRoot + "/src/compat/typecheck")]) {
+    try {
+      const require2 = createRequire(path3.join(base, "noop.js"));
+      return path3.dirname(require2.resolve(`@types/${name}/package.json`));
+    } catch {
+    }
+  }
+  return void 0;
+}
+function absolutePaths(paths, basePath) {
+  if (!paths) return void 0;
+  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, (__pnextRoot + "/src/compat/typecheck")]) {
+    try {
+      const require2 = createRequire(path3.join(base, "noop.js"));
+      return path3.dirname(require2.resolve(`${name}/package.json`));
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function writeTypecheckProject(config, native) {
+  const dir = path3.join(config.outPath, "typecheck");
+  await mkdir3(dir, { recursive: true });
+  const reactTypes = resolveTypesDir("react", config.root);
+  const hasReactTypes = reactTypes !== void 0;
+  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) : void 0;
+  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 : void 0
+  );
+  const nodeTypes = resolveTypesDir("node", config.root);
+  await writeFile3(
+    project,
+    JSON.stringify(
+      {
+        ...base ? { extends: base } : {},
+        compilerOptions: {
+          noEmit: true,
+          // TS keeps only the buildinfo under noEmit, so a re-check of an
+          // unchanged app is near-free. It lives outside outPath, which every
+          // build wipes.
+          incremental: true,
+          tsBuildInfoFile: path3.join(
+            config.root,
+            "node_modules",
+            ".cache",
+            "pnext",
+            "typecheck.tsbuildinfo"
+          ),
+          skipLibCheck: true,
+          allowJs: true,
+          resolveJsonModule: true,
+          isolatedModules: true,
+          // Next owns the JSX transform and typechecks the source form. Besides
+          // matching its required tsconfig option, `preserve` keeps a legacy
+          // `import React` semantically used when noUnusedLocals is enabled.
+          jsx: "preserve",
+          // `paths` only, never `baseUrl` — TS 7 removed it (TS5102). The
+          // mappings are absolutized above so they resolve the same from here.
+          ...paths ? { paths } : {},
+          // Fallbacks for apps whose tsconfig leaves these unset (the ES3 default rejects modern syntax).
+          // The app's own values win - `next build` checks with the app's options, and overriding
+          // lib/strict/target changes inference.
+          ...baseOptions.strict === void 0 ? { strict: false } : {},
+          ...baseOptions.target === void 0 ? { target: "es2022" } : {},
+          ...baseOptions.module === void 0 ? { module: "esnext" } : {},
+          ...baseOptions.moduleResolution === void 0 ? { moduleResolution: "bundler" } : {},
+          ...baseOptions.lib === void 0 ? { lib: ["es2022", "dom", "dom.iterable"] } : {}
+        },
+        include: [
+          path3.join(dir, "next-shims.d.ts"),
+          // Generated per-route assignability checks (typegen writes them next to this
+          // project, not under the app-included `types/` dir, so only pnext's own compiler
+          // reads them). Included by hand to keep that coverage.
+          path3.join(dir, "checks", "**/*.ts"),
+          ...nodeTypes ? [path3.join(nodeTypes, "index.d.ts")] : [],
+          path3.join(config.root, "next-env.d.ts"),
+          // The build emits `.next/types/validator.ts` (page/layout/route-handler export validation) just
+          // before this typecheck. Next includes it in the program so invalid exports fail the build with a
+          // constraint type error; include it here too. It lives outside the `.pnext` outPath, so its
+          // diagnostics survive appDiagnostic's scoping.
+          ...!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.*"),
+          // Next type-checks the project's next.config.(ts|mts|cts) as part of
+          // `next build`; a type error in the config fails the build (the
+          // next-config-ts*/type-error suites assert this). JS configs carry no
+          // types to check, so only the TS variants are included.
+          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"),
+          // The app tsconfig's own file list contributes ambient declarations
+          // (global .d.ts JSX/module augmentations) nothing imports; merge just
+          // those in. Merging its `include` PATTERNS instead would also drag in
+          // every stray root-level source (e2e fixtures keep collectors, custom
+          // servers and loader inputs there) that no app entry imports, failing
+          // builds on helper files the app never bundles.
+          ...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.outPath, "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) : void 0;
+  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 void 0;
+    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 void 0;
+  }
+}
+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 : void 0;
+}
+var parsedProjects = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
+  for (const diagnostic of diagnostics) {
+    const raw = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    const typedRoute = typedRouteMessage(raw);
+    let location = "";
+    if (diagnostic.file && diagnostic.start !== void 0) {
+      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 void 0;
+  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("\n");
+  return `declare module 'next/root-params' {
+${getters}
+  const rootParams: (...args: any[]) => Promise<any>
+  export default rootParams
+}`;
+}
+function stripNextModuleDeclarations(source) {
+  const lines = source.split("\n");
+  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("\n");
+}
+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 = /* @__PURE__ */ new Set([
+  ".css",
+  ".scss",
+  ".sass",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".webp",
+  ".wasm",
+  ".mdx",
+  ".md"
+]);
+var TS_RESOLVED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".d.ts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+]);
+function loaderRuleAssetDeclarations() {
+  const specs = /* @__PURE__ */ 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("")}
+`;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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)
+  });
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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
+  });
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/register/middleware.ts
+import path4 from "node:path";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { fileURLToPath } from "node: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 void 0;
+  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");
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/metadata-artifacts.ts
+import { createRequire as createRequire2 } from "node:module";
+import { access, mkdir as mkdir5, readdir, readFile as readFile2, writeFile as writeFile5 } from "node:fs/promises";
+import path5 from "node:path";
+var foundGeistFontPath;
+async function emitMetadataRouteArtifacts(ctx) {
+  if (!nextCompatEnabled(ctx.config)) return;
+  const routes = ctx.manifest.routes.filter(
+    (route) => route.kind === "handler" && route.metadataRoute !== void 0
+  );
+  if (routes.length === 0) return;
+  const outPath = ctx.config.outPath;
+  const outputRoots = Array.from(
+    /* @__PURE__ */ 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 = /* @__PURE__ */ 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={}\n",
+        "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) : void 0;
+    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, void 0, route);
+    }
+    if (entries[route.route] || !isStaticPrerenderRoute(route)) continue;
+    entries[route.route] = prerenderEntry(route.route, void 0, 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 !== void 0 && 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 = /* @__PURE__ */ 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 {}\n", "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\n");
+      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, "public", 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 void 0;
+  }
+}
+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;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/export/emit.ts
+import { copyFile, mkdir as mkdir7, readFile as readFile3, rm as rm2, writeFile as writeFile7 } from "node:fs/promises";
+import path7 from "node:path";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/export/standalone.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { mkdir as mkdir6, rm, writeFile as writeFile6 } from "node:fs/promises";
+import path6 from "node: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 = path6.join(config.root, ".next", "standalone");
+  await rm(standaloneDir, { recursive: true, force: true });
+  await mkdir6(standaloneDir, { recursive: true });
+  await writeServerEntry(config, standaloneDir);
+  await writeTraceFiles(config, standaloneDir);
+  await writeMiddlewareManifest(manifest, standaloneDir);
+}
+async function writeServerEntry(config, standaloneDir) {
+  await writeFile6(
+    path6.join(standaloneDir, "package.json"),
+    `${JSON.stringify({ name: "pnext-standalone", version: "0.0.0", type: "commonjs", private: true }, null, 2)}
+`
+  );
+  await writeFile6(path6.join(standaloneDir, "server.js"), standaloneServerSource(config));
+}
+function standaloneServerSource(config) {
+  const cliPath = path6.resolve((__pnextRoot + "/src/compat/export"), "..", "..", "cli", "index.ts");
+  return `'use strict';
+// pnext standalone launcher. Generated by pnext build; see
+// src/compat/export/standalone.ts. Spawned as \`node server.js\` from the moved
+// standalone directory; re-execs the real pnext server under Bun.
+const { spawn } = require('node:child_process');
+
+const PNEXT_CLI = ${JSON.stringify(cliPath)};
+const PNEXT_ROOT = ${JSON.stringify(config.root)};
+const port = String(process.env.PORT || '3000');
+const hostname = process.env.HOSTNAME || '0.0.0.0';
+
+const child = spawn(
+  'bun',
+  ['--conditions=react-server', PNEXT_CLI, 'start', '--port', port, '--hostname', hostname],
+  {
+    cwd: PNEXT_ROOT,
+    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',
+      PNEXT_COMPAT: 'next',
+      BROWSER: 'none',
+      NODE_ENV: 'production',
+      PORT: port,
+      HOSTNAME: hostname,
+    },
+    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 = readFileSync2(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: [] })}
+`
+    );
+  }
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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, "public")));
+  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 rm2(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, "public", "assets");
+  const assets = /* @__PURE__ */ 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, "public");
+  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();\n"
+  );
+  await writeFile7(path7.join(dir, "_ssgManifest.js"), "self.__SSG_MANIFEST=new Set();\n");
+}
+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) : void 0;
+    if (route?.kind !== "page") continue;
+    const htmlFile = path7.join(config.outPath, "public", ...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(() => void 0);
+  if (html === void 0) 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
+  );
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/next/custom-server.ts
+import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync3 } from "node:fs";
+import { mkdir as mkdir8, rm as rm3, writeFile as writeFile8 } from "node:fs/promises";
+import path8 from "node:path";
+var SERVER_ENTRY_NAMES = ["server.js", "server.mjs", "server.cjs", "server.ts"];
+var SHIM_VERSION = "0.0.0-pnext-custom-server";
+function hasCustomServerEntry(root) {
+  for (const name of SERVER_ENTRY_NAMES) {
+    const file = path8.join(root, name);
+    if (!existsSync4(file)) continue;
+    try {
+      const source = readFileSync3(file, "utf8");
+      if (/(?:require\(\s*['"]next['"]\s*\)|from\s+['"]next['"])/.test(source)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function emitCustomServerShim(config) {
+  if (!hasCustomServerEntry(config.root)) return;
+  const target = path8.join(config.root, "node_modules", "next");
+  try {
+    const stat = lstatSync(target);
+    if (!stat.isSymbolicLink() && !isEmittedShim(target)) return;
+    await rm3(target, { recursive: true, force: true });
+  } catch {
+  }
+  await mkdir8(target, { recursive: true });
+  await writeFile8(
+    path8.join(target, "package.json"),
+    `${JSON.stringify({ name: "next", version: SHIM_VERSION, main: "index.cjs" }, null, 2)}
+`
+  );
+  await writeFile8(path8.join(target, "index.cjs"), customServerShimSource());
+}
+function isEmittedShim(target) {
+  try {
+    const pkg = JSON.parse(readFileSync3(path8.join(target, "package.json"), "utf8"));
+    return pkg.version === SHIM_VERSION;
+  } catch {
+    return false;
+  }
+}
+function customServerShimSource() {
+  const cliPath = path8.resolve((__pnextRoot + "/src/compat/next"), "..", "..", "cli", "index.ts");
+  return `'use strict';
+// pnext custom-server shim for require('next') / import next from 'next'.
+// Generated by pnext build; see src/compat/next/custom-server.ts.
+const { spawn } = require('node:child_process');
+
+const PNEXT_CLI = ${JSON.stringify(cliPath)};
+const HOP_BY_HOP = new Set([
+  'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
+  'te', 'trailer', 'transfer-encoding', 'upgrade', 'host', 'accept-encoding',
+]);
+
+function createServer(options = {}) {
+  const dev = Boolean(options.dev);
+  const hostname = options.hostname || 'localhost';
+  const port = options.port || 3000;
+  let child;
+  let childExited;
+  let internalPort;
+
+  async function prepare() {
+    if (internalPort) return;
+    child = spawn(
+      'bun',
+      ['--conditions=react-server', PNEXT_CLI, dev ? 'dev' : 'start', '--port', '0', '--hostname', '127.0.0.1'],
+      {
+        cwd: process.cwd(),
+        env: { ...process.env, BROWSER: 'none', NODE_ENV: dev ? 'development' : 'production' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
+    );
+    childExited = new Promise((resolve) => child.once('exit', resolve));
+    internalPort = await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error('pnext custom-server: timed out waiting for the pnext server to start')),
+        60000
+      );
+      let buffer = '';
+      // Echo the child's logs line by line, relabelling its "- Local: <internal>"
+      // ready banner: log scanners on THIS process's stdout (the Next e2e harness
+      // parses that exact line for the app URL) must not pick up the internal
+      // port, or every request would bypass the custom server. Line buffering
+      // keeps a coalesced/split chunk from slipping the raw banner through.
+      const echoLines = (out) => {
+        let tail = '';
+        const write = (text) => {
+          const merged = tail + text;
+          const cut = merged.lastIndexOf('\\n') + 1;
+          tail = merged.slice(cut);
+          if (cut === 0) return;
+          out.write(merged.slice(0, cut).replace(/-(\\s*)(Local|Network):/g, '[pnext internal]$1$2:'));
+        };
+        child.once('exit', () => { if (tail) { const rest = tail; tail = ''; out.write(rest); } });
+        return write;
+      };
+      const echoOut = echoLines(process.stdout);
+      const echoErr = echoLines(process.stderr);
+      const scan = (chunk, echo) => {
+        const text = chunk.toString('utf8');
+        echo(text);
+        if (internalPort) return;
+        buffer = (buffer + text).slice(-4096);
+        const match = /-\\s*Local:\\s+https?:\\/\\/[^:\\s]+:(\\d+)/.exec(buffer);
+        if (match) {
+          clearTimeout(timer);
+          resolve(Number(match[1]));
+        }
+      };
+      child.stdout.on('data', (chunk) => scan(chunk, echoOut));
+      child.stderr.on('data', (chunk) => scan(chunk, echoErr));
+      child.once('exit', (code) => {
+        clearTimeout(timer);
+        reject(new Error('pnext custom-server: the pnext server exited during startup (code ' + code + ')'));
+      });
+    });
+  }
+
+  async function handleRequest(req, res) {
+    if (!internalPort) throw new Error('pnext custom-server: prepare() must complete before handling requests');
+    const target = new URL(req.url || '/', 'http://127.0.0.1:' + internalPort);
+    const headers = {};
+    for (const [name, value] of Object.entries(req.headers)) {
+      if (value === undefined || HOP_BY_HOP.has(name)) continue;
+      headers[name] = Array.isArray(value) ? value.join(', ') : value;
+    }
+    if (req.headers.host) headers['x-forwarded-host'] = req.headers.host;
+    headers['x-forwarded-proto'] = 'http';
+    const method = (req.method || 'GET').toUpperCase();
+    const hasBody = method !== 'GET' && method !== 'HEAD';
+    const response = await fetch(target, {
+      method,
+      headers,
+      body: hasBody ? req : undefined,
+      duplex: hasBody ? 'half' : undefined,
+      redirect: 'manual',
+    });
+    res.statusCode = response.status;
+    for (const [name, value] of response.headers) {
+      if (['content-encoding', 'content-length', 'transfer-encoding', 'set-cookie'].includes(name)) continue;
+      if (name === 'location') {
+        // Rewrite child-origin absolute redirects back to a relative target so
+        // the browser stays on the custom server's host/port.
+        try {
+          const url = new URL(value);
+          if (url.hostname === '127.0.0.1' && Number(url.port) === internalPort) {
+            res.setHeader(name, url.pathname + url.search + url.hash);
+            continue;
+          }
+        } catch {}
+      }
+      res.setHeader(name, value);
+    }
+    const setCookies = typeof response.headers.getSetCookie === 'function' ? response.headers.getSetCookie() : [];
+    if (setCookies.length > 0) {
+      const existing = res.getHeader('set-cookie');
+      const merged = existing === undefined ? setCookies : [].concat(existing, setCookies);
+      res.setHeader('set-cookie', merged);
+    }
+    if (response.body) {
+      for await (const chunk of response.body) res.write(chunk);
+    }
+    res.end();
+  }
+
+  async function close() {
+    if (!child || child.exitCode !== null) return;
+    // Graceful: the pnext server stops accepting connections, drains pending
+    // after() callbacks, then exits 0. Escalate to SIGKILL only on a hang.
+    child.kill('SIGTERM');
+    await Promise.race([
+      childExited,
+      new Promise((resolve) => setTimeout(resolve, 15000).unref()),
+    ]);
+    if (child.exitCode === null) child.kill('SIGKILL');
+  }
+
+  return {
+    hostname,
+    port,
+    prepare,
+    close,
+    getRequestHandler: () => (req, res) => handleRequest(req, res).catch((error) => {
+      console.error('pnext custom-server: request failed:', error);
+      if (!res.headersSent) res.statusCode = 500;
+      res.end('Internal Server Error');
+    }),
+    getUpgradeHandler: () => (_req, socket) => { socket.destroy(); },
+    setAssetPrefix: () => {},
+    logError: (...args) => console.error(...args),
+    render: async (req, res) => { await handleRequest(req, res); },
+    renderToHTML: async () => { throw new Error('renderToHTML is not supported by the pnext custom server'); },
+  };
+}
+
+module.exports = createServer;
+module.exports.default = createServer;
+`;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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
+};