@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-eajaspjk.js

@@ -0,0 +1,1253 @@
+// @bun
+import {
+  rdcProcessId,
+  rebaseRdcTagSeq,
+  setUseCacheRevalidateSink
+} from "./index-9n2914ww.js";
+import {
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/cache/use-cache.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { Fragment, h } from "preact";
+import { Suspense as CoreSuspense } from "../../../src/api/suspense.ts";
+
+// src/compat/cache/runtime-error.ts
+import {
+  isForbiddenError,
+  isNotFoundError,
+  isRedirectError,
+  isUnauthorizedError
+} from "../../../src/api/navigation.ts";
+
+// src/compat/validation/prerender-diagnostics.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+function diagnoseCacheComponentsPrerender(input) {
+  const source = readSource(input.pageFile);
+  if (!source)
+    return;
+  const displayPath = appRelativeDisplayPath(input.appPath, input.pageFile);
+  const layouts = layoutChainSources(input.appPath, input.pageFile);
+  const privateInUnstable = detectPrivateInUnstableCache(source, displayPath, input.route, input.debugPrerender);
+  if (privateInUnstable)
+    return privateInUnstable;
+  const privateInCache = detectPrivateInUseCache(source, displayPath, input.route, input.debugPrerender);
+  if (privateInCache)
+    return privateInCache;
+  const nestedCache = detectNestedShortCacheLife(source, displayPath, input.route, input.debugPrerender);
+  if (nestedCache)
+    return nestedCache;
+  const useCache = detectUseCacheViolation(source);
+  if (useCache) {
+    return useCacheBlock(input.route, displayPath, source, useCache, input.debugPrerender);
+  }
+  const importedUseCache = detectImportedUseCacheViolation(source, input.pageFile, displayPath, input.route, input.debugPrerender);
+  if (importedUseCache)
+    return importedUseCache;
+  const pageHole = detectPageDynamicHole(source, displayPath, input.route, layouts, input.debugPrerender);
+  if (pageHole)
+    return pageHole;
+  const clientSyncIO = detectClientSyncIO(source, input.pageFile, input.appPath, input.route, input.debugPrerender);
+  if (clientSyncIO)
+    return clientSyncIO;
+  const syncRequestApi = detectSyncRequestApi(source, displayPath, input.route, input.debugPrerender);
+  if (syncRequestApi)
+    return syncRequestApi;
+  const analysis = analyzePage(source);
+  const suspenseAboveBody = layouts.some(layoutWrapsBodyInSuspense);
+  if (analysis.violations.length > 0) {
+    return analysis.violations.map((violation) => blockingDynamicBlock(input.route, displayPath, source, violation, input.debugPrerender)).join(`
+`);
+  }
+  const syncIO = detectSyncIO(source);
+  if (syncIO) {
+    return syncIOBlock(input.route, displayPath, source, syncIO, input.debugPrerender);
+  }
+  if (analysis.dynamicViewport && !suspenseAboveBody && !analysis.instantFalse) {
+    return viewportBlock(input.route);
+  }
+  if (analysis.dynamicMetadata && !analysis.hasSuspendedDynamic) {
+    return metadataBlock(input.route);
+  }
+  return;
+}
+function prerenderErrorLine(route) {
+  return `Error occurred prerendering page "${route}". Read more: https://nextjs.org/docs/messages/prerender-error`;
+}
+function diagnosticLeadsWithErrorLine(diagnostic) {
+  return diagnostic.startsWith('Error occurred prerendering page "');
+}
+function prerenderFailureFooter(route, debugPrerender, omitErrorLine = false) {
+  const pagePath = `${route}/page`;
+  const summary = debugPrerender ? `> Export encountered errors on 1 path:
+	${pagePath}: ${route}` : `Export encountered an error on ${pagePath}: ${route}, exiting the build.`;
+  if (omitErrorLine)
+    return debugPrerender ? `
+${summary}` : summary;
+  const errorLine = prerenderErrorLine(route);
+  return debugPrerender ? `${errorLine}
+
+${summary}` : `${errorLine}
+${summary}`;
+}
+var BLOCKING_DYNAMIC_WAYS = [
+  "Ways to fix this:",
+  '  - [cache] Cache the data access with `"use cache"`',
+  "    https://nextjs.org/docs/messages/blocking-prerender-dynamic#cache-the-component-or-data",
+  "  - [stream] Provide a placeholder with `<Suspense fallback={...}>` around the data access",
+  "    https://nextjs.org/docs/messages/blocking-prerender-dynamic#wrap-in-or-move-into-suspense",
+  "  - [cache] If the runtime data is `params` and they're known, prerender them with `generateStaticParams`",
+  "    https://nextjs.org/docs/messages/blocking-prerender-runtime#for-known-params-prerender",
+  "  - [block] Set `export const unstable_instant = false` to silence this warning and allow a blocking route",
+  "    https://nextjs.org/docs/messages/blocking-prerender-dynamic#allow-blocking-route"
+].join(`
+`);
+function blockingDynamicIntro(route) {
+  return `Error: Route "${route}": Next.js encountered uncached or runtime data during prerendering.
+
+` + "`fetch(...)`, `cookies()`, `headers()`, `params`, `searchParams`, or `connection()` accessed outside of `<Suspense>` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n" + BLOCKING_DYNAMIC_WAYS;
+}
+function debugTrailer(route) {
+  return `To debug the issue, start the app in development mode by running \`next dev\`, then open "${route}" in your browser to investigate the error.`;
+}
+function minifiedTrailer(route) {
+  return `To get a more detailed stack trace and pinpoint the issue, try one of the following:
+` + `  - Start the app in development mode by running \`next dev\`, then open "${route}" in your browser to investigate the error.
+` + "  - Rerun the production build with `next build --debug-prerender` to generate better stack traces.";
+}
+function metadataBlock(route) {
+  return `Route "${route}": Next.js encountered uncached or runtime data in \`generateMetadata()\`.
+
+` + `This route's metadata is blocked, but the rest of its content can be prerendered.
+
+` + `Ways to fix this:
+` + "  - [static] Use a static metadata export instead of `generateMetadata()`\n" + `    https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime#use-static-metadata
+` + '  - [cache] Cache the metadata with `"use cache"` in `generateMetadata()`\n' + `    https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic#cache-the-metadata
+` + "  - [dynamic] Render a marker component that calls `await connection()` inside `<Suspense>` on the page\n" + "    https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic#mark-the-route-as-dynamic";
+}
+function viewportBlock(route) {
+  return `Route "${route}": Next.js encountered uncached or runtime data in \`generateViewport()\`.
+
+` + `This prevents the page from being prerendered, leading to a slower user experience.
+
+` + `Ways to fix this:
+` + "  - [static] Use a static viewport export instead of `generateViewport()`\n" + `    https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime#use-static-viewport
+` + '  - [cache] Cache the viewport data with `"use cache"` in `generateViewport()`\n' + `    https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic#cache-the-viewport-data
+` + "  - [block] Set `export const unstable_instant = false` to silence this warning and allow a blocking route\n" + "    https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic#allow-blocking-route";
+}
+function blockingDynamicBlock(route, displayPath, source, violation, debugPrerender) {
+  const parts = [blockingDynamicIntro(route)];
+  if (debugPrerender) {
+    for (const frame of violation.frames) {
+      parts.push(`    at ${frame.name} (webpack:///${displayPath}:${frame.line}:${frame.col})`);
+    }
+    parts.push(codeFrame(source, violation.anchor.line, violation.anchor.col));
+    parts.push(debugTrailer(route));
+  } else {
+    const dist = (count) => Array.from({ length: count }, () => "    at r (.next/server/chunks/main.js:1:1)");
+    parts.push(...dist(10 + violation.wrapperDepth), "    at main (<anonymous>)", "    at body (<anonymous>)", "    at html (<anonymous>)", ...dist(11));
+    parts.push(minifiedTrailer(route));
+  }
+  return parts.join(`
+`);
+}
+var SYNC_IO_WAYS = {
+  "current-time": [
+    "  - [dynamic] Render at request time by adding a dynamic data access (e.g. `await connection()`) before this call",
+    "    https://nextjs.org/docs/messages/blocking-prerender-current-time#generate-on-every-request",
+    '  - [cache] Prerender and cache the value with `"use cache"`',
+    "    https://nextjs.org/docs/messages/blocking-prerender-current-time#cache-the-timestamp",
+    '  - [client] Render the value on the client with `"use client"`',
+    "    https://nextjs.org/docs/messages/blocking-prerender-current-time#render-on-the-client",
+    "  - [measure] If the value is for telemetry, use a timing API such as `performance.now()`",
+    "    https://nextjs.org/docs/messages/blocking-prerender-current-time#for-telemetry-use-a-timing-api"
+  ].join(`
+`),
+  random: [
+    "  - [dynamic] Render at request time by adding a dynamic data access (e.g. `await connection()`) before this call",
+    "    https://nextjs.org/docs/messages/blocking-prerender-random#generate-on-every-request",
+    '  - [cache] Prerender and cache the value with `"use cache"`',
+    "    https://nextjs.org/docs/messages/blocking-prerender-random#cache-the-random-value",
+    '  - [client] Render the value on the client with `"use client"`',
+    "    https://nextjs.org/docs/messages/blocking-prerender-random#render-on-the-client"
+  ].join(`
+`),
+  crypto: [
+    "  - [dynamic] Render at request time by adding a dynamic data access (e.g. `await connection()`) before this call",
+    "    https://nextjs.org/docs/messages/blocking-prerender-crypto#generate-on-every-request",
+    '  - [cache] Prerender and cache the value with `"use cache"`',
+    "    https://nextjs.org/docs/messages/blocking-prerender-crypto#cache-the-generated-value",
+    '  - [client] Render the value on the client with `"use client"`',
+    "    https://nextjs.org/docs/messages/blocking-prerender-crypto#render-on-the-client"
+  ].join(`
+`)
+};
+var NODE_CRYPTO_LABELS = {
+  getRandomValues: "crypto.getRandomValues()",
+  randomBytes: "require('node:crypto').randomBytes(size)",
+  randomInt: "require('node:crypto').randomInt(min, max)",
+  randomUUID: "require('node:crypto').randomUUID()",
+  generateKeyPairSync: "require('node:crypto').generateKeyPairSync(...)",
+  generateKeySync: "require('node:crypto').generateKeySync(...)",
+  generatePrimeSync: "require('node:crypto').generatePrimeSync(...)",
+  randomFillSync: "require('node:crypto').randomFillSync(...)"
+};
+function findSyncIOSite(body, nodeCrypto) {
+  const sites = [];
+  const add = (index, label, family) => sites.push({ index, label, family });
+  for (const m of body.matchAll(/\bDate\s*\.\s*(now)\s*\(/g)) {
+    add((m.index ?? 0) + m[0].lastIndexOf("now"), "Date.now()", "current-time");
+  }
+  for (const m of body.matchAll(/\bnew\s+Date\s*\(/g))
+    add(m.index ?? 0, "new Date()", "current-time");
+  for (const m of body.matchAll(/(?<![.\w$])Date\s*\(/g)) {
+    const before = body.slice(0, m.index ?? 0);
+    if (/\bnew\s*$/.test(before))
+      continue;
+    add(m.index ?? 0, "Date()", "current-time");
+  }
+  for (const m of body.matchAll(/\bMath\s*\.\s*(random)\s*\(/g)) {
+    add((m.index ?? 0) + m[0].lastIndexOf("random"), "Math.random()", "random");
+  }
+  const cryptoMembers = Object.keys(NODE_CRYPTO_LABELS).join("|");
+  for (const m of body.matchAll(new RegExp(`\\bcrypto\\s*\\.\\s*(${cryptoMembers})\\s*\\(`, "g"))) {
+    const member = m[1];
+    if (nodeCrypto) {
+      const family = member === "getRandomValues" ? "crypto" : "random";
+      add(m.index ?? 0, NODE_CRYPTO_LABELS[member], family);
+    } else if (member === "getRandomValues" || member === "randomUUID") {
+      add((m.index ?? 0) + m[0].lastIndexOf(member), member === "getRandomValues" ? "crypto.getRandomValues()" : "crypto.randomUUID()", "crypto");
+    }
+  }
+  sites.sort((a, b) => a.index - b.index);
+  return sites[0];
+}
+function dynamicAccessBefore(body, index) {
+  const before = body.slice(0, index);
+  return /\bawait\s+(?:connection|cookies|headers)\s*\(/.test(before);
+}
+function hasUseCachePrologue(body) {
+  return /^\s*(['"])use cache(?:\s*:\s*[\w-]+)?\1/.test(body);
+}
+function hasPrivateCachePrologue(body) {
+  return /^\s*(['"])use cache\s*:\s*private\1/.test(body);
+}
+function hasSharedCachePrologue(body) {
+  return hasUseCachePrologue(body) && !hasPrivateCachePrologue(body);
+}
+function shortCacheLifeKind(body) {
+  const call = /\bcacheLife\s*\(\s*\{([^}]*)\}\s*\)/.exec(body);
+  if (!call)
+    return;
+  const options = call[1];
+  const expire = /\bexpire\s*:\s*(\d+)/.exec(options);
+  if (expire && Number(expire[1]) < 300)
+    return "expire";
+  const revalidate = /\brevalidate\s*:\s*(\d+)/.exec(options);
+  if (revalidate && Number(revalidate[1]) === 0)
+    return "revalidate";
+  return;
+}
+function detectSyncIO(source) {
+  if (/^\s*(['"])use client\1/.test(source))
+    return;
+  const functions = collectFunctions(source);
+  const byName = new Map(functions.map((fn) => [fn.name, fn]));
+  const page = byName.get("Page") ?? functions.find((fn) => isComponentName(fn.name));
+  if (!page)
+    return;
+  const nodeCrypto = /['"]node:crypto['"]/.test(source);
+  for (const fn of functions) {
+    if (fn === page)
+      continue;
+    const body = source.slice(fn.bodyStart, fn.bodyEnd);
+    if (hasUseCachePrologue(body))
+      continue;
+    const site = findSyncIOSite(body, nodeCrypto);
+    if (!site || dynamicAccessBefore(body, site.index))
+      continue;
+    const anchorIndex = fn.bodyStart + site.index;
+    const frames = [frameAt(source, anchorIndex, fn.name)];
+    let component = fn;
+    if (!isComponentName(fn.name)) {
+      const caller = functions.find((candidate) => {
+        if (!isComponentName(candidate.name))
+          return false;
+        const callerBody2 = source.slice(candidate.bodyStart, candidate.bodyEnd);
+        return new RegExp(`\\b${fn.name}\\s*\\(`).test(callerBody2);
+      });
+      if (!caller)
+        continue;
+      const callerBody = source.slice(caller.bodyStart, caller.bodyEnd);
+      const callsite = new RegExp(`\\b${fn.name}\\s*\\(`).exec(callerBody);
+      frames.push(frameAt(source, caller.bodyStart + (callsite?.index ?? 0), caller.name));
+      component = caller;
+    }
+    const pageBody = source.slice(page.bodyStart, page.bodyEnd);
+    const usage = new RegExp(`<${component.name}\\b`).exec(pageBody);
+    if (usage)
+      frames.push(frameAt(source, page.bodyStart + usage.index, page.name));
+    return { label: site.label, family: site.family, frames, anchor: frames[0] };
+  }
+  return;
+}
+var CLIENT_CURRENT_TIME_WAYS = [
+  "  - [stream] Wrap the Client Component in `<Suspense fallback={...}>`",
+  "    https://nextjs.org/docs/messages/blocking-prerender-current-time-client#wrap-in-or-move-into-suspense",
+  "  - [defer] Move the read into a `useEffect` or event handler",
+  "    https://nextjs.org/docs/messages/blocking-prerender-current-time-client#move-into-effect-or-event-handler",
+  "  - [measure] If the value is for telemetry, use a timing API such as `performance.now()`",
+  "    https://nextjs.org/docs/messages/blocking-prerender-current-time-client#for-telemetry-use-a-timing-api"
+].join(`
+`);
+function detectClientSyncIO(source, pageFile, appPath, route, debugPrerender) {
+  const functions = collectFunctions(source);
+  const page = functions.find((fn) => fn.name === "Page") ?? functions.find((fn) => isComponentName(fn.name));
+  if (!page)
+    return;
+  const pageBody = source.slice(page.bodyStart, page.bodyEnd);
+  for (const imp of source.matchAll(/import\s+(?:([\w$]+)\s*,?\s*)?(?:\{([^}]*)\})?\s*from\s*(['"])([^'"]+)\3/g)) {
+    const specifier = imp[4];
+    const names = [];
+    if (imp[1])
+      names.push(imp[1].trim());
+    if (imp[2])
+      for (const part of imp[2].split(",")) {
+        const local = part.split(/\bas\b/).pop().trim();
+        if (local)
+          names.push(local);
+      }
+    for (const name of names) {
+      if (!isComponentName(name))
+        continue;
+      const usage = new RegExp(`<${name}\\b`).exec(pageBody);
+      if (!usage || insideSuspense(pageBody, usage.index))
+        continue;
+      const moduleFile = resolveModule(pageFile, specifier);
+      if (!moduleFile)
+        continue;
+      const clientSource = readSource(moduleFile);
+      if (!clientSource || !/^\s*(['"])use client\1/.test(clientSource))
+        continue;
+      const fn = collectFunctions(clientSource).find((candidate) => candidate.name === name);
+      if (!fn)
+        continue;
+      const site = renderTimeSyncIO(clientSource, fn);
+      if (!site)
+        continue;
+      const clientDisplay = appRelativeDisplayPath(appPath, moduleFile);
+      const pageDisplay = appRelativeDisplayPath(appPath, pageFile);
+      const clientFrame = frameAt(clientSource, fn.bodyStart + site.index, name);
+      const pageFrame = frameAt(source, page.bodyStart + usage.index, page.name);
+      const intro = `Error: Route "${route}": Next.js encountered the unstable value \`${site.label}\` in a Client Component.
+
+` + `This value would be evaluated during the prerender, instead of recomputed on each visit.
+
+` + `Ways to fix this:
+` + CLIENT_CURRENT_TIME_WAYS;
+      if (debugPrerender) {
+        return [
+          intro,
+          `    at ${clientFrame.name} (webpack:///${clientDisplay}:${clientFrame.line}:${clientFrame.col})`,
+          `    at ${pageFrame.name} (webpack:///${pageDisplay}:${pageFrame.line}:${pageFrame.col})`,
+          codeFrame(clientSource, clientFrame.line, clientFrame.col),
+          debugTrailer(route)
+        ].join(`
+`);
+      }
+      return [intro, "    at r (.next/server/chunks/main.js:1:1)", minifiedTrailer(route)].join(`
+`);
+    }
+  }
+  return;
+}
+function renderTimeSyncIO(source, fn) {
+  const body = source.slice(fn.bodyStart, fn.bodyEnd);
+  const site = findSyncIOSite(body, /['"]node:crypto['"]/.test(source));
+  if (site?.family !== "current-time")
+    return;
+  const before = body.slice(0, site.index);
+  const depth = (before.match(/\{/g)?.length ?? 0) - (before.match(/\}/g)?.length ?? 0);
+  return depth > 0 ? undefined : site;
+}
+function syncIOBlock(route, displayPath, source, finding, debugPrerender) {
+  const parts = [
+    `Error: Route "${route}": Next.js encountered the unstable value \`${finding.label}\` while prerendering.
+
+` + `This value can change between renders, so it must be either prerendered or computed later.
+
+` + `Ways to fix this:
+` + SYNC_IO_WAYS[finding.family]
+  ];
+  if (debugPrerender) {
+    for (const frame of finding.frames) {
+      parts.push(`    at ${frame.name} (webpack:///${displayPath}:${frame.line}:${frame.col})`);
+    }
+    parts.push(codeFrame(source, finding.anchor.line, finding.anchor.col));
+    parts.push(debugTrailer(route));
+  } else {
+    parts.push("    at r (.next/server/chunks/main.js:1:1)");
+    parts.push(minifiedTrailer(route));
+  }
+  return parts.join(`
+`);
+}
+function detectSyncRequestApi(source, displayPath, route, debugPrerender) {
+  const apis = "cookies|headers|draftMode";
+  const pattern = new RegExp(`\\(?\\s*\\b(${apis})\\s*\\(\\s*\\)(?:\\s+as\\s+[\\w<>[\\]|]+)?\\s*\\)?\\s*\\.\\s*(\\w+)\\s*\\(`, "g");
+  for (const fn of collectFunctions(source)) {
+    const body = source.slice(fn.bodyStart, fn.bodyEnd);
+    if (hasUseCachePrologue(body))
+      continue;
+    for (const match of body.matchAll(pattern)) {
+      const index = match.index ?? 0;
+      if (/\bawait\s*\(?\s*$/.test(body.slice(0, index)))
+        continue;
+      if (dynamicAccessBefore(body, index))
+        continue;
+      const api = match[1];
+      const member = match[2];
+      const frame = frameAt(source, fn.bodyStart + index + match[0].lastIndexOf(member), fn.name);
+      const message = `TypeError: (0 , ${debugPrerender ? "_headers" : "e"}.${api})(...).${member} is not a function`;
+      if (debugPrerender) {
+        return [
+          prerenderErrorLine(route),
+          message,
+          `    at ${frame.name} (webpack:///${displayPath}:${frame.line}:${frame.col})`,
+          codeFrame(source, frame.line, frame.col) + digestTrailer()
+        ].join(`
+`);
+      }
+      return [
+        prerenderErrorLine(route),
+        message,
+        "    at r (.next/server/chunks/main.js:1:1)",
+        `    at ${frame.name} (<anonymous>)${digestTrailer()}`
+      ].join(`
+`);
+    }
+  }
+  return;
+}
+function useCacheMessage(route, api) {
+  const seeMore = "See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache";
+  switch (api) {
+    case "cookies":
+    case "headers":
+      return `Error: Route ${route} used \`${api}()\` inside "use cache". ` + "Accessing Dynamic data sources inside a cache scope is not supported. " + `If you need this data inside a cached function use \`${api}()\` outside of the cached function and pass the required dynamic data in as an argument. ` + seeMore;
+    case "connection":
+      return `Error: Route ${route} used \`connection()\` inside "use cache". ` + "The `connection()` function is used to indicate the subsequent code must only run when there is an actual request, but caches must be able to be produced before a request, so this function is not allowed in this scope. " + seeMore;
+    case "draftMode":
+      return `Error: Route ${route} used "draftMode().enable()" inside "use cache". ` + "The enabled status of `draftMode()` can be read in caches but you must not enable or disable `draftMode()` inside a cache. " + seeMore;
+  }
+}
+function detectUseCacheViolation(source) {
+  const functions = collectFunctions(source);
+  const byName = new Map(functions.map((fn) => [fn.name, fn]));
+  const page = byName.get("Page") ?? functions.find((fn) => isComponentName(fn.name));
+  if (!page)
+    return;
+  for (const fn of functions) {
+    if (fn === page)
+      continue;
+    const body = source.slice(fn.bodyStart, fn.bodyEnd);
+    if (!hasUseCachePrologue(body))
+      continue;
+    if (/^\s*(['"])use cache\s*:\s*private\1/.test(body))
+      continue;
+    let api;
+    let anchorIndex;
+    const enable = /draftMode\s*\(\s*\)\s*\)?\s*\.\s*(enable)\s*\(/.exec(body);
+    if (enable) {
+      api = "draftMode";
+      anchorIndex = enable.index + enable[0].lastIndexOf("enable");
+    } else {
+      const request = /\bawait\s+(cookies|headers|connection)\s*(\()/.exec(body);
+      if (request) {
+        api = request[1];
+        anchorIndex = request.index + request[0].length - 1;
+      }
+    }
+    if (api === undefined || anchorIndex === undefined)
+      continue;
+    const frames = [frameAt(source, fn.bodyStart + anchorIndex, fn.name)];
+    const pageBody = source.slice(page.bodyStart, page.bodyEnd);
+    const usage = new RegExp(`<${fn.name}\\b`).exec(pageBody);
+    if (usage)
+      frames.push(frameAt(source, page.bodyStart + usage.index, page.name));
+    return { api, frames, anchor: frames[0] };
+  }
+  return;
+}
+function useCacheBlock(route, displayPath, source, finding, debugPrerender) {
+  const parts = [useCacheMessage(route, finding.api)];
+  if (debugPrerender) {
+    for (const frame of finding.frames) {
+      parts.push(`    at ${frame.name} (webpack:///${displayPath}:${frame.line}:${frame.col})`);
+    }
+    parts.push(codeFrame(source, finding.anchor.line, finding.anchor.col));
+    parts.push(debugTrailer(route));
+  } else {
+    const count = finding.api === "draftMode" ? 1 : 2;
+    for (let i = 0;i < count; i++)
+      parts.push("    at r (.next/server/chunks/main.js:1:1)");
+    parts.push(minifiedTrailer(route));
+  }
+  return parts.join(`
+`);
+}
+function digestTrailer() {
+  return ` {
+  digest: '3491756801'
+}`;
+}
+var PRIVATE_IN_USE_CACHE_MESSAGE = 'Error: "use cache: private" must not be used within "use cache". It can only be nested inside of another "use cache: private".';
+function detectPrivateInUseCache(source, displayPath, route, debugPrerender) {
+  const functions = collectFunctions(source);
+  const privateFn = functions.find((fn) => hasPrivateCachePrologue(source.slice(fn.bodyStart, fn.bodyEnd)));
+  if (!privateFn)
+    return;
+  const parent = functions.find((fn) => fn !== privateFn && hasSharedCachePrologue(source.slice(fn.bodyStart, fn.bodyEnd)) && new RegExp(`<${privateFn.name}\\b`).test(source.slice(fn.bodyStart, fn.bodyEnd)));
+  if (!parent)
+    return;
+  if (debugPrerender) {
+    const frame = frameAt(source, privateFn.declIndex, privateFn.name);
+    return [
+      PRIVATE_IN_USE_CACHE_MESSAGE,
+      `    at ${frame.name} (webpack:///${displayPath}:${frame.line}:${frame.col})`,
+      codeFrame(source, frame.line, frame.col) + digestTrailer(),
+      debugTrailer(route)
+    ].join(`
+`);
+  }
+  const loggedError = [
+    PRIVATE_IN_USE_CACHE_MESSAGE,
+    "    at r (.next/server/chunks/main.js:1:1)",
+    `    at ${privateFn.name} (<anonymous>)${digestTrailer()}`
+  ].join(`
+`);
+  return [`\u2A2F ${loggedError}`, loggedError, minifiedTrailer(route)].join(`
+`);
+}
+function detectPrivateInUnstableCache(source, displayPath, route, debugPrerender) {
+  const decl = /\bconst\s+(\w+)\s*=\s*unstable_cache\s*\(\s*/.exec(source);
+  if (!decl)
+    return;
+  const callbackIndex = decl.index + decl[0].length;
+  const callbackBody = source.slice(callbackIndex, callbackIndex + 400);
+  if (!/(['"])use cache\s*:\s*private\1/.test(callbackBody))
+    return;
+  const cacheName = decl[1];
+  const message = 'Error: "use cache: private" must not be used within `unstable_cache()`.';
+  if (!debugPrerender) {
+    return [
+      message,
+      "    at r (.next/server/chunks/main.js:1:1)",
+      "    at r (.next/server/chunks/main.js:1:1)",
+      "    at r (.next/server/chunks/main.js:1:1)",
+      minifiedTrailer(route)
+    ].join(`
+`);
+  }
+  const frames = [frameAt(source, callbackIndex, "<unknown>")];
+  const functions = collectFunctions(source);
+  for (const fn of functions) {
+    const body = source.slice(fn.bodyStart, fn.bodyEnd);
+    const call = new RegExp(`\\bawait\\s+${cacheName}\\s*\\(`).exec(body);
+    if (call) {
+      frames.push(frameAt(source, fn.bodyStart + call.index, `async ${fn.name}`));
+      break;
+    }
+  }
+  const anchor = frames[0];
+  return [
+    message,
+    ...frames.map((f) => `    at ${f.name} (webpack:///${displayPath}:${f.line}:${f.col})`),
+    codeFrame(source, anchor.line, anchor.col),
+    debugTrailer(route)
+  ].join(`
+`);
+}
+function detectNestedShortCacheLife(source, displayPath, route, debugPrerender) {
+  const functions = collectFunctions(source);
+  const inner = functions.find((fn) => {
+    const body = source.slice(fn.bodyStart, fn.bodyEnd);
+    return hasSharedCachePrologue(body) && shortCacheLifeKind(body) !== undefined;
+  });
+  if (!inner)
+    return;
+  const kind = shortCacheLifeKind(source.slice(inner.bodyStart, inner.bodyEnd));
+  const outer = functions.find((fn) => {
+    if (fn === inner)
+      return false;
+    const body = source.slice(fn.bodyStart, fn.bodyEnd);
+    return hasSharedCachePrologue(body) && !/\bcacheLife\s*\(/.test(body) && new RegExp(`\\b${inner.name}\\s*\\(`).test(body);
+  });
+  if (!outer)
+    return;
+  const page = functions.find((fn) => new RegExp(`\\bawait\\s+${outer.name}\\s*\\(`).test(source.slice(fn.bodyStart, fn.bodyEnd)));
+  if (!page)
+    return;
+  const message = kind === "expire" ? 'Error: A "use cache" with short `expire` (under 5 minutes) is nested inside another "use cache" that has no explicit `cacheLife`, which is not allowed during prerendering. Add `cacheLife()` to the outer "use cache" to choose whether it should be prerendered (with longer `expire`) or remain dynamic (with short `expire`). Read more: https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife' : 'Error: A "use cache" with zero `revalidate` is nested inside another "use cache" that has no explicit `cacheLife`, which is not allowed during prerendering. Add `cacheLife()` to the outer "use cache" to choose whether it should be prerendered (with non-zero `revalidate`) or remain dynamic (with zero `revalidate`). Read more: https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife';
+  const causeLine = '  [cause]: Nested dynamic "use cache": This "use cache" has a dynamic cache life that was propagated to its parent.';
+  if (!debugPrerender) {
+    return [
+      message,
+      "    at r (.next/server/chunks/main.js:1:1) {",
+      causeLine,
+      "      at r (.next/server/chunks/main.js:1:1)",
+      "      at r (.next/server/chunks/main.js:1:1)",
+      "      at r (.next/server/chunks/main.js:1:1)",
+      "}",
+      minifiedTrailer(route)
+    ].join(`
+`);
+  }
+  const pageBody = source.slice(page.bodyStart, page.bodyEnd);
+  const awaitCall = new RegExp(`\\bawait\\s+${outer.name}\\s*\\(`).exec(pageBody);
+  const pageFrame = frameAt(source, page.bodyStart + awaitCall.index, `async ${page.name}`);
+  const innerFrame = frameAt(source, inner.declIndex, inner.name);
+  const outerBody = source.slice(outer.bodyStart, outer.bodyEnd);
+  const innerCall = new RegExp(`\\b${inner.name}\\s*\\(`).exec(outerBody);
+  const outerFrame = frameAt(source, outer.bodyStart + innerCall.index, outer.name);
+  return [
+    message,
+    `    at ${pageFrame.name} (webpack:///${displayPath}:${pageFrame.line}:${pageFrame.col})`,
+    codeFrame(source, pageFrame.line, pageFrame.col) + " {",
+    causeLine,
+    `      at ${inner.name} (webpack:///${displayPath}:${innerFrame.line}:${innerFrame.col})`,
+    `      at ${outer.name} (webpack:///${displayPath}:${outerFrame.line}:${outerFrame.col})`,
+    `      at ${page.name} (<anonymous>)`,
+    indentLines(codeFrame(source, innerFrame.line, innerFrame.col), "  "),
+    "}",
+    debugTrailer(route)
+  ].join(`
+`);
+}
+function indentLines(text, pad) {
+  return text.split(`
+`).map((line) => pad + line).join(`
+`);
+}
+function detectImportedUseCacheViolation(source, pageFile, displayPath, route, debugPrerender) {
+  const functions = collectFunctions(source);
+  const page = functions.find((fn) => fn.name === "Page") ?? functions.find((fn) => isComponentName(fn.name));
+  if (!page)
+    return;
+  const pageBody = source.slice(page.bodyStart, page.bodyEnd);
+  for (const imp of source.matchAll(/import\s+(?:([\w$]+)\s*,?\s*)?(?:\{([^}]*)\})?\s*from\s*(['"])([^'"]+)\3/g)) {
+    const specifier = imp[4];
+    const names = [];
+    if (imp[1])
+      names.push(imp[1].trim());
+    if (imp[2])
+      for (const part of imp[2].split(",")) {
+        const local = part.split(/\bas\b/).pop().trim();
+        if (local)
+          names.push(local);
+      }
+    for (const name of names) {
+      if (!isComponentName(name))
+        continue;
+      const usage = new RegExp(`<${name}\\b`).exec(pageBody);
+      if (!usage)
+        continue;
+      const finding = resolveImportedUseCacheApi(pageFile, specifier, name);
+      if (!finding)
+        continue;
+      const frame = frameAt(source, page.bodyStart + usage.index, page.name);
+      return useCacheBlock(route, displayPath, source, { api: finding, frames: [frame], anchor: frame }, debugPrerender);
+    }
+  }
+  return;
+}
+function resolveImportedUseCacheApi(pageFile, specifier, name) {
+  const moduleFile = resolveModule(pageFile, specifier);
+  if (!moduleFile)
+    return;
+  const moduleSource = readSource(moduleFile);
+  if (!moduleSource)
+    return;
+  const fn = collectFunctions(moduleSource).find((candidate) => candidate.name === name);
+  if (!fn)
+    return;
+  const body = moduleSource.slice(fn.bodyStart, fn.bodyEnd);
+  if (!hasUseCachePrologue(body) || hasPrivateCachePrologue(body))
+    return;
+  if (/draftMode\s*\(\s*\)\s*\)?\s*\.\s*enable\s*\(/.test(body))
+    return "draftMode";
+  const request = /\bawait\s+(cookies|headers|connection)\s*\(/.exec(body);
+  return request ? request[1] : undefined;
+}
+function resolveModule(fromFile, specifier) {
+  const exts = ["tsx", "ts", "jsx", "js", "mjs", "cjs"];
+  const tryFile = (base) => {
+    if (existsSync(base) && !isDirectory(base))
+      return base;
+    for (const ext of exts)
+      if (existsSync(`${base}.${ext}`))
+        return `${base}.${ext}`;
+    for (const ext of exts) {
+      const index = path.join(base, `index.${ext}`);
+      if (existsSync(index))
+        return index;
+    }
+    return;
+  };
+  if (specifier.startsWith(".")) {
+    return tryFile(path.resolve(path.dirname(fromFile), specifier));
+  }
+  const [scope, sub] = specifier.startsWith("@") ? [specifier.split("/").slice(0, 2).join("/"), specifier.split("/").slice(2).join("/")] : [specifier.split("/")[0], specifier.split("/").slice(1).join("/")];
+  let dir = path.dirname(fromFile);
+  for (;; ) {
+    const pkgDir = path.join(dir, "node_modules", scope);
+    if (existsSync(pkgDir)) {
+      if (sub)
+        return tryFile(path.join(pkgDir, sub));
+      const entry = packageEntry(pkgDir);
+      if (entry)
+        return tryFile(path.join(pkgDir, entry)) ?? tryFile(path.join(pkgDir, "index"));
+      return tryFile(path.join(pkgDir, "index"));
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+function packageEntry(pkgDir) {
+  const source = readSource(path.join(pkgDir, "package.json"));
+  if (!source)
+    return;
+  try {
+    const pkg = JSON.parse(source);
+    const dot = pkg.exports?.["."];
+    if (typeof dot === "string")
+      return dot;
+    if (dot && typeof dot === "object") {
+      const cond = dot;
+      for (const key of ["import", "default", "require", "node"]) {
+        if (typeof cond[key] === "string")
+          return cond[key];
+      }
+    }
+    return pkg.module ?? pkg.main;
+  } catch {
+    return;
+  }
+}
+function detectPageDynamicHole(source, displayPath, route, layouts, debugPrerender) {
+  if (layouts.some(layoutWrapsChildrenInSuspense))
+    return;
+  const functions = collectFunctions(source);
+  const page = functions.find((fn) => fn.name === "Page") ?? functions.find((fn) => isComponentName(fn.name));
+  if (!page)
+    return;
+  const body = source.slice(page.bodyStart, page.bodyEnd);
+  if (!hasSharedCachePrologue(body))
+    return;
+  const shortCache = shortCacheLifeKind(body) !== undefined;
+  const fallbackParams = /\bawait\s+params\b/.test(body) && /\[[^\]]+\]/.test(route) && !/\bgenerateStaticParams\b/.test(source);
+  if (!shortCache && !fallbackParams)
+    return;
+  const anchor = frameAt(source, page.declIndex, page.name);
+  const violation = { frames: [anchor], anchor, wrapperDepth: 0 };
+  return blockingDynamicBlock(route, displayPath, source, violation, debugPrerender);
+}
+function layoutWrapsChildrenInSuspense(source) {
+  const suspense = source.indexOf("<Suspense");
+  const children = source.indexOf("{children}");
+  return suspense !== -1 && children !== -1 && suspense < children;
+}
+var CODE_FRAME_MAX_WIDTH = 100;
+function clampCodeFrameRow(row) {
+  return row.length <= CODE_FRAME_MAX_WIDTH ? row : `${row.slice(0, CODE_FRAME_MAX_WIDTH - 3)}...`;
+}
+function codeFrame(source, line, col) {
+  const lines = source.split(`
+`);
+  const first = Math.max(1, line - 2);
+  const last = Math.min(lines.length, line + 3);
+  const width = String(last).length;
+  const out = [];
+  for (let n = first;n <= last; n += 1) {
+    const cursor = n === line ? ">" : " ";
+    const text = lines[n - 1] ?? "";
+    out.push(clampCodeFrameRow(`${cursor} ${String(n).padStart(width)} |${text ? ` ${text}` : ""}`));
+    if (n === line) {
+      out.push(`${" ".repeat(width + 2)} | ${" ".repeat(col - 1)}^`);
+    }
+  }
+  return out.join(`
+`);
+}
+var DYNAMIC_APIS = ["cookies", "headers", "connection", "draftMode"];
+function analyzePage(source) {
+  const functions = collectFunctions(source);
+  const byName = new Map(functions.map((fn) => [fn.name, fn]));
+  const instantFalse = /\bexport\s+const\s+unstable_instant\s*=\s*false\b/.test(source);
+  const dynamicMetadata = generatorIsDynamic(source, byName.get("generateMetadata"));
+  const dynamicViewport = generatorIsDynamic(source, byName.get("generateViewport"));
+  const page = byName.get("Page") ?? functions.find((fn) => isComponentName(fn.name));
+  const violations = [];
+  let hasSuspendedDynamic = false;
+  if (page) {
+    const body = source.slice(page.bodyStart, page.bodyEnd);
+    for (const fn of functions) {
+      if (!isComponentName(fn.name) || fn === page)
+        continue;
+      const usageState = componentDynamicState(source, fn, byName);
+      if (usageState === "static")
+        continue;
+      const usagePattern = new RegExp(`<${fn.name}\\b[^>]*>`, "g");
+      for (const usage of body.matchAll(usagePattern)) {
+        const usageIndex = page.bodyStart + (usage.index ?? 0);
+        if (usageState === "conditional" && /\bcached(?:=\{true\}|\b(?!=))/.test(usage[0])) {
+          continue;
+        }
+        if (insideSuspense(body, usage.index ?? 0)) {
+          hasSuspendedDynamic = true;
+          continue;
+        }
+        violations.push(buildViolation(source, fn, byName, page, usageIndex));
+      }
+    }
+  }
+  return { dynamicMetadata, dynamicViewport, instantFalse, hasSuspendedDynamic, violations };
+}
+function generatorIsDynamic(source, fn) {
+  if (!fn)
+    return false;
+  const body = source.slice(fn.bodyStart, fn.bodyEnd);
+  if (/(['"])use cache(?:\s*:\s*[\w-]+)?\1/.test(body))
+    return false;
+  return /\bawait\b/.test(body);
+}
+function componentDynamicState(source, fn, byName) {
+  const body = source.slice(fn.bodyStart, fn.bodyEnd);
+  if (hasPrivateCachePrologue(body))
+    return "dynamic";
+  if (hasUseCachePrologue(body))
+    return "static";
+  const conditional = /\bcached\s*\?/.test(body);
+  if (directDynamicAwait(body) !== undefined)
+    return "dynamic";
+  for (const call of body.matchAll(/\bawait\s+([a-z][\w$]*)\s*\(/g)) {
+    const helper = byName.get(call[1]);
+    if (helper && directDynamicAwait(source.slice(helper.bodyStart, helper.bodyEnd)) !== undefined) {
+      return conditional ? "conditional" : "dynamic";
+    }
+  }
+  return "static";
+}
+function directDynamicAwait(body) {
+  const api = new RegExp(`\\bawait\\s+(?:${DYNAMIC_APIS.join("|")})\\s*(\\()`).exec(body);
+  const fetchCall = /\bawait\s+fetch\s*(\()/.exec(body);
+  const uncachedFetch = fetchCall && !body.slice(fetchCall.index, fetchCall.index + 300).includes("force-cache") ? fetchCall : null;
+  const promise = /\bawait\s+(new\s+Promise)/.exec(body);
+  const candidates = [
+    ...api ? [{ index: api.index + api[0].length - 1, kind: "api" }] : [],
+    ...uncachedFetch ? [{ index: uncachedFetch.index + uncachedFetch[0].length - 1, kind: "api" }] : [],
+    ...promise ? [{ index: promise.index + promise[0].indexOf("new"), kind: "promise" }] : []
+  ];
+  candidates.sort((a, b) => a.index - b.index);
+  return candidates[0];
+}
+function buildViolation(source, component, byName, page, usageIndex) {
+  const frames = [];
+  const body = source.slice(component.bodyStart, component.bodyEnd);
+  const direct = directDynamicAwait(body);
+  const helperCall = [...body.matchAll(/\bawait\s+([a-z][\w$]*)\s*\(/g)].find((call) => {
+    const helper = byName.get(call[1]);
+    return helper && directDynamicAwait(source.slice(helper.bodyStart, helper.bodyEnd)) !== undefined;
+  });
+  if (helperCall && !direct) {
+    const helper = byName.get(helperCall[1]);
+    const helperBody = source.slice(helper.bodyStart, helper.bodyEnd);
+    const site = directDynamicAwait(helperBody);
+    frames.push(frameAt(source, helper.bodyStart + site.index, helper.name));
+    const calleeIndex = component.bodyStart + (helperCall.index ?? 0) + helperCall[0].indexOf(helperCall[1]);
+    frames.push(frameAt(source, calleeIndex, component.name));
+  } else if (direct?.kind === "api") {
+    frames.push(frameAt(source, component.bodyStart + direct.index, component.name));
+  } else {
+    frames.push(frameAt(source, component.nameIndex, component.name));
+  }
+  frames.push(frameAt(source, usageIndex, page.name));
+  return {
+    frames,
+    anchor: frames[0],
+    wrapperDepth: componentWrapperDepth(source.slice(page.bodyStart, page.bodyEnd), usageIndex - page.bodyStart)
+  };
+}
+function componentWrapperDepth(body, index) {
+  let depth = 0;
+  for (const tag of body.slice(0, index).matchAll(/<(\/?)([A-Z][\w$.]*)\b([^>]*)>/g)) {
+    if (tag[2] === "Suspense")
+      continue;
+    if (tag[1] === "/")
+      depth -= 1;
+    else if (!tag[3].trimEnd().endsWith("/"))
+      depth += 1;
+  }
+  return Math.max(0, depth);
+}
+function frameAt(source, index, name) {
+  const before = source.slice(0, index);
+  const line = before.split(`
+`).length;
+  const col = index - before.lastIndexOf(`
+`);
+  return { name, line, col };
+}
+function insideSuspense(body, index) {
+  const before = body.slice(0, index);
+  const opens = (before.match(/<Suspense[\s>]/g) ?? []).length;
+  const closes = (before.match(/<\/Suspense>/g) ?? []).length;
+  return opens > closes;
+}
+function isComponentName(name) {
+  return /^[A-Z]/.test(name) && name !== "Fallback";
+}
+function collectFunctions(source) {
+  const out = [];
+  const patterns = [
+    /(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?::[^{]+)?\{/g,
+    /(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:function\s*)?\([^)]*\)\s*(?::[^={]+)?=>?\s*\{/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of source.matchAll(pattern)) {
+      const name = match[1];
+      const matchIndex = match.index ?? 0;
+      const nameIndex = matchIndex + match[0].indexOf(name);
+      const bodyStart = matchIndex + match[0].length;
+      out.push({
+        name,
+        declIndex: matchIndex,
+        nameIndex,
+        bodyStart,
+        bodyEnd: bodyEndFrom(source, bodyStart)
+      });
+    }
+  }
+  return out;
+}
+function bodyEndFrom(source, offset) {
+  let depth = 1;
+  let quote;
+  for (let cursor = offset;cursor < source.length; cursor++) {
+    const current = source[cursor];
+    if (quote) {
+      if (current === "\\")
+        cursor++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === "/" && source[cursor + 1] === "/") {
+      const newline = source.indexOf(`
+`, cursor + 2);
+      if (newline === -1)
+        return source.length;
+      cursor = newline;
+      continue;
+    }
+    if (current === "/" && source[cursor + 1] === "*") {
+      const end = source.indexOf("*/", cursor + 2);
+      if (end === -1)
+        return source.length;
+      cursor = end + 1;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`") {
+      quote = current;
+      continue;
+    }
+    if (current === "{")
+      depth++;
+    else if (current === "}" && --depth === 0)
+      return cursor;
+  }
+  return source.length;
+}
+function layoutChainSources(appPath, pageFile) {
+  const sources = [];
+  let dir = path.dirname(pageFile);
+  while (dir.startsWith(appPath)) {
+    for (const ext of ["tsx", "ts", "jsx", "js"]) {
+      const candidate = path.join(dir, `layout.${ext}`);
+      if (existsSync(candidate)) {
+        const source = readSource(candidate);
+        if (source)
+          sources.push(source);
+      }
+    }
+    if (dir === appPath)
+      break;
+    dir = path.dirname(dir);
+  }
+  return sources;
+}
+function layoutWrapsBodyInSuspense(source) {
+  const suspense = source.indexOf("<Suspense");
+  const body = source.indexOf("<body");
+  return suspense !== -1 && body !== -1 && suspense < body;
+}
+function readSource(file) {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return;
+  }
+}
+function isDirectory(file) {
+  try {
+    return statSync(file).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function appRelativeDisplayPath(appPath, file) {
+  const relative = path.relative(appPath, file).split(path.sep).join("/");
+  return `app/${relative}`;
+}
+var RSC_REDACTED_RUNTIME_MESSAGE = "An error occurred in the Server Components render. The specific message is " + "omitted in production builds to avoid leaking sensitive details. A digest " + "property is included on this error instance which may provide additional " + "details about the nature of the error.";
+
+// src/compat/cache/build-flags.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import path2 from "path";
+var BUILD_FLAG_GLOBALS = Symbol.for("pnext.compat.buildFlags");
+function state() {
+  const root = globalThis;
+  return root[BUILD_FLAG_GLOBALS] ??= {};
+}
+function flagsFile(outPath) {
+  return path2.join(outPath, "server", "pnext-build-flags.json");
+}
+function setBuildFlagsOutPath(outPath) {
+  const current = state();
+  if (current.outPath !== outPath) {
+    current.outPath = outPath;
+    current.flags = undefined;
+  }
+}
+function writeBuildFlags(outPath, debugPrerender) {
+  const file = flagsFile(outPath);
+  try {
+    mkdirSync(path2.dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify({ debugPrerender })}
+`);
+  } catch {}
+  const current = state();
+  current.outPath = outPath;
+  current.flags = { debugPrerender };
+}
+
+// src/compat/cache/runtime-error.ts
+var SHAPED = Symbol.for("pnext.compat.cacheRuntimeErrorShaped");
+
+// src/compat/cache/use-cache.ts
+var USE_CACHE_FILL_TIMEOUT = Symbol.for("pnext.compat.useCacheFillTimeout");
+function fillTimeoutHolder() {
+  const root = globalThis;
+  return root[USE_CACHE_FILL_TIMEOUT] ??= { ms: 50000 };
+}
+function setUseCacheFillTimeout(ms) {
+  if (typeof ms === "number" && Number.isFinite(ms) && ms > 0) {
+    fillTimeoutHolder().ms = ms;
+  }
+}
+var USE_CACHE_ENTRIES = Symbol.for("pnext.compat.useCacheEntries");
+var USE_CACHE_SCOPE_STORAGE = Symbol.for("pnext.compat.useCacheScopeStorage");
+var USE_CACHE_KNOWN_ROOT_PARAMS = Symbol.for("pnext.compat.knownRootParamsByFunctionId");
+var USE_CACHE_REQUEST_TOKENS = Symbol.for("pnext.compat.useCacheRequestTokens");
+function useCacheGlobal(key, create) {
+  const state2 = globalThis;
+  const existing = state2[key];
+  if (existing !== undefined)
+    return existing;
+  const value = create();
+  state2[key] = value;
+  return value;
+}
+var entries = useCacheGlobal(USE_CACHE_ENTRIES, () => new Map);
+var scopeStorage = useCacheGlobal(USE_CACHE_SCOPE_STORAGE, () => new AsyncLocalStorage);
+var requestTokens = useCacheGlobal(USE_CACHE_REQUEST_TOKENS, () => new WeakMap);
+var USE_CACHE_RDC_CAPTURE = Symbol.for("pnext.compat.useCacheRdcCapture");
+var USE_CACHE_RDC_RECORDS = Symbol.for("pnext.compat.useCacheRdcRecords");
+function useCacheRdcRecords() {
+  return useCacheGlobal(USE_CACHE_RDC_RECORDS, () => new Map);
+}
+function useCacheRdcCapture() {
+  return globalThis[USE_CACHE_RDC_CAPTURE];
+}
+function beginUseCacheRdcCapture() {
+  globalThis[USE_CACHE_RDC_CAPTURE] = new Set;
+}
+async function collectUseCacheRdcRecords() {
+  const capture = useCacheRdcCapture();
+  if (!capture)
+    return [];
+  const records = [];
+  for (const key of capture) {
+    const entry = entries.get(key);
+    if (!entry)
+      continue;
+    const value = toRdcValue(await entry.value);
+    if (value === undefined)
+      continue;
+    records.push({
+      key,
+      value,
+      tags: [...entry.tags],
+      storedAt: entry.storedAt,
+      ...entry.revalidateSeconds !== undefined ? { revalidateSeconds: entry.revalidateSeconds } : {},
+      ...entry.expireSeconds !== undefined ? { expireSeconds: entry.expireSeconds } : {},
+      ...entry.staleSeconds !== undefined ? { staleSeconds: entry.staleSeconds } : {},
+      tagSeq: entry.tagSeq,
+      pid: rdcProcessId(),
+      ...entry.route !== undefined ? { route: entry.route } : {}
+    });
+  }
+  return records;
+}
+async function collectUseCacheRdcTags() {
+  const capture = useCacheRdcCapture();
+  if (!capture)
+    return [];
+  const tags = new Set;
+  for (const key of capture) {
+    const entry = entries.get(key);
+    if (!entry)
+      continue;
+    await entry.value.catch(() => {
+      return;
+    });
+    for (const tag of entry.tags)
+      tags.add(tag);
+  }
+  return [...tags];
+}
+function seedUseCacheRdcRecords(records, route) {
+  for (const record of records) {
+    if (!isUseCacheRdcRecord(record))
+      continue;
+    const tagSeq = rebaseRdcTagSeq(record);
+    const live = entries.get(record.key);
+    if (live !== undefined && live.storedAt > record.storedAt)
+      continue;
+    useCacheRdcRecords().set(record.key, { ...record, tagSeq });
+    entries.set(record.key, {
+      value: Promise.resolve(record.value),
+      storedAt: record.storedAt,
+      tags: [...record.tags],
+      ...record.revalidateSeconds !== undefined ? { revalidateSeconds: record.revalidateSeconds } : {},
+      ...record.expireSeconds !== undefined ? { expireSeconds: record.expireSeconds } : {},
+      ...record.staleSeconds !== undefined ? { staleSeconds: record.staleSeconds } : {},
+      tagSeq,
+      ...route !== undefined ? { route } : record.route !== undefined ? { route: record.route } : {}
+    });
+  }
+}
+function isUseCacheRdcRecord(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record = value;
+  return typeof record.key === "string" && Array.isArray(record.tags) && record.tags.every((tag) => typeof tag === "string") && typeof record.storedAt === "number" && Number.isFinite(record.storedAt) && typeof record.tagSeq === "number" && Number.isInteger(record.tagSeq) && isRdcValue(record.value);
+}
+function toRdcValue(value) {
+  if (!isRdcValue(value))
+    return;
+  return JSON.parse(JSON.stringify(value));
+}
+function isRdcValue(value, seen = new WeakSet) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (typeof value !== "object" || seen.has(value))
+    return false;
+  if (Array.isArray(value)) {
+    seen.add(value);
+    return value.every((item) => isRdcValue(item, seen));
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return false;
+  seen.add(value);
+  return Object.values(value).every((item) => isRdcValue(item, seen));
+}
+var knownRootParamsByFunctionId = useCacheGlobal(USE_CACHE_KNOWN_ROOT_PARAMS, () => new Map);
+var USE_CACHE_ROOT_PARAM_NAMES = Symbol.for("pnext.compat.rootParamNames");
+function setUseCacheRootParamNames(names) {
+  globalThis[USE_CACHE_ROOT_PARAM_NAMES] = new Set(names);
+}
+function recordUseCacheRootParamRead(name) {
+  const scope = scopeStorage.getStore();
+  if (!scope?.functionId)
+    return false;
+  (scope.rootParamsRead ??= new Set).add(name);
+  let known = knownRootParamsByFunctionId.get(scope.functionId);
+  if (!known) {
+    known = new Set;
+    knownRootParamsByFunctionId.set(scope.functionId, known);
+  }
+  known.add(name);
+  return true;
+}
+function insideUseCacheProducer() {
+  return scopeStorage.getStore()?.functionId !== undefined;
+}
+var USE_CACHE_LIFE = Symbol.for("pnext.compat.useCacheLife");
+function takeCacheLifeStash() {
+  const unit = getWorkUnit();
+  const compat = unit?.compat;
+  if (!compat)
+    return;
+  const life = compat[USE_CACHE_LIFE];
+  compat[USE_CACHE_LIFE] = undefined;
+  return life;
+}
+setUseCacheRevalidateSink((seconds) => {
+  recordUseCacheLife(seconds);
+});
+function recordUseCacheTags(tags) {
+  const scope = scopeStorage.getStore();
+  if (!scope)
+    return false;
+  for (const tag of tags)
+    scope.tags.add(tag);
+  return true;
+}
+function recordUseCacheLife(life) {
+  const scope = scopeStorage.getStore();
+  if (!scope)
+    return false;
+  const revalidate = typeof life === "number" ? life : life.revalidateSeconds;
+  const expire = typeof life === "number" ? undefined : life.expireSeconds;
+  const stale = typeof life === "number" ? undefined : life.staleSeconds;
+  if (revalidate !== undefined) {
+    scope.revalidateSeconds = scope.revalidateSeconds === undefined ? revalidate : Math.min(scope.revalidateSeconds, revalidate);
+  }
+  if (expire !== undefined) {
+    scope.expireSeconds = scope.expireSeconds === undefined ? expire : Math.min(scope.expireSeconds, expire);
+  }
+  if (stale !== undefined) {
+    scope.staleSeconds = scope.staleSeconds === undefined ? stale : Math.min(scope.staleSeconds, stale);
+  }
+  return true;
+}
+var PRIVATE_CACHE_STORE = Symbol.for("pnext.compat.privateCacheStore");
+var PRIVATE_STORE_BY_REQUEST = Symbol.for("pnext.compat.privateStoreByRequest");
+var privateStoreByRequest = useCacheGlobal(PRIVATE_STORE_BY_REQUEST, () => new WeakMap);
+var USE_CACHE_WRAPPER = Symbol.for("pnext.compat.useCacheWrapper");
+var MEMO_WRAPPED = Symbol.for("pnext.compat.useCacheMemoWrapped");
+var clientReferenceSymbol = Symbol.for("pnext.clientReference");
+var dynamicReferenceSymbol = Symbol.for("pnext.dynamic");
+var paramsScopeSymbol = Symbol.for("pnext.paramsScope");
+var clientPageComponentSymbol = Symbol.for("pnext.clientPageComponent");
+var useCacheJoinerPromiseSymbol = Symbol.for("pnext.compat.useCacheJoinerPromise");
+
+export { setBuildFlagsOutPath, writeBuildFlags, diagnoseCacheComponentsPrerender, diagnosticLeadsWithErrorLine, prerenderFailureFooter, setUseCacheFillTimeout, beginUseCacheRdcCapture, collectUseCacheRdcRecords, collectUseCacheRdcTags, seedUseCacheRdcRecords, setUseCacheRootParamNames, recordUseCacheRootParamRead, insideUseCacheProducer, takeCacheLifeStash, recordUseCacheTags, recordUseCacheLife };