@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,1299 @@
+// @bun
+import {
+  activateTestProxy,
+  installTestProxyFetch
+} from "./index-2wfv4kvx.js";
+import {
+  transpilePackages
+} from "./index-danncfhy.js";
+import {
+  selectRouteForRequest
+} from "./index-jepjvcrf.js";
+import {
+  compatAliases,
+  missingCompatImportError,
+  nextCompatAliases,
+  nextCompatEnabled,
+  reactCompatEnabled,
+  reactCompilerOptions,
+  reactServerLayerAliases
+} from "./index-eeaanp2e.js";
+import {
+  findProxyFiles
+} from "./index-kq8kpzye.js";
+import {
+  getRequestRuntime
+} from "./index-z88qv16t.js";
+import {
+  recordRequestPath
+} from "./index-2vz0wzdn.js";
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+import {
+  build
+} from "./index-cjgqs13g.js";
+import {
+  cssModuleScopePath
+} from "./index-20ppawv7.js";
+import {
+  markErrorLogged
+} from "./index-jcsjq3d1.js";
+import {
+  productionRelease
+} from "./index-tqn2qnnn.js";
+import {
+  getWorkUnit
+} from "./index-grta8ap3.js";
+import {
+  isPostpone
+} from "./index-e3a6yx84.js";
+import {
+  packageNameOfSpecifier,
+  resolveExternalLoadTarget,
+  resolveImport,
+  resolvePackageSpecifier,
+  setModuleAliases
+} from "./index-yz54pxrh.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  getProxyExtensions,
+  onExtensionHostReset,
+  registerAlwaysClientEntryReason,
+  registerClientEntryDetectors,
+  registerInitHooks,
+  registerLoadableExtensions,
+  registerPageExtensions,
+  registerRequestInterceptors,
+  registerRouteConventions,
+  registerRouteDependencyClassifiers,
+  registerUsageDetectors,
+  setBundlerExtensions,
+  setCompatModeExtensions,
+  setCssExtensions,
+  setImportAliasExtensions,
+  setProxyExtensions,
+  setRequestExtensions
+} from "./index-zqpqyg8p.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/css/modules.ts
+import { existsSync, lstatSync, readdirSync, readFileSync, symlinkSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import path2 from "path";
+
+// src/compat/css/lightningcss.ts
+import { createRequire } from "module";
+import path from "path";
+var moduleCache = new Map;
+function loadLightningcss(root) {
+  const cached = moduleCache.get(root);
+  if (cached !== undefined)
+    return cached;
+  let loaded = null;
+  try {
+    const require2 = createRequire(path.join(root, "package.json"));
+    loaded = loadNative(() => require2("lightningcss"));
+  } catch {
+    loaded = null;
+  }
+  moduleCache.set(root, loaded);
+  return loaded;
+}
+function featureKey(name) {
+  return name.replace(/(?:^|-)([a-z0-9])/g, (_match, char) => char.toUpperCase());
+}
+function featureMask(features, names) {
+  let mask = 0;
+  for (const name of names ?? [])
+    mask |= features[featureKey(name)] ?? 0;
+  return mask;
+}
+function maybeLightningcssTransform(css, file, root) {
+  const experimental = getNextConfig().experimental;
+  if (experimental?.useLightningcss !== true)
+    return css;
+  const lightning = loadLightningcss(root);
+  if (!lightning)
+    return css;
+  const features = experimental.lightningCssFeatures;
+  const userInclude = featureMask(lightning.Features, features?.include);
+  const userExclude = featureMask(lightning.Features, features?.exclude);
+  const include = ((lightning.Features.Nesting ?? 1) | userInclude) & ~userExclude;
+  try {
+    const result = lightning.transform({
+      filename: file,
+      code: new TextEncoder().encode(css),
+      include,
+      exclude: userExclude,
+      errorRecovery: true
+    });
+    return new TextDecoder().decode(result.code);
+  } catch {
+    return css;
+  }
+}
+
+// src/compat/css/modules.ts
+var pagesCompatIgnoredSourceEntries = new Set([".next", ".pnext", "app", "node_modules", "pages"]);
+function materializeNextCssSources(config) {
+  if (productionRelease(config))
+    return;
+  const generatedRoot = path2.dirname(config.appPath);
+  if (path2.basename(path2.dirname(generatedRoot)) !== "pnext-pages-compat")
+    return;
+  const outTop = path2.relative(config.root, config.outRootPath).split(path2.sep)[0];
+  const inApp = !path2.relative(config.root, generatedRoot).startsWith("..");
+  for (const entry of readdirSync(config.root)) {
+    if (pagesCompatIgnoredSourceEntries.has(entry) || entry === outTop)
+      continue;
+    const source = path2.join(config.root, entry);
+    const target = path2.join(generatedRoot, entry);
+    if (existsSync(target))
+      continue;
+    try {
+      symlinkSync(inApp ? path2.relative(generatedRoot, source) : source, target, lstatSync(source).isDirectory() ? "dir" : "file");
+    } catch {}
+  }
+}
+var cssBuild;
+function nextCssModuleChunkPlugin(config) {
+  return {
+    name: "pnext-compat-css-modules",
+    setup(build2) {
+      build2.onLoad({ filter: /\.css$/ }, async ({ path: file }) => {
+        const source = nextCssSource(file, config.root);
+        const raw = (await (cssBuild ??= import("./build-spy3dxp4.js"))).hoistCssImports(readFileSync(source, "utf8"));
+        const contents = file.endsWith(".module.css") ? transformCssModule(raw, source, config.root) : rewriteTransparentBodyChildren(raw);
+        return {
+          contents: maybeLightningcssTransform(contents, source, config.root),
+          loader: "css",
+          resolveDir: path2.dirname(source)
+        };
+      });
+    }
+  };
+}
+function nextCssResolveModule(config) {
+  return (file) => isCssModuleFile(file) ? cssModuleMapping(file, config.root) : undefined;
+}
+function nextCssLoadModuleForClient(config) {
+  return (file) => isCssModuleFile(file) ? `export default ${JSON.stringify(cssModuleMapping(file, config.root))};` : undefined;
+}
+function nextCssResolveDependency(config) {
+  const requires = new Map;
+  return (_root, fromFile, specifier) => {
+    if (specifier.startsWith(".") || path2.isAbsolute(specifier))
+      return;
+    const source = nextCssSource(fromFile, config.root);
+    let require2 = requires.get(source);
+    if (!require2) {
+      require2 = createRequire2(source);
+      requires.set(source, require2);
+    }
+    try {
+      const resolved = require2.resolve(specifier);
+      return isCssDependency(resolved) ? resolved : undefined;
+    } catch {
+      return;
+    }
+  };
+}
+function isCssModuleFile(file) {
+  return file.endsWith(".module.css");
+}
+function isCssDependency(file) {
+  return /\.(?:css|scss|sass)$/.test(file);
+}
+function cssModuleMapping(file, root) {
+  file = nextCssSource(file, root);
+  const cache = new Map;
+  const info = moduleInfo(file, root, cache);
+  return Object.fromEntries([...info.classes].map((className) => [
+    className,
+    classValue(file, className, root, cache, new Set)
+  ]));
+}
+function nextCssSource(file, root) {
+  const resolved = path2.resolve(file);
+  const parts = resolved.split(path2.sep);
+  const buildClientIndex = parts.findIndex((_, index) => parts.slice(index, index + 3).join("/") === "cache/server/build-client");
+  if (buildClientIndex !== -1) {
+    const source = path2.join(root, ...parts.slice(buildClientIndex + 3));
+    if (existsSync(source))
+      return source;
+  }
+  const generatedIndex = parts.lastIndexOf("pnext-pages-compat");
+  const relative = generatedIndex === -1 ? undefined : parts.slice(generatedIndex + 2);
+  if (relative?.length) {
+    const source = path2.join(root, ...relative[0] === "source-app" ? ["app", ...relative.slice(1)] : relative[0] === "source-pages" ? ["pages", ...relative.slice(1)] : relative);
+    if (existsSync(source))
+      return source;
+  }
+  return resolved;
+}
+function rewriteTransparentBodyChildren(source) {
+  return source.replace(/body\s*>\s*(-?[_a-zA-Z][\w-]*)/g, (_, element) => `:is(body>${element},body :where(pnext-layout,#pnext-page)>${element})`);
+}
+function transformCssModule(source, file, root) {
+  const info = moduleInfoFromSource(source, file, root);
+  const imports = info.dependencies.map((dep) => `@import ${JSON.stringify(dep)};`).join(`
+`);
+  const css = scopeKeyframes(rewriteModuleSelectors(stripComposes(source), file), file);
+  return [imports, css].filter(Boolean).join(`
+`);
+}
+function moduleInfo(file, root, cache) {
+  const key = path2.resolve(file);
+  const cached = cache.get(key);
+  if (cached)
+    return cached;
+  const info = moduleInfoFromSource(readFileSync(key, "utf8"), key, root);
+  cache.set(key, info);
+  return info;
+}
+function moduleInfoFromSource(source, file, root) {
+  const classes = cssClassNames(source);
+  const composes = new Map;
+  const dependencies = [];
+  const seenDependencies = new Set;
+  const rulePattern = /(^|})([^{}]+)\{([^{}]*)\}/g;
+  let match;
+  while (match = rulePattern.exec(source)) {
+    const [, , selector, body] = match;
+    if (!selector || !body)
+      continue;
+    const localClasses = selectorClassNames(selector).filter((className) => classes.has(className));
+    if (localClasses.length === 0)
+      continue;
+    for (const ref of composeRefs(body)) {
+      for (const localClass of localClasses) {
+        const refs = composes.get(localClass) ?? [];
+        refs.push(ref);
+        composes.set(localClass, refs);
+      }
+      if (!ref.from || ref.from === "global")
+        continue;
+      const dependency = resolveCssModuleImport(root, file, ref.from);
+      if (!dependency || seenDependencies.has(dependency))
+        continue;
+      dependencies.push(dependency);
+      seenDependencies.add(dependency);
+    }
+  }
+  return { classes, composes, dependencies };
+}
+function classValue(file, className, root, cache, stack) {
+  const key = `${path2.resolve(file)}\x00${className}`;
+  if (stack.has(key))
+    return cssModuleClassName(file, className);
+  stack.add(key);
+  const info = moduleInfo(file, root, cache);
+  const parts = [cssModuleClassName(file, className)];
+  for (const ref of info.composes.get(className) ?? []) {
+    if (ref.from === "global") {
+      parts.push(...ref.names);
+      continue;
+    }
+    const refFile = ref.from ? resolveCssModuleImport(root, file, ref.from) : file;
+    if (!refFile)
+      continue;
+    const refInfo = moduleInfo(refFile, root, cache);
+    for (const name of ref.names) {
+      if (!refInfo.classes.has(name))
+        continue;
+      parts.push(...classValue(refFile, name, root, cache, stack).split(/\s+/));
+    }
+  }
+  stack.delete(key);
+  return [...new Set(parts)].join(" ");
+}
+function composeRefs(body) {
+  const refs = [];
+  const pattern = /\bcomposes\s*:\s*([^;]+);/g;
+  let match;
+  while (match = pattern.exec(body)) {
+    const value = match[1]?.trim();
+    if (!value)
+      continue;
+    const fromMatch = /^(.+?)\s+from\s+(['"]?)([^'"]+)\2$/.exec(value);
+    const names = (fromMatch?.[1] ?? value).split(/\s+/).filter(Boolean);
+    if (names.length === 0)
+      continue;
+    refs.push({ names, ...fromMatch?.[3] ? { from: fromMatch[3] } : {} });
+  }
+  return refs;
+}
+function resolveCssModuleImport(root, fromFile, specifier) {
+  const resolved = resolveImport(root, fromFile, specifier);
+  if (resolved && isCssModuleFile(resolved))
+    return path2.resolve(resolved);
+  if (specifier.startsWith(".") || path2.isAbsolute(specifier))
+    return;
+  const sibling = path2.resolve(path2.dirname(fromFile), specifier);
+  return existsSync(sibling) && isCssModuleFile(sibling) ? sibling : undefined;
+}
+function stripComposes(source) {
+  return source.replace(/\s*composes\s*:[^;{}]+;/g, "");
+}
+function cssClassNames(source) {
+  return new Set(selectorClassNames(source.replace(/\{[^{}]*\}/g, "{")));
+}
+function selectorClassNames(selector) {
+  const classes = [];
+  const pattern = /(^|[\s,>+~])\.(-?[_a-zA-Z][\w-]*)/g;
+  let match;
+  while (match = pattern.exec(selector)) {
+    if (match[2])
+      classes.push(match[2]);
+  }
+  return classes;
+}
+function rewriteModuleSelectors(css, file) {
+  let out = "";
+  let runStart = 0;
+  for (let index = 0;index < css.length; index++) {
+    const char = css[index];
+    if (char === "{") {
+      out += `${rewriteSelectorRun(css.slice(runStart, index), file)}{`;
+      runStart = index + 1;
+    } else if (char === "}" || char === ";") {
+      out += css.slice(runStart, index + 1);
+      runStart = index + 1;
+    }
+  }
+  return out + css.slice(runStart);
+}
+function rewriteSelectorRun(selector, file) {
+  if (selector.trimStart().startsWith("@"))
+    return selector;
+  let out = selector;
+  for (const className of selectorClassNames(selector)) {
+    out = rewriteClassSelector(out, cssModuleClassName(file, className), className);
+  }
+  return out.replace(/:global\(((?:[^()]|\([^()]*\))*)\)/g, "$1");
+}
+function scopeKeyframes(css, file) {
+  let out = css;
+  for (const name of keyframeNames(css)) {
+    const scoped = cssModuleClassName(file, name);
+    out = out.replace(new RegExp(`(@(?:-webkit-)?keyframes\\s+)${escapeRegex(name)}(?![-_a-zA-Z0-9])`, "g"), `$1${scoped}`);
+    out = out.replace(new RegExp(`(animation-name\\s*:\\s*)${escapeRegex(name)}(?![-_a-zA-Z0-9])`, "g"), `$1${scoped}`);
+    out = out.replace(new RegExp(`(animation\\s*:[^;{}]*?(?<![-_a-zA-Z0-9]))${escapeRegex(name)}(?![-_a-zA-Z0-9])`, "g"), `$1${scoped}`);
+  }
+  return out;
+}
+function keyframeNames(css) {
+  const names = new Set;
+  const pattern = /@(?:-webkit-)?keyframes\s+(-?[_a-zA-Z][\w-]*)/g;
+  let match;
+  while (match = pattern.exec(css)) {
+    if (match[1])
+      names.add(match[1]);
+  }
+  return names;
+}
+function cssModuleClassName(file, className) {
+  const base = path2.basename(file).replace(/\.module\.css$/, "").replace(/[^_a-zA-Z0-9]/g, "_");
+  const hash = pathHash(cssModuleScopePath(file));
+  return `${base}_${className}_${hash}`;
+}
+function rewriteClassSelector(css, scopedClassName, originalClassName) {
+  const pattern = new RegExp(`\\.${escapeRegex(originalClassName)}(?![-_a-zA-Z0-9])`, "g");
+  return css.replace(pattern, `.${scopedClassName}`);
+}
+function pathHash(file) {
+  let hash = 5381;
+  for (const char of file)
+    hash = (hash << 5) + hash ^ char.charCodeAt(0);
+  return (hash >>> 0).toString(36).slice(0, 5);
+}
+
+// src/compat/lifecycle/instrumentation.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import path3 from "path";
+import { pathToFileURL } from "url";
+import { createRequire as createRequire3 } from "module";
+var INSTRUMENTATION_BASENAMES = [
+  "instrumentation.ts",
+  "instrumentation.mts",
+  "instrumentation.js",
+  "instrumentation.mjs",
+  "instrumentation.tsx"
+];
+function instrumentationAliases(config) {
+  return { ...compatAliases(config, "server"), ...reactServerLayerAliases(config) };
+}
+function instrumentationPlugin(root, config) {
+  const appRequire = createRequire3(path3.join(root, "package.json"));
+  const aliases = config ? instrumentationAliases(config) : {};
+  return {
+    name: "pnext-instrumentation",
+    setup(builder) {
+      builder.onResolve({ filter: /^[^./]/ }, (args) => {
+        const alias = aliases[args.path];
+        if (!alias)
+          return;
+        return {
+          path: path3.isAbsolute(alias) ? pathToFileURL(alias).href : alias,
+          external: true
+        };
+      });
+      builder.onResolve({ filter: /^server-only$/ }, () => ({
+        path: "server-only",
+        namespace: "pnext"
+      }));
+      builder.onLoad({ filter: /^server-only$/, namespace: "pnext" }, () => ({ contents: "" }));
+      builder.onResolve({ filter: /^@vercel\/otel$/ }, () => {
+        try {
+          appRequire.resolve("@vercel/otel");
+          return;
+        } catch {
+          return { path: "@vercel/otel", namespace: "pnext" };
+        }
+      });
+      builder.onLoad({ filter: /^@vercel\/otel$/, namespace: "pnext" }, () => ({
+        contents: "export function registerOTel() {}"
+      }));
+      builder.onResolve({ filter: /^[^./]/ }, (args) => {
+        const target = resolveExternalLoadTarget({
+          root,
+          fromFile: args.importer || path3.join(root, "instrumentation.ts"),
+          specifier: args.path,
+          target: "server"
+        });
+        return target ? { path: target } : undefined;
+      });
+    }
+  };
+}
+var loaded;
+var readyGate;
+function getUserOnRequestError() {
+  return loaded?.onRequestError;
+}
+function instrumentationReady() {
+  return readyGate ?? Promise.resolve();
+}
+function findInstrumentation(config) {
+  for (const root of instrumentationLookupRoots(config)) {
+    for (const name of INSTRUMENTATION_BASENAMES) {
+      const candidate = path3.join(root, name);
+      if (existsSync2(candidate))
+        return candidate;
+    }
+  }
+  return;
+}
+function instrumentationLookupRoots(config) {
+  const src = path3.join(config.root, "src");
+  const usesSrc = existsSync2(path3.join(src, "app")) || existsSync2(path3.join(src, "pages"));
+  return usesSrc ? [src] : [config.root];
+}
+async function importInstrumentation(file, config, suffix = "") {
+  const outDir = path3.join(config.outPath, "instrumentation");
+  mkdirSync(outDir, { recursive: true });
+  const outfile = path3.join(outDir, `instrumentation.${Date.now()}${suffix}.mjs`);
+  try {
+    await bundleInstrumentation(file, config, outfile);
+    return await import(pathToFileURL(outfile).href);
+  } finally {
+    rmSync(outfile, { force: true });
+  }
+}
+async function bundleInstrumentation(file, config, outfile, releaseDir) {
+  const root = config.root;
+  const tsconfig = path3.join(root, "tsconfig.json");
+  const sourceUrl = releaseDir ? `new URL(${JSON.stringify(path3.relative(releaseDir, file).split(path3.sep).join("/"))}, import.meta.url).href` : JSON.stringify(pathToFileURL(file).href);
+  await build({
+    entryPoints: [file],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    target: "esnext",
+    packages: "external",
+    plugins: [instrumentationPlugin(root, config)],
+    ...existsSync2(tsconfig) ? { tsconfig } : {},
+    banner: {
+      js: `import { fileURLToPath as __pnextFileURLToPath } from "node:url";
+import { dirname as __pnextDirname } from "node:path";
+const __pnextSourceUrl = ${sourceUrl};
+const __pnextSourceFile = __pnextFileURLToPath(__pnextSourceUrl);
+const __pnextSourceDir = __pnextDirname(__pnextSourceFile);`
+    },
+    define: {
+      __dirname: "__pnextSourceDir",
+      __filename: "__pnextSourceFile",
+      "import.meta.url": "__pnextSourceUrl"
+    },
+    logLevel: "silent",
+    sourcemap: false
+  });
+}
+function loadInstrumentation(config) {
+  if (readyGate)
+    return;
+  const released = productionRelease(config);
+  if (released) {
+    readyGate = registerReleased(released.instrumentation);
+    return;
+  }
+  const file = findInstrumentation(config);
+  if (!file) {
+    readyGate = Promise.resolve();
+    return;
+  }
+  readyGate = (async () => {
+    try {
+      if (!process.env.NEXT_RUNTIME)
+        process.env.NEXT_RUNTIME = "nodejs";
+      loaded = await importInstrumentation(file, config);
+      await loaded.register?.();
+      if (appHasEdgeEntities(config))
+        await runEdgeRegisterPass(file, config);
+    } catch (error) {
+      console.error("instrumentation register() failed:", error);
+    }
+  })();
+}
+async function registerReleased(instrumentation) {
+  if (!instrumentation?.file)
+    return;
+  try {
+    if (!process.env.NEXT_RUNTIME)
+      process.env.NEXT_RUNTIME = "nodejs";
+    loaded = await import(pathToFileURL(instrumentation.file).href);
+    await loaded.register?.();
+    if (instrumentation.edge) {
+      await withEdgeRuntime(async () => {
+        const edgeInstance = await import(pathToFileURL(instrumentation.edge).href);
+        await edgeInstance.register?.();
+      }, "instrumentation register() (edge pass) failed:");
+    }
+  } catch (error) {
+    console.error("instrumentation register() failed:", error);
+  }
+}
+async function runEdgeRegisterPass(file, config) {
+  await withEdgeRuntime(async () => {
+    const edgeInstance = await importInstrumentation(file, config, ".edge");
+    await edgeInstance.register?.();
+  }, "instrumentation register() (edge pass) failed:");
+}
+async function withEdgeRuntime(task, failure) {
+  const previous = process.env.NEXT_RUNTIME;
+  process.env.NEXT_RUNTIME = "edge";
+  try {
+    await task();
+  } catch (error) {
+    console.error(failure, error);
+  } finally {
+    if (previous === undefined) {
+      delete process.env.NEXT_RUNTIME;
+    } else {
+      process.env.NEXT_RUNTIME = previous;
+    }
+  }
+}
+var SOURCE_FILE_RE = /\.(?:ts|tsx|js|jsx|mjs|mts|cjs|cts)$/;
+var EDGE_RUNTIME_RE = /\bruntime\b\s*[:=]\s*['"](?:experimental-)?edge['"]/;
+function appHasEdgeEntities(config) {
+  const roots = [config.root, path3.join(config.root, "src")];
+  for (const root of roots) {
+    for (const name of ["middleware", "proxy"]) {
+      for (const ext of ["ts", "js", "mts", "mjs"]) {
+        if (existsSync2(path3.join(root, `${name}.${ext}`)))
+          return true;
+      }
+    }
+    for (const dir of ["app", "pages"]) {
+      if (sourceTreeDeclaresEdgeRuntime(path3.join(root, dir)))
+        return true;
+    }
+  }
+  return false;
+}
+function sourceTreeDeclaresEdgeRuntime(dir) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry.startsWith("."))
+      continue;
+    const full = path3.join(dir, entry);
+    let stats;
+    try {
+      stats = statSync(full);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      if (sourceTreeDeclaresEdgeRuntime(full))
+        return true;
+      continue;
+    }
+    if (!SOURCE_FILE_RE.test(entry))
+      continue;
+    try {
+      if (EDGE_RUNTIME_RE.test(readFileSync2(full, "utf8")))
+        return true;
+    } catch {}
+  }
+  return false;
+}
+
+// src/compat/lifecycle/error-funnel.ts
+import path4 from "path";
+import {
+  isForbiddenError,
+  isNotFoundError,
+  isRedirectError,
+  isUnauthorizedError
+} from "../../../src/api/navigation.ts";
+var ERROR_REPORTED_KEY = Symbol.for("pnext.errorReported");
+function isControlFlowError(error) {
+  return isRedirectError(error) || isNotFoundError(error) || isForbiddenError(error) || isUnauthorizedError(error) || isPostpone(error) || isNextDynamicNoSsr(error);
+}
+function isNextDynamicNoSsr(error) {
+  const digest = error?.digest;
+  return digest === "NEXT_DYNAMIC_NO_SSR_CODE" || typeof digest === "string" && digest.startsWith("DYNAMIC_SERVER_USAGE");
+}
+function toDisplayRoute(route) {
+  let value = route.route || "/";
+  if (route.catchAll) {
+    const pattern = route.catchAllOptional ? `[[...${route.catchAll}]]` : `[...${route.catchAll}]`;
+    value = value.replace(`:${route.catchAll}*`, pattern);
+  }
+  for (const param of route.params)
+    value = value.replace(`:${param}`, `[${param}]`);
+  return value;
+}
+function routeKindFromFile(runtimeRoot, route) {
+  if (!runtimeRoot) {
+    return "App Router";
+  }
+  const normalized = path4.normalize(route.file);
+  const pagesRoot = path4.join(runtimeRoot, "pages");
+  const appRoot = path4.join(runtimeRoot, "app");
+  return normalized.startsWith(pagesRoot + path4.sep) || normalized === pagesRoot ? "Pages Router" : normalized.startsWith(appRoot + path4.sep) || normalized === appRoot ? "App Router" : "App Router";
+}
+function resolveRoute(pathname) {
+  const runtime = getRequestRuntime();
+  if (!runtime)
+    return;
+  const selectedPath = pathname.split("?")[0] ?? pathname;
+  const matched = selectRouteForRequest(runtime.routes, selectedPath, undefined);
+  if (!matched)
+    return;
+  return { route: matched.route, routePath: toDisplayRoute(matched.route) };
+}
+function resolveRoutePath(path5) {
+  try {
+    return resolveRoute(path5)?.routePath;
+  } catch {
+    return;
+  }
+}
+function errorDigest(error) {
+  const digest = error?.digest;
+  return typeof digest === "string" ? digest : undefined;
+}
+function buildContext(error, context, path5) {
+  const runtime = getRequestRuntime();
+  const match = runtime ? resolveRoute(path5) : undefined;
+  const out = {};
+  out.routerKind = match ? routeKindFromFile(runtime?.config.root, match.route) : "App Router";
+  out.routeType = context.routeKind === "route-handler" ? "route" : "render";
+  const routePath = match ? match.routePath : resolveRoutePath(path5);
+  if (routePath)
+    out.routePath = routePath;
+  if (context.routeKind === "html") {
+    out.renderSource = context.renderSource ?? "react-server-components";
+  }
+  const revalidateReason = context.revalidateReason;
+  if (revalidateReason)
+    out.revalidateReason = revalidateReason;
+  const digest = errorDigest(error);
+  if (digest)
+    out.digest = digest;
+  return out;
+}
+function buildActionContext(error, path5) {
+  const runtime = getRequestRuntime();
+  const match = runtime ? resolveRoute(path5) : undefined;
+  const out = {
+    routerKind: match ? routeKindFromFile(runtime?.config.root, match.route) : "App Router",
+    routeType: "action",
+    renderSource: "react-server-components-payload"
+  };
+  const routePath = match ? match.routePath : resolveRoutePath(path5);
+  if (routePath)
+    out.routePath = routePath;
+  const digest = errorDigest(error);
+  if (digest)
+    out.digest = digest;
+  return out;
+}
+function isServerActionRequest(headers) {
+  if (headers.has("next-action"))
+    return true;
+  const accept = headers.get("accept") ?? "";
+  return accept.includes("text/x-component");
+}
+async function reportActionErrorToUser(error, request) {
+  if (isControlFlowError(error))
+    return;
+  const unit = getWorkUnit();
+  if (unit) {
+    const bag = unit.compat ??= {};
+    if (bag[ERROR_REPORTED_KEY])
+      return;
+    bag[ERROR_REPORTED_KEY] = true;
+  }
+  await instrumentationReady();
+  const hook = getUserOnRequestError();
+  if (!hook)
+    return;
+  let path5 = request.url;
+  try {
+    const parsed = new URL(request.url);
+    path5 = parsed.pathname + parsed.search;
+  } catch {}
+  try {
+    await hook(error, { path: path5, method: request.method, headers: headersToObject(request.headers) }, buildActionContext(error, path5));
+  } catch (hookError) {
+    console.error("instrumentation onRequestError failed:", hookError);
+  }
+}
+function headersToObject(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+async function reportRequestErrorToUser(error, requestInfo, context) {
+  if (isControlFlowError(error))
+    return;
+  const unit = getWorkUnit();
+  if (unit) {
+    const bag = unit.compat ??= {};
+    if (bag[ERROR_REPORTED_KEY])
+      return;
+    bag[ERROR_REPORTED_KEY] = true;
+  }
+  await instrumentationReady();
+  const hook = getUserOnRequestError();
+  if (!hook)
+    return;
+  let path5 = requestInfo.url;
+  try {
+    const parsed = new URL(requestInfo.url);
+    path5 = parsed.pathname + parsed.search;
+  } catch {}
+  const hookContext = isServerActionRequest(requestInfo.headers) ? buildActionContext(error, path5) : buildContext(error, context, path5);
+  try {
+    await hook(error, { path: path5, method: requestInfo.method, headers: headersToObject(requestInfo.headers) }, hookContext);
+  } catch (hookError) {
+    console.error("instrumentation onRequestError failed:", hookError);
+  }
+}
+var guardInstalled = false;
+function installUnhandledRejectionGuard() {
+  if (guardInstalled)
+    return;
+  if (typeof process === "undefined" || typeof process.on !== "function")
+    return;
+  guardInstalled = true;
+  process.on("unhandledRejection", (reason) => {
+    if (isControlFlowError(reason))
+      return;
+    if (markErrorLogged(reason))
+      console.error(reason);
+  });
+}
+
+// src/compat/lifecycle/node-console.ts
+import { format } from "util";
+var installed = Symbol.for("pnext.node-console-format-installed");
+function installNodeConsoleFormat() {
+  const state = globalThis;
+  if (state[installed])
+    return;
+  state[installed] = true;
+  const log = console.log.bind(console);
+  console.log = (...args) => log(format(...args));
+  const error = console.error.bind(console);
+  console.error = (...args) => error(format(...args));
+  const warn = console.warn.bind(console);
+  console.warn = (...args) => warn(format(...args));
+}
+
+// src/compat/register/lifecycle.ts
+function testProxyEnabled() {
+  const experimental = getNextConfig().experimental;
+  return experimental?.testProxy === true;
+}
+function registerLifecycleBootHooks(config) {
+  if (!nextCompatEnabled(config))
+    return;
+  installNodeConsoleFormat();
+  setRequestExtensions({ onRequestError: reportRequestErrorToUser });
+  installUnhandledRejectionGuard();
+  registerInitHooks((cfg, context) => {
+    if (!context.build)
+      loadInstrumentation(cfg);
+    installTestProxyFetch();
+  });
+}
+function registerLifecycleExtensions(config) {
+  if (!nextCompatEnabled(config))
+    return;
+  const lifecycleInterceptor = async (request) => {
+    await instrumentationReady();
+    try {
+      recordRequestPath(new URL(request.url).pathname);
+    } catch {}
+    if (testProxyEnabled())
+      activateTestProxy(request.headers);
+    return;
+  };
+  registerRequestInterceptors(lifecycleInterceptor);
+}
+
+// src/compat/register/routing.ts
+function registerRoutingExtensions(config) {
+  if (!nextCompatEnabled(config))
+    return;
+  registerRouteConventions({ name: "forbidden", boundary: true }, { name: "unauthorized", boundary: true });
+  registerUsageDetectors(usesNextRequestImport, usesNextServerConnection);
+  registerRouteDependencyClassifiers(classifyNextRouteDependencies);
+  registerClientEntryDetectors({ reason: "actions", detect: usesServerActionForm }, { reason: "form", detect: usesNextForm }, { reason: "control-flow", detect: usesClientControlFlowThrow });
+  registerAlwaysClientEntryReason("compat-parity");
+}
+var classificationCache = new Map;
+function classifyNextRouteDependencies({
+  kind,
+  files
+}) {
+  for (const { source } of files) {
+    const key = `${kind}\x00${source.length}\x00${Bun.hash(source).toString()}`;
+    let usesRequest = classificationCache.get(key);
+    if (usesRequest === undefined) {
+      usesRequest = sourceUsesRequest(kind, source);
+      classificationCache.set(key, usesRequest);
+    }
+    if (usesRequest)
+      return { usesRequest: true };
+  }
+  return;
+}
+function sourceUsesRequest(kind, source) {
+  const requestUse = usesNextRequestImport(source) || usesNextServerConnection(source);
+  const afterOnly = hasAfterCallbacks(source) && !hasRequestApiOutsideAfter(source);
+  const handlerAfterDraftMode = kind === "handler" && hasAfterDraftMode(source);
+  if (requestUse && (kind === "handler" || !afterOnly) || handlerAfterDraftMode)
+    return true;
+  return kind === "page" && hasAfterCallbacks(source) && !hasRequestApiUse(source) && !hasAfterDraftMode(source) && !hasExplicitStaticDynamic(source);
+}
+function hasAfterDraftMode(source) {
+  return hasAfterCallbacks(source) && nextHeadersBindings(source).draftMode.length > 0;
+}
+function hasRequestApiOutsideAfter(source) {
+  return hasRequestApiUse(withoutAfterCallbacks(source));
+}
+function hasRequestApiUse(source) {
+  const outside = stripCommentsAndStrings(source);
+  const headers = nextHeadersBindings(source);
+  return headers.headers.some((name) => new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside)) || headers.cookies.some((name) => new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside)) || connectionBindings(source).some((name) => new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside));
+}
+function nextHeadersBindings(source) {
+  const headers = [];
+  const cookies = [];
+  const draftMode = [];
+  const pattern = /\bimport\s+\{([^}]*)\}\s+from\s*['"]next\/headers(?:\.js)?['"]/g;
+  let match;
+  while (match = pattern.exec(stripComments(source))) {
+    for (const item of match[1].split(",")) {
+      const [imported, local] = item.trim().split(/\s+as\s+/);
+      const name = (local ?? imported)?.trim();
+      if (!name)
+        continue;
+      if (imported?.trim() === "headers")
+        headers.push(name);
+      if (imported?.trim() === "cookies")
+        cookies.push(name);
+      if (imported?.trim() === "draftMode")
+        draftMode.push(name);
+    }
+  }
+  return { headers, cookies, draftMode };
+}
+function connectionBindings(source) {
+  const names = [];
+  const pattern = /\bimport\s+[^'";]+?\s+from\s*['"]next\/server(?:\.js)?['"]/g;
+  let match;
+  while (match = pattern.exec(stripComments(source))) {
+    const named = /\{([^}]*)\}/.exec(match[0])?.[1];
+    if (!named)
+      continue;
+    for (const item of named.split(",")) {
+      const [imported, local] = item.trim().split(/\s+as\s+/);
+      if (imported?.trim() === "connection")
+        names.push((local ?? imported).trim());
+    }
+  }
+  return names;
+}
+var AFTER_TOKEN = /\bafter\b/;
+function mentionsAfter(source) {
+  return source.includes("after") && AFTER_TOKEN.test(source);
+}
+function hasAfterCallbacks(source) {
+  return mentionsAfter(source) && /\bafter\s*\(/.test(maskCommentsAndStrings(source));
+}
+function hasExplicitStaticDynamic(source) {
+  return /\bexport\s+const\s+dynamic\s*=\s*['"](?:error|force-static)['"]/.test(stripComments(source));
+}
+function withoutAfterCallbacks(source) {
+  if (!mentionsAfter(source))
+    return source;
+  const chars = [...source];
+  const searchable = maskCommentsAndStrings(source);
+  const pattern = /\bafter\s*\(/g;
+  let match;
+  while (match = pattern.exec(searchable)) {
+    let depth = 1;
+    let index = match.index + match[0].length;
+    for (;index < searchable.length && depth > 0; index++) {
+      if (searchable[index] === "(")
+        depth++;
+      else if (searchable[index] === ")")
+        depth--;
+    }
+    if (depth !== 0)
+      continue;
+    for (let cursor = match.index;cursor < index; cursor++)
+      chars[cursor] = " ";
+    pattern.lastIndex = index;
+  }
+  return chars.join("");
+}
+var maskCommentsAndStrings = memoizeBySource(maskSource);
+function maskSource(source) {
+  const chars = [...source];
+  let quote;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < chars.length; index++) {
+    const char = chars[index];
+    const next = chars[index + 1];
+    if (lineComment) {
+      if (char === `
+`)
+        lineComment = false;
+      else
+        chars[index] = " ";
+      continue;
+    }
+    if (blockComment) {
+      chars[index] = char === `
+` ? `
+` : " ";
+      if (char === "*" && next === "/") {
+        chars[index + 1] = " ";
+        blockComment = false;
+        index++;
+      }
+      continue;
+    }
+    if (quote) {
+      chars[index] = char === `
+` ? `
+` : " ";
+      if (char === "\\") {
+        if (next && next !== `
+`)
+          chars[index + 1] = " ";
+        index++;
+      } else if (char === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      chars[index] = chars[index + 1] = " ";
+      lineComment = true;
+      index++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      chars[index] = chars[index + 1] = " ";
+      blockComment = true;
+      index++;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      chars[index] = " ";
+      quote = char;
+    }
+  }
+  return chars.join("");
+}
+function usesServerActionForm(source) {
+  return source.includes("use server") && /(['"])use server\1/.test(stripComments(source)) || usesClientFunctionFormAction(source);
+}
+var CLIENT_FUNCTION_ACTION_PATTERN = /\b(?:action|formAction)\s*=\s*\{\s*(?!['"`])/;
+function usesClientFunctionFormAction(source) {
+  if (!hasUseClientDirective(source))
+    return false;
+  return CLIENT_FUNCTION_ACTION_PATTERN.test(stripComments(source));
+}
+var USE_CLIENT_DIRECTIVE = /^\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*|#![^\n]*\n|\s)*(['"])use client\1/;
+function hasUseClientDirective(source) {
+  return source.includes("use client") && USE_CLIENT_DIRECTIVE.test(source);
+}
+var CONTROL_FLOW_IMPORT_PATTERN = /import\s*\{[^}]*\b(?:notFound|forbidden|unauthorized)\b[^}]*\}\s*from\s*['"]next\/navigation(?:\.js)?['"]/;
+function usesClientControlFlowThrow(source) {
+  return hasUseClientDirective(source) && CONTROL_FLOW_IMPORT_PATTERN.test(source);
+}
+var NEXT_FORM_IMPORT_PATTERN = /import\s+[^'";]*\s+from\s+['"]next\/form(?:\.js)?['"]/;
+function usesNextForm(source) {
+  if (!source.includes("next/form"))
+    return false;
+  const searchable = stripComments(source);
+  if (!NEXT_FORM_IMPORT_PATTERN.test(searchable))
+    return false;
+  return /\b<form\b[^>]*\b(?:action|formAction)\s*=/.test(searchable) || /\bformAction\s*:\s*/.test(searchable) || /<\s*[A-Za-z_$][\w$]*\b[^>]*\b(?:action|formAction)\s*=/.test(searchable);
+}
+function usesNextRequestImport(source) {
+  const withoutComments = stripComments(source);
+  const draftModeOnlyImport = /\bimport\s+\{\s*draftMode\s*(?:as\s+[\w$]+\s*)?,?\s*\}\s*from\s*['"]next\/headers(?:\.js)?['"]/g;
+  const headers = nextHeadersImportPattern().test(withoutComments.replace(draftModeOnlyImport, ""));
+  const client = /^\s*['"]use client['"]\s*;?/.test(withoutComments);
+  return headers || !client && importsNextNavigationRequestHook(withoutComments);
+}
+function nextHeadersImportPattern() {
+  return /(?:from\s+|import\s*\()\s*['"]next\/headers(?:\.js)?['"]/;
+}
+function importsNextNavigationRequestHook(source) {
+  const importPattern = /\bimport\s+(type\s+)?([^'";]+?)\s+from\s+['"]next\/navigation['"]/g;
+  let match;
+  while (match = importPattern.exec(source)) {
+    const [, typeKeyword, clause] = match;
+    if (!typeKeyword && clause && includesRequestNavigationHook(importedExports(clause)))
+      return true;
+  }
+  const exportPattern = /\bexport\s+(type\s+)?\{([^}]*)\}\s+from\s+['"]next\/navigation['"]/g;
+  while (match = exportPattern.exec(source)) {
+    const [, typeKeyword, clause] = match;
+    if (!typeKeyword && clause && includesRequestNavigationHook(exportedNames(clause)))
+      return true;
+  }
+  return false;
+}
+function usesNextServerConnection(source) {
+  const withoutComments = stripComments(source);
+  const searchable = stripCommentsAndStrings(source);
+  const importPattern = /\bimport\s+(type\s+)?([^'";]+?)\s+from\s+['"]next\/server(?:\.js)?['"]/g;
+  let match;
+  while (match = importPattern.exec(withoutComments)) {
+    const [, typeKeyword, clause] = match;
+    if (typeKeyword || !clause)
+      continue;
+    for (const pattern of importedConnectionCallPatterns(clause)) {
+      if (pattern.test(searchable))
+        return true;
+    }
+  }
+  return false;
+}
+function importedConnectionCallPatterns(clause) {
+  const patterns = [];
+  const namespace = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause)?.[1];
+  if (namespace)
+    patterns.push(new RegExp(`\\b${escapeRegex(namespace)}\\.connection\\s*\\(`));
+  const named = /\{([^}]*)\}/.exec(clause)?.[1];
+  if (named) {
+    for (const item of named.split(",")) {
+      const [imported, local] = item.trim().split(/\s+as\s+/);
+      if (imported?.trim() === "connection") {
+        patterns.push(new RegExp(`\\b${escapeRegex((local ?? imported).trim())}\\s*\\(`));
+      }
+    }
+  }
+  return patterns;
+}
+function includesRequestNavigationHook(exports) {
+  return exports.includes("*") || exports.includes("useSearchParams") || exports.includes("useRoute");
+}
+function importedExports(clause) {
+  const value = clause.trim();
+  if (!value)
+    return [];
+  const exports = new Set;
+  if (value.startsWith("*"))
+    exports.add("*");
+  const defaultImport = /^[A-Za-z_$][\w$]*/.exec(value);
+  if (defaultImport && !value.startsWith("{") && !value.startsWith("*"))
+    exports.add("default");
+  const named = /\{([^}]*)\}/.exec(value);
+  if (named?.[1]) {
+    for (const item of named[1].split(",")) {
+      const [name] = item.trim().split(/\s+as\s+/);
+      if (name)
+        exports.add(name.trim());
+    }
+  }
+  return [...exports];
+}
+function exportedNames(clause) {
+  return clause.split(",").map((item) => item.trim().split(/\s+as\s+/)[0]?.trim()).filter((name) => Boolean(name) && name !== "type");
+}
+function memoizeBySource(derive) {
+  const cache = new Map;
+  return (source) => {
+    const hit = cache.get(source);
+    if (hit !== undefined)
+      return hit;
+    const value = derive(source);
+    if (cache.size >= 4)
+      cache.delete(cache.keys().next().value);
+    cache.set(source, value);
+    return value;
+  };
+}
+var stripCommentsAndStrings = memoizeBySource((source) => stripComments(source).replace(/(['"`])(?:\\[\s\S]|(?!\1)[^\\])*\1/g, ""));
+var stripComments = memoizeBySource((source) => {
+  const chars = [...source];
+  let quote;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < chars.length; index++) {
+    const char = chars[index];
+    const next = chars[index + 1];
+    if (lineComment) {
+      if (char === `
+`)
+        lineComment = false;
+      else
+        chars[index] = " ";
+      continue;
+    }
+    if (blockComment) {
+      chars[index] = char === `
+` ? `
+` : " ";
+      if (char === "*" && next === "/") {
+        chars[index + 1] = " ";
+        blockComment = false;
+        index++;
+      }
+      continue;
+    }
+    if (quote) {
+      if (char === "\\")
+        index++;
+      else if (char === quote)
+        quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      chars[index] = chars[index + 1] = " ";
+      lineComment = true;
+      index++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      chars[index] = chars[index + 1] = " ";
+      blockComment = true;
+      index++;
+    }
+  }
+  return chars.join("");
+});
+
+// src/compat/register/boot.ts
+var NEXT_PROXY_NAMES = ["proxy", "middleware"];
+var CORE_BASE_PAGE_EXTENSIONS = new Set(["tsx", "ts", "jsx", "js", "mjs"]);
+var registered = false;
+onExtensionHostReset(() => registered = false);
+function registerCompatBootExtensions(config) {
+  if (registered)
+    return;
+  registered = true;
+  setCompatModeExtensions({
+    nextEnabled: nextCompatEnabled,
+    reactEnabled: reactCompatEnabled,
+    reactCompilerOptions
+  });
+  setImportAliasExtensions({
+    aliases: compatAliases,
+    clientSsrAliases: (cfg) => nextCompatAliases(cfg, "server"),
+    missingImportError: missingCompatImportError,
+    reactServerLayerAliases
+  });
+  setModuleAliases(compatAliases(config, "server"));
+  registerRoutingExtensions(config);
+  registerLifecycleBootHooks(config);
+  if (!nextCompatEnabled(config))
+    return;
+  registerCompatPageExtensions();
+  setBundlerExtensions({ resolveRouteDependency: resolveTranspiledRouteDependency() });
+  materializeNextCssSources(config);
+  setCssExtensions({
+    extraCssExtensions: () => [".scss", ".sass"],
+    resolveCssDependency: nextCssResolveDependency(config)
+  });
+  setProxyExtensions({ names: NEXT_PROXY_NAMES, validateFiles: validateProxyFiles });
+}
+function registerCompatPageExtensions() {
+  const configured = getNextConfig().pageExtensions;
+  if (Array.isArray(configured)) {
+    const extras = configured.filter((ext) => typeof ext === "string" && ext.length > 0 && !CORE_BASE_PAGE_EXTENSIONS.has(ext));
+    if (extras.length > 0)
+      registerPageExtensions(...extras);
+  }
+  registerLoadableExtensions("mdx", "md");
+}
+function resolveTranspiledRouteDependency() {
+  const transpile = new Set(transpilePackages());
+  return (root, fromFile, specifier) => {
+    const packageName = packageNameOfSpecifier(specifier);
+    if (!packageName || !transpile.has(packageName))
+      return;
+    return resolvePackageSpecifier(root, fromFile, specifier, ["import", "browser", "default"]);
+  };
+}
+async function validateProxyFiles(config) {
+  if (findProxyFiles(config, NEXT_PROXY_NAMES).length === 0)
+    return;
+  const { registerProxyExtensions } = await import("./proxy-w1d0wmsn.js");
+  registerProxyExtensions(config);
+  await getProxyExtensions().validateFiles(config);
+}
+
+export { nextCssModuleChunkPlugin, nextCssResolveModule, nextCssLoadModuleForClient, nextCssSource, instrumentationReady, instrumentationLookupRoots, reportActionErrorToUser, registerLifecycleExtensions, registerCompatBootExtensions };