@wular/coder 0.4.1 → 0.4.3

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-SNVPTULL.js

@@ -1,2397 +0,0 @@
-import { createRequire as __coderRequire } from "node:module";
-const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
-import { createRequire as __pnextCreateRequire } from "node:module";
-const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
-import {
-  safeDecode
-} from "./chunk-JRPJM2XY.js";
-import {
-  dynamicCallsFromSource,
-  nextCompatEnabled,
-  pnextDynamicImportNames,
-  rewriteLiteralDynamicCalls
-} from "./chunk-CCATPVTW.js";
-import {
-  clientReferenceId,
-  dynamicCallFacts,
-  scanFacts,
-  ssrClientReference
-} from "./chunk-NQE46AZN.js";
-import {
-  cssModuleScopePath,
-  ensureDir,
-  listFiles,
-  listFilesSync,
-  readDirListing,
-  readText,
-  toPosixPath,
-  withDirCache
-} from "./chunk-2HFY3DQT.js";
-import {
-  alwaysClientEntryReasons,
-  classifyRouteDependencies,
-  extraBoundaryConventionNames,
-  extraPageExtensions,
-  getBundlerExtensions,
-  getCssExtensions,
-  resolveImport,
-  resolveModuleAlias,
-  resolvePackageSpecifier,
-  sourceClientEntryReasons,
-  sourceUsesRegisteredRequestApi
-} from "./chunk-4P5CMIYT.js";
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/routes.ts
-import path4 from "node:path";
-import { existsSync as existsSync3 } from "node:fs";
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/source-text.ts
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-var disabled = process.env.PNEXT_SRC_CACHE === "0";
-var contents = /* @__PURE__ */ new Map();
-var inflight = /* @__PURE__ */ new Map();
-var scoped = false;
-var reads = 0;
-var hits = 0;
-function readSourceSync(file) {
-  if (!scoped) return readFileSync(file, "utf8");
-  const cached = contents.get(file);
-  if (cached !== void 0) {
-    hits += 1;
-    return cached;
-  }
-  reads += 1;
-  const source = readFileSync(file, "utf8");
-  contents.set(file, source);
-  return source;
-}
-async function readSourceText(file) {
-  if (!scoped) return readFile(file, "utf8");
-  const cached = contents.get(file);
-  if (cached !== void 0) {
-    hits += 1;
-    return cached;
-  }
-  const pending = inflight.get(file);
-  if (pending) {
-    hits += 1;
-    return pending;
-  }
-  reads += 1;
-  const read = (async () => {
-    try {
-      const source = await readFile(file, "utf8");
-      contents.set(file, source);
-      return source;
-    } finally {
-      inflight.delete(file);
-    }
-  })();
-  inflight.set(file, read);
-  return read;
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/css/build.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import { readFile as readFile2, rename, writeFile as writeFile2 } from "node:fs/promises";
-import path2 from "node:path";
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/asset-hash.ts
-import { createHash } from "node:crypto";
-function assetContentHash(bytes) {
-  return createHash("sha256").update(bytes).digest("hex").slice(0, 16);
-}
-function hashedAssetName(name, bytes) {
-  const hash = assetContentHash(bytes);
-  const dot = name.lastIndexOf(".");
-  return dot <= 0 ? `${name}-${hash}` : `${name.slice(0, dot)}-${hash}${name.slice(dot)}`;
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/css/postcss.ts
-import { createHash as createHash2 } from "node:crypto";
-import { createRequire } from "node:module";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  realpathSync,
-  renameSync,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-var tailwindScannerPatch = Symbol.for("pnext.tailwind-scanner-v1");
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/css/build.ts
-var cssRuntimeRegistered = false;
-function globalCssSources(config) {
-  return globalCssSourcesForPaths(config.root, config.appPath, config.workspaceRoot);
-}
-var globalCssSourceCache = /* @__PURE__ */ new Map();
-var globalCssStore;
-function globalCssSourcesForPaths(root, appPath, workspaceRoot) {
-  const key = `${root}\0${appPath}\0${workspaceRoot ?? ""}`;
-  const cached = globalCssSourceCache.get(key);
-  if (cached) return cached;
-  const stored = globalCssStore?.load(key);
-  if (stored) {
-    globalCssSourceCache.set(key, stored);
-    return stored;
-  }
-  const sources = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const missing = /* @__PURE__ */ new Set();
-  collectGlobalCssSources(
-    root,
-    rootLayoutFile(appPath, missing),
-    sources,
-    visited,
-    missing,
-    workspaceRoot
-  );
-  const resolved = [...sources].map((file) => path2.resolve(file));
-  globalCssSourceCache.set(key, resolved);
-  globalCssStore?.save(key, resolved, [...visited], [...missing]);
-  return resolved;
-}
-function collectGlobalCssSources(root, file, sources, visited, missing, workspaceRoot) {
-  const resolvedFile = path2.resolve(file);
-  if (visited.has(resolvedFile)) return;
-  if (!existsSync2(resolvedFile)) {
-    missing?.add(resolvedFile);
-    return;
-  }
-  visited.add(resolvedFile);
-  for (const specifier of moduleSpecifiers(readFileSync3(resolvedFile, "utf8"))) {
-    const resolved = resolveImport(root, resolvedFile, specifier, workspaceRoot);
-    if (!resolved) continue;
-    if (isCssFile(resolved)) {
-      sources.add(resolved);
-    } else {
-      collectGlobalCssSources(root, resolved, sources, visited, missing, workspaceRoot);
-    }
-  }
-}
-function rootLayoutFile(appPath, missing) {
-  for (const extension of ["tsx", "ts", "jsx", "js", "mjs", ...extraPageExtensions()]) {
-    const file = path2.join(appPath, `layout.${extension}`);
-    if (existsSync2(file)) return file;
-    missing?.add(file);
-  }
-  return path2.join(appPath, "layout.tsx");
-}
-function globalCssHref(config) {
-  return globalCssSources(config).length > 0 ? assetHref(config, "global.css") : void 0;
-}
-var emittedAssets = /* @__PURE__ */ new Map();
-function recordEmittedAsset(outPath, logical, emitted) {
-  const names = emittedAssets.get(outPath) ?? /* @__PURE__ */ new Map();
-  names.set(logical, emitted);
-  emittedAssets.set(outPath, names);
-}
-function publishEmittedAssets(outPath, names) {
-  if (!names) return;
-  for (const [logical, emitted] of Object.entries(names))
-    recordEmittedAsset(outPath, logical, emitted);
-}
-function emittedAssetName(config, name) {
-  if (!config?.outPath) return name;
-  return emittedAssets.get(config.outPath)?.get(name) ?? name;
-}
-function assetPathname(config, name) {
-  const emitted = emittedAssetName(config, name);
-  return nextCompatEnabled(config ?? {}) ? `/_next/static/${emitted}` : `/assets/${emitted}`;
-}
-function assetHref(config, name) {
-  return withAssetPrefix(config, assetPathname(config, name));
-}
-function routeCssAssetNames(route) {
-  if (route.cssImports.length === 0) return [];
-  return route.cssAssets?.length ? route.cssAssets : [`${route.id}.css`];
-}
-function routeCssHref(route, config) {
-  const assets = routeCssAssetNames(route);
-  if (assets.length === 0) return void 0;
-  return assets.map((asset) => assetHref(config, asset));
-}
-async function emitFontCssStylesheet(config, routeId2, fontCss, baseAsset, options) {
-  const outDir = path2.join(config.outPath, options.dev ? "cache" : "public", "assets");
-  await ensureDir(outDir);
-  const baseFile = baseAsset ? path2.join(outDir, baseAsset) : void 0;
-  const baseCss = baseFile && existsSync2(baseFile) ? await readFile2(baseFile, "utf8") : "";
-  const contents2 = [fontCss, baseCss].filter(Boolean).join("\n");
-  const logicalName = baseAsset ? baseAsset.replace(/-[0-9a-f]{16}(?=\.css$)/, "") : `${routeId2}.css`;
-  const name = hashedAssetName(logicalName, contents2);
-  const file = path2.join(outDir, name);
-  if (!existsSync2(file) || await readFile2(file, "utf8") !== contents2)
-    await writeFile2(file, contents2);
-  return name;
-}
-function withAssetPrefix(config, href) {
-  const prefix = config?.assetPrefix;
-  if (!prefix) return href;
-  return `${prefix.replace(/\/$/, "")}${href}`;
-}
-function moduleSpecifiers(source) {
-  const specifiers = [];
-  const pattern = /(?:import|export)\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+)['"]/g;
-  let match;
-  while (match = pattern.exec(source)) {
-    if (match[1]) specifiers.push(match[1]);
-  }
-  return specifiers;
-}
-function cssFileExtensions() {
-  return [".css", ...getCssExtensions().extraCssExtensions()];
-}
-function isCssFile(file) {
-  return cssFileExtensions().some((extension) => file.endsWith(extension));
-}
-function registerCssRuntime() {
-  if (cssRuntimeRegistered) return;
-  cssRuntimeRegistered = true;
-  Bun.plugin({
-    name: "pnext-css-runtime",
-    setup(plugin) {
-      plugin.onLoad(
-        { filter: /\.(?:css|scss|sass)$/ },
-        async ({ path: file }) => isCssModuleFile(file) ? {
-          exports: { default: await cssModuleMapping(file) },
-          loader: "object"
-        } : {
-          contents: "export default undefined;",
-          loader: "js"
-        }
-      );
-    }
-  });
-}
-function isCssModuleFile(file) {
-  return /\.module\.(?:css|scss|sass)$/.test(file);
-}
-var CSS_CONFIG_AT_RULES = /* @__PURE__ */ new Set(["source", "plugin", "config"]);
-function hoistCssImports(source) {
-  if (!/@(?:source|plugin|config)\b/.test(source)) return source;
-  const imports = [];
-  const others = [];
-  let charset = "";
-  let sawDirective = false;
-  let hoist = false;
-  let index = 0;
-  while (index < source.length) {
-    const code = source.charCodeAt(index);
-    if (code === 32 || code === 9 || code === 10 || code === 13 || code === 12) {
-      index += 1;
-      continue;
-    }
-    const char = source[index];
-    if (char === "/" && source[index + 1] === "*") {
-      const end2 = source.indexOf("*/", index + 2);
-      if (end2 === -1) break;
-      others.push(source.slice(index, end2 + 2));
-      index = end2 + 2;
-      continue;
-    }
-    const name = char === "@" ? /^@([\w-]+)/.exec(source.slice(index))?.[1] : void 0;
-    if (!name) break;
-    if (name !== "import" && name !== "charset" && !CSS_CONFIG_AT_RULES.has(name)) break;
-    const end = statementEnd(source, index);
-    if (end === -1) break;
-    const statement = source.slice(index, end);
-    if (name === "charset") charset ||= statement;
-    else if (name === "import") {
-      imports.push(statement);
-      if (sawDirective) hoist = true;
-    } else {
-      others.push(statement);
-      sawDirective = true;
-    }
-    index = end;
-  }
-  if (!hoist) return source;
-  return `${[charset, ...imports, ...others].filter(Boolean).join("\n")}
-${source.slice(index)}`;
-}
-function statementEnd(source, start) {
-  for (let index = start; index < source.length; index += 1) {
-    const char = source[index];
-    if (char === ";") return index + 1;
-    if (char === "{" || char === "}") return -1;
-    if (char === '"' || char === "'") {
-      index = skipString(source, index);
-      if (index === -1) return -1;
-    }
-  }
-  return -1;
-}
-function skipString(source, start) {
-  const quote = source[start];
-  for (let index = start + 1; index < source.length; index += 1) {
-    const char = source[index];
-    if (char === "\\") index += 1;
-    else if (char === quote) return index;
-  }
-  return -1;
-}
-async function cssModuleMapping(file) {
-  const compatMapping = getCssExtensions().resolveCssModule(file);
-  if (compatMapping) return compatMapping;
-  const source = await readText(file);
-  const classNames = cssClassNames(source);
-  return Object.fromEntries(
-    [...classNames].map((className) => [className, cssModuleClassName(file, className)])
-  );
-}
-function cssClassNames(source) {
-  const classNames = /* @__PURE__ */ new Set();
-  const classPattern = /(^|[^\\])\.(-?[_a-zA-Z][\w-]*)/g;
-  let match;
-  while (match = classPattern.exec(source)) {
-    if (match[2]) classNames.add(match[2]);
-  }
-  return classNames;
-}
-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 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);
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/slots.ts
-import path3 from "node:path";
-var pageExtensions = ["tsx", "ts", "jsx", "js", "mjs"];
-var interceptionMarkers = ["(..)(..)", "(...)", "(..)", "(.)"];
-var interceptionLevels = {
-  "(.)": 0,
-  "(..)": 1,
-  "(..)(..)": 2,
-  "(...)": Number.POSITIVE_INFINITY
-};
-function interceptionMarkerOf(segment) {
-  return interceptionMarkers.find(
-    (marker) => segment.startsWith(marker) && segment.length > marker.length
-  );
-}
-function interceptionMarkerLevels(marker) {
-  return interceptionLevels[marker];
-}
-function isSlotSegment(name) {
-  return name.startsWith("@");
-}
-function isGroupSegment(name) {
-  return name.startsWith("(") && name.endsWith(")") && !interceptionMarkerOf(name);
-}
-function slotConventionFile(dir, base) {
-  const { files } = readDirListing(dir);
-  for (const extension of pageExtensions) {
-    if (files.has(`${base}.${extension}`)) return path3.join(dir, `${base}.${extension}`);
-  }
-  return void 0;
-}
-function childDirectories(dir) {
-  return readDirListing(dir).dirs;
-}
-function slotDirectoriesIn(dir) {
-  return childDirectories(dir).filter(isSlotSegment).map((name) => path3.join(dir, name));
-}
-function consumedSegments(appPath, dir) {
-  const relative = path3.relative(appPath, dir);
-  if (relative.startsWith("..")) return 0;
-  let consumed = 0;
-  for (const name of relative.split(path3.sep).filter(Boolean)) {
-    if (isGroupSegment(name) || isSlotSegment(name)) continue;
-    const marker = interceptionMarkerOf(name);
-    const bare = marker ? name.slice(marker.length) : name;
-    if (/^\[\[?\.\.\./.test(bare)) return Number.POSITIVE_INFINITY;
-    consumed += 1;
-  }
-  return consumed;
-}
-function matchSegments(dir, segments, options = {}, params = {}, dirs = []) {
-  const children = childDirectories(dir);
-  const groups = children.filter(isGroupSegment);
-  if (segments.length === 0) {
-    const page = slotConventionFile(dir, "page");
-    if (page) return { file: page, dirs, params };
-    for (const group of groups) {
-      const match = matchSegments(path3.join(dir, group), [], options, params, [...dirs, group]);
-      if (match) return match;
-    }
-    for (const name of children) {
-      const param = optionalCatchAllName(bareName(name, options));
-      if (!param) continue;
-      const match = matchSegments(path3.join(dir, name), [], options, { ...params, [param]: [] }, [
-        ...dirs,
-        name
-      ]);
-      if (match) return match;
-    }
-    if (options.markersAsSegments && (slotConventionFile(dir, "layout") || children.some(isSlotSegment))) {
-      return { dirs, params };
-    }
-    return null;
-  }
-  const [head, ...rest] = segments;
-  for (const name of children) {
-    if (bareName(name, options) !== head) continue;
-    const match = matchSegments(path3.join(dir, name), rest, options, params, [...dirs, name]);
-    if (match) return match;
-  }
-  for (const group of groups) {
-    const match = matchSegments(path3.join(dir, group), segments, options, params, [...dirs, group]);
-    if (match) return match;
-  }
-  for (const name of children) {
-    const param = dynamicParamName(bareName(name, options));
-    if (!param) continue;
-    const match = matchSegments(
-      path3.join(dir, name),
-      rest,
-      options,
-      { ...params, [param]: safeDecode(head) },
-      [...dirs, name]
-    );
-    if (match) return match;
-  }
-  for (const name of children) {
-    const bare = bareName(name, options);
-    const param = catchAllName(bare) ?? optionalCatchAllName(bare);
-    if (!param) continue;
-    const match = matchSegments(
-      path3.join(dir, name),
-      [],
-      options,
-      { ...params, [param]: segments.map(safeDecode) },
-      [...dirs, name]
-    );
-    if (match) return match;
-  }
-  return null;
-}
-function bareName(name, options) {
-  if (isSlotSegment(name)) return "\0";
-  const marker = interceptionMarkerOf(name);
-  if (!marker) return name;
-  return options.markersAsSegments ? name.slice(marker.length) : "\0";
-}
-function dynamicParamName(name) {
-  const match = /^\[([^\].]+)\]$/.exec(name);
-  return match?.[1];
-}
-function catchAllName(name) {
-  const match = /^\[\.\.\.([^\]]+)\]$/.exec(name);
-  return match?.[1];
-}
-function optionalCatchAllName(name) {
-  const match = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(name);
-  return match?.[1];
-}
-function childrenDefaultFile(dir, segments) {
-  let current = dir;
-  let best = slotConventionFile(current, "default");
-  for (const segment of segments) {
-    const next = childSegmentDir(current, segment);
-    if (!next) break;
-    current = next;
-    best = slotConventionFile(current, "default") ?? best;
-  }
-  return best;
-}
-function childSegmentDir(dir, segment) {
-  const children = childDirectories(dir);
-  if (children.includes(segment)) return path3.join(dir, segment);
-  for (const group of children.filter(isGroupSegment)) {
-    const nested = childSegmentDir(path3.join(dir, group), segment);
-    if (nested) return nested;
-  }
-  const dynamic = children.find((name) => dynamicParamName(name));
-  if (dynamic) return path3.join(dir, dynamic);
-  return void 0;
-}
-function slotInterceptorUnits(appPath, slotDir) {
-  const owner = routeTokensForDir(appPath, path3.dirname(slotDir));
-  if (!owner) return [];
-  const units = [];
-  collectInterceptorUnits(slotDir, owner, [], units);
-  return units;
-}
-function collectInterceptorUnits(dir, owner, inner, units) {
-  for (const name of childDirectories(dir)) {
-    const child = path3.join(dir, name);
-    if (isSlotSegment(name) || isGroupSegment(name)) {
-      collectInterceptorUnits(child, owner, inner, units);
-      continue;
-    }
-    const marker = interceptionMarkerOf(name);
-    if (marker) {
-      const bare = name.slice(marker.length);
-      const levels = interceptionLevels[marker];
-      const context = [...owner, ...inner];
-      const kept = levels === Number.POSITIVE_INFINITY ? [] : context.slice(0, Math.max(0, context.length - levels));
-      const target = [...kept, segmentToken(bare)];
-      units.push({
-        dir: child,
-        targetSegments: target.map((token) => token.route),
-        targetPattern: target.map((token) => token.pattern).join("/"),
-        params: target.filter((token) => token.param).map((token) => ({ name: token.param, catchAll: Boolean(token.catchAll) })),
-        catchAllTail: Boolean(target[target.length - 1]?.catchAll)
-      });
-      continue;
-    }
-    collectInterceptorUnits(child, owner, [...inner, segmentToken(name)], units);
-  }
-}
-function routeTokensForDir(appPath, dir) {
-  const relative = path3.relative(appPath, dir);
-  if (relative.startsWith("..")) return void 0;
-  let tokens = [];
-  for (const name of toPosixPath(relative).split("/").filter(Boolean)) {
-    if (isGroupSegment(name) || isSlotSegment(name)) continue;
-    const marker = interceptionMarkerOf(name);
-    if (marker) {
-      const levels = interceptionLevels[marker];
-      tokens = levels === Number.POSITIVE_INFINITY ? [] : tokens.slice(0, Math.max(0, tokens.length - levels));
-      tokens.push(segmentToken(name.slice(marker.length)));
-      continue;
-    }
-    tokens.push(segmentToken(name));
-  }
-  return tokens;
-}
-function segmentToken(name) {
-  const optional = optionalCatchAllName(name);
-  if (optional) return { route: `:${optional}*`, pattern: "(.*)", param: optional, catchAll: true };
-  const catchAll = catchAllName(name);
-  if (catchAll) return { route: `:${catchAll}*`, pattern: "(.*)", param: catchAll, catchAll: true };
-  const param = dynamicParamName(name);
-  if (param) return { route: `:${param}`, pattern: "([^/]+)", param };
-  return { route: name, pattern: escapeRegex(name) };
-}
-function matchSlotInterceptor(appPath, slotDir, pathname) {
-  const segments = pathnameSegments(pathname);
-  const markerOwner = markerOwnerTokens(appPath, slotDir);
-  if (markerOwner) {
-    const params = matchTargetTokens(markerOwner, pathname);
-    if (params) {
-      const rest = markerOwner.at(-1)?.catchAll ? [] : segments.slice(markerOwner.length);
-      const inner = matchSegments(slotDir, rest, { markersAsSegments: true }, params, []);
-      if (inner) return inner;
-    }
-  }
-  const units = slotInterceptorUnits(appPath, slotDir).sort(
-    (a, b) => Number(a.catchAllTail) - Number(b.catchAllTail) || b.targetSegments.length - a.targetSegments.length || a.params.length - b.params.length
-  );
-  for (const unit of units) {
-    const regex = new RegExp(`^/${unit.targetPattern}(?:/(.*))?$`);
-    const match = regex.exec(pathname.replace(/\/+$/, "") || "/");
-    if (!match) continue;
-    const params = {};
-    unit.params.forEach((param, index) => {
-      const value = match[index + 1] ?? "";
-      params[param.name] = param.catchAll ? value.split("/").filter(Boolean).map(safeDecode) : safeDecode(value);
-    });
-    const rest = unit.catchAllTail ? [] : segments.slice(unit.targetSegments.length);
-    const inner = matchSegments(unit.dir, rest, { markersAsSegments: true }, params, []);
-    if (inner) {
-      return {
-        file: inner.file,
-        dirs: [path3.basename(unit.dir), ...inner.dirs],
-        params: inner.params
-      };
-    }
-  }
-  return null;
-}
-function markerOwnerTokens(appPath, slotDir) {
-  const relative = path3.relative(appPath, slotDir);
-  if (relative.startsWith("..")) return null;
-  const segments = toPosixPath(relative).split("/").filter(Boolean);
-  const markerIndex = segments.findIndex((segment) => Boolean(interceptionMarkerOf(segment)));
-  if (markerIndex === -1) return null;
-  return routeTokensForDir(appPath, path3.join(appPath, ...segments.slice(0, markerIndex + 1))) ?? null;
-}
-function matchTargetTokens(tokens, pathname) {
-  const pattern = tokens.map((token) => token.pattern).join("/");
-  const regex = new RegExp(`^/${pattern}(?:/.*)?$`);
-  const match = regex.exec(pathname.replace(/\/+$/, "") || "/");
-  if (!match) return null;
-  const params = {};
-  tokens.filter((token) => token.param).forEach((token, index) => {
-    const value = match[index + 1] ?? "";
-    params[token.param] = token.catchAll ? value.split("/").filter(Boolean).map(safeDecode) : safeDecode(value);
-  });
-  return params;
-}
-function pathnameSegments(pathname) {
-  return pathname.split("?")[0].split("/").filter(Boolean);
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/routes.ts
-var BASE_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js", "mjs"];
-var BASE_ROUTE_HANDLER_EXTENSIONS = ["ts", "tsx", "js", "mjs"];
-function pageExtensions2() {
-  return [.../* @__PURE__ */ new Set([...BASE_PAGE_EXTENSIONS, ...extraPageExtensions()])];
-}
-function routeHandlerExtensions() {
-  return BASE_ROUTE_HANDLER_EXTENSIONS;
-}
-function allFileExtensions() {
-  return [.../* @__PURE__ */ new Set([...pageExtensions2(), ...routeHandlerExtensions()])];
-}
-var componentConventions = ["loading", "error", "not-found"];
-function boundaryConventions() {
-  return [...componentConventions, ...extraBoundaryConventionNames()];
-}
-var globalErrorBase = "global-error";
-var memoPageFile;
-var memoRouteFilePattern;
-var memoDefaultConventionPattern;
-var memoMetadataCodeFilePattern;
-var memoPageOrRouteTrailing;
-var memoSlotConventionPattern;
-var memoExtensionsKey;
-function freshMemos() {
-  const key = extraPageExtensions().join(",");
-  if (key === memoExtensionsKey) return;
-  memoExtensionsKey = key;
-  memoPageFile = void 0;
-  memoRouteFilePattern = void 0;
-  memoDefaultConventionPattern = void 0;
-  memoMetadataCodeFilePattern = void 0;
-  memoPageOrRouteTrailing = void 0;
-  memoSlotConventionPattern = void 0;
-}
-function pageFile() {
-  freshMemos();
-  return memoPageFile ??= extensionRegex("page", pageExtensions2());
-}
-function routeFilePattern() {
-  freshMemos();
-  return memoRouteFilePattern ??= extensionRegex("route", routeHandlerExtensions());
-}
-function defaultConventionPattern() {
-  freshMemos();
-  return memoDefaultConventionPattern ??= extensionRegex("default", pageExtensions2());
-}
-function metadataCodeFilePattern() {
-  freshMemos();
-  return memoMetadataCodeFilePattern ??= new RegExp(
-    `(^|/)(robots|sitemap|manifest|icon\\d*|apple-icon\\d*|opengraph-image\\d*|twitter-image\\d*)\\.(${allFileExtensions().join(
-      "|"
-    )})$`
-  );
-}
-function pageOrRouteTrailing() {
-  freshMemos();
-  return memoPageOrRouteTrailing ??= new RegExp(
-    `/?(page|route|layout|template|loading|error|not-found|forbidden|unauthorized|default|global-error)\\.(${allFileExtensions().join(
-      "|"
-    )})$`
-  );
-}
-function slotConventionPattern() {
-  freshMemos();
-  return memoSlotConventionPattern ??= new RegExp(
-    `(^|/)(page|layout|template|loading|error|default|not-found)\\.(${pageExtensions2().join("|")})$`
-  );
-}
-function extensionRegex(base, extensions) {
-  return new RegExp(`(^|/)${escapeRegex2(base)}\\.(${extensions.join("|")})$`);
-}
-function conventionFileName(dir, base) {
-  const { files } = readDirListing(dir);
-  for (const extension of pageExtensions2()) {
-    if (files.has(`${base}.${extension}`)) return path4.join(dir, `${base}.${extension}`);
-  }
-  return void 0;
-}
-function createScanContext(appPath, globalCss, workspaceRoot) {
-  const root = rootFromAppPath(appPath);
-  let memo;
-  return {
-    root,
-    workspaceRoot,
-    appPath,
-    sources: /* @__PURE__ */ new Map(),
-    edges: /* @__PURE__ */ new Map(),
-    requestImportUsage: /* @__PURE__ */ new Map(),
-    exists: /* @__PURE__ */ new Map(),
-    useClient: /* @__PURE__ */ new Map(),
-    usesLink: /* @__PURE__ */ new Map(),
-    usesNavigation: /* @__PURE__ */ new Map(),
-    entryReasons: /* @__PURE__ */ new Map(),
-    globalCssImports: globalCss ?? (() => memo ??= new Set(globalCssSourcesForPaths(root, appPath, workspaceRoot)))
-  };
-}
-function fileExists(context, file) {
-  let hit = context.exists.get(file);
-  if (hit === void 0) {
-    hit = existsSync3(file);
-    context.exists.set(file, hit);
-  }
-  return hit;
-}
-var routeHandlerMethods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
-var deferredFields = [
-  "mode",
-  "hasStaticParams",
-  "usesRequest",
-  "handlerUsesRevalidationApi",
-  "dynamicErrorApi",
-  "client",
-  "clientReferences",
-  "cssImports",
-  "sourceFiles",
-  "serverActionFile",
-  "stream",
-  "maxDuration",
-  "ppr",
-  "segmentConfig",
-  "needsRouterEntry",
-  "clientEntryReasons"
-];
-var resolvedRoutes = /* @__PURE__ */ new WeakSet();
-var factsVersion = 0;
-function routeFactsVersion() {
-  return factsVersion;
-}
-function routeFactsResolved(route) {
-  return resolvedRoutes.has(route);
-}
-function materializeRouteFacts(routes, onRoute) {
-  for (const route of routes) {
-    void route.sourceFiles;
-    onRoute?.(route);
-  }
-  return routes;
-}
-async function materializeRouteFactsPaced(routes, pause) {
-  for (const route of routes) {
-    await pause();
-    void route.sourceFiles;
-  }
-  return routes;
-}
-var factsStore;
-function setRouteFactsStore(store) {
-  factsStore = store;
-}
-function withDeferredFacts(appPath, base, compute) {
-  const entry = base;
-  let facts;
-  const overrides = /* @__PURE__ */ new Map();
-  for (const field of deferredFields) {
-    Object.defineProperty(entry, field, {
-      enumerable: true,
-      configurable: true,
-      get() {
-        if (overrides.has(field)) return overrides.get(field);
-        if (!facts) {
-          const key = `${appPath}\0${base.kind}:${base.id}`;
-          const stored = factsStore?.load(key);
-          facts = stored ?? withDirCache(compute);
-          if (!stored) factsStore?.save(key, facts);
-          resolvedRoutes.add(entry);
-          factsVersion += 1;
-        }
-        return facts[field];
-      },
-      set(value) {
-        overrides.set(field, value);
-      }
-    });
-  }
-  return entry;
-}
-async function scanRoutes(appPath, workspaceRoot) {
-  const files = await listFiles(appPath);
-  return withDirCache(() => buildRouteTable(appPath, files, workspaceRoot));
-}
-function buildRouteTable(appPath, files, workspaceRoot) {
-  const context = createScanContext(appPath, void 0, workspaceRoot);
-  const routes = [];
-  const slotPageFiles = [];
-  const defaultPageFiles = [];
-  const table = { parallelRoutes: false };
-  for (const file of files) {
-    const relative = toPosixPath(path4.relative(appPath, file));
-    const routeFile = path4.join(appPath, relative);
-    if (defaultConventionPattern().test(relative) && !relative.split("/").some((segment) => segment.startsWith("@"))) {
-      defaultPageFiles.push({ file, relative });
-    }
-    if (isPrivateAppPath(relative)) continue;
-    if (!pageFile().test(relative) && !routeFilePattern().test(relative)) {
-      if (!metadataCodeFilePattern().test(relative)) continue;
-      const source = readSource(context, file);
-      const metadataParts = dynamicMetadataRouteParts(relative, source);
-      if (!metadataParts) continue;
-      routes.push(
-        withDeferredFacts(
-          appPath,
-          {
-            id: `metadata-${routeId(metadataParts.route)}`,
-            kind: "handler",
-            route: metadataParts.route,
-            pattern: metadataParts.pattern,
-            file,
-            params: metadataParts.params,
-            catchAll: metadataParts.catchAll,
-            ...metadataParts.catchAllOptional ? { catchAllOptional: true } : {},
-            metadataRoute: metadataParts.metadataRoute
-          },
-          () => metadataRouteFacts(context, routeFile, metadataParts)
-        )
-      );
-      continue;
-    }
-    if (relative.split("/").some((segment) => segment.startsWith("@"))) {
-      if (pageFile().test(relative)) slotPageFiles.push({ file, relative });
-      continue;
-    }
-    const kind = pageFile().test(relative) ? "page" : "handler";
-    const routeDir = relative.replace(pageOrRouteTrailing(), "");
-    const parts = routeParts(routeDir);
-    const conventions = conventionPaths(appPath, routeFile, kind);
-    const templatePaths = conventions.templateFiles.filter((item) => existsSync3(item));
-    const extraBoundaries = new Set(extraBoundaryConventionNames());
-    const forbiddenPaths = kind === "page" && extraBoundaries.has("forbidden") ? findConventionFiles(appPath, routeFile, "forbidden").filter((item) => existsSync3(item)) : [];
-    const unauthorizedPaths = kind === "page" && extraBoundaries.has("unauthorized") ? findConventionFiles(appPath, routeFile, "unauthorized").filter((item) => existsSync3(item)) : [];
-    const interception = parts.interception;
-    routes.push(
-      withDeferredFacts(
-        appPath,
-        {
-          id: interception ? `intercept-${sanitizeIdPart(routeDir)}` : routeId(parts.route || "/"),
-          kind,
-          route: parts.route,
-          pattern: parts.pattern,
-          file,
-          params: parts.params,
-          catchAll: parts.catchAll,
-          ...parts.catchAllOptional ? { catchAllOptional: true } : {},
-          ...templatePaths.length > 0 ? { templateFiles: templatePaths } : {},
-          ...forbiddenPaths.length > 0 ? { forbiddenFiles: forbiddenPaths } : {},
-          ...unauthorizedPaths.length > 0 ? { unauthorizedFiles: unauthorizedPaths } : {},
-          ...conventions.slotDirs.length > 0 ? { slotDirs: conventions.slotDirs } : {},
-          ...interception ? { interception } : {}
-        },
-        () => pageOrHandlerFacts(context, { kind, routeFile, parts, conventions, table })
-      )
-    );
-  }
-  appendSlotDerivedRoutes(context, routes, slotPageFiles, table);
-  appendDefaultDerivedRoutes(context, routes, defaultPageFiles, table);
-  table.parallelRoutes = routes.some((route) => route.slotDirs?.length || route.interception);
-  return routes.sort((a, b) => routeRank(a).localeCompare(routeRank(b)));
-}
-function conventionPaths(appPath, routeFile, kind) {
-  if (kind !== "page") {
-    return { layoutFiles: [], templateFiles: [], specialFiles: [], slotDirs: [], slotFiles: [] };
-  }
-  const slotDirs = chainSlotDirs(appPath, routeFile);
-  return {
-    layoutFiles: findLayouts(appPath, routeFile),
-    templateFiles: findConventionFiles(appPath, routeFile, "template"),
-    specialFiles: boundaryConventions().flatMap(
-      (name) => findConventionFiles(appPath, routeFile, name)
-    ),
-    slotDirs,
-    slotFiles: slotTreeFiles(slotDirs)
-  };
-}
-function metadataRouteFacts(context, routeFile, parts) {
-  const source = readSource(context, routeFile);
-  const sourceFiles = collectSourceFiles(context, [routeFile]);
-  const dependency = routeDependencyClassification(context, "handler", sourceFiles);
-  const usesRequest = metadataRouteUsesRequest(source) || usesRevalidationApis(source) || dependency.usesRequest === true || usesRequestImportDataForFiles(
-    context,
-    sourceFiles.filter((file) => !isAssetFile(file))
-  );
-  const segmentConfig = segmentConfigFromEntries(
-    context.appPath,
-    [{ file: routeFile, source }],
-    parts
-  );
-  return {
-    mode: inferRouteMode(parts, usesRequest, segmentConfig),
-    hasStaticParams: Boolean(parts.metadataRoute.generatedParam),
-    usesRequest,
-    client: false,
-    clientReferences: [],
-    cssImports: [],
-    sourceFiles,
-    maxDuration: maxDurationFromSources([source]),
-    ...segmentConfig ? { segmentConfig } : {}
-  };
-}
-function pageOrHandlerFacts(context, options) {
-  const { appPath } = context;
-  const { kind, routeFile, parts, conventions, table } = options;
-  const { layoutFiles, templateFiles, specialFiles, slotFiles } = conventions;
-  const source = readScanSource(context, routeFile);
-  const layoutSources = [...layoutFiles, ...templateFiles, ...specialFiles].filter((item) => existsSync3(item)).map((item) => readScanSource(context, item));
-  const entryFiles = [routeFile, ...layoutFiles, ...templateFiles, ...specialFiles, ...slotFiles];
-  const sourceFiles = collectSourceFiles(context, entryFiles);
-  const dependency = routeDependencyClassification(context, kind, sourceFiles);
-  const handlerUsesRevalidationApi = kind === "handler" && usesRevalidationApis(source);
-  const usesRequest = kind === "handler" ? routeHandlerUsesRequest(source) || handlerUsesRevalidationApi || dependency.usesRequest === true : [source, ...layoutSources].some(usesRequestData) || dependency.usesRequest === true;
-  const existingLayoutFiles = layoutFiles.filter((item) => existsSync3(item));
-  const configEntries = [
-    { file: routeFile, source },
-    ...[...existingLayoutFiles].reverse().map((item) => ({
-      file: item,
-      source: readScanSource(context, item)
-    }))
-  ];
-  const segmentConfig = segmentConfigFromEntries(appPath, configEntries, parts);
-  if (segmentConfig?.dynamicParamsFalse?.length) {
-    const allDynamicParams = [...parts.params, ...parts.catchAll ? [parts.catchAll] : []];
-    const coveredParams = /* @__PURE__ */ new Set();
-    for (const entry of configEntries) {
-      if (!hasStaticParamsExport(entry.source)) continue;
-      const covered = paramOfOwnSegment(appPath, entry.file, allDynamicParams);
-      if (covered) coveredParams.add(covered);
-    }
-    if (allDynamicParams.some((param) => !coveredParams.has(param))) {
-      delete segmentConfig.dynamicParamsFalse;
-    } else if (hasStaticParamsExport(source)) {
-      segmentConfig.strictDynamicParams = true;
-    }
-  }
-  const hasStaticParams = hasStaticParamsExport(source) || kind === "page" && existingLayoutFiles.map((item) => readScanSource(context, item)).some(hasStaticParamsExport);
-  const dynamicErrorApi = segmentConfig?.dynamic === "error" && parts.params.length === 0 && !parts.catchAll && !hasStaticParams ? dynamicApiLabel(kind === "handler" ? [source] : [source, ...layoutSources], kind) : void 0;
-  const ppr = kind === "page" && usesRequest && parts.params.length === 0 && !parts.catchAll && exportsExperimentalPpr([source, ...layoutSources]);
-  const directClient = kind === "page" && hasUseClientDirective(routeFile, source);
-  const clientReferences = kind === "page" ? collectClientReferences(
-    context,
-    directClient ? [...layoutFiles, ...templateFiles, ...specialFiles, ...slotFiles] : entryFiles
-  ) : [];
-  const client = directClient || clientReferences.some(
-    (reference) => reference.file === routeFile && reference.exportName === "default"
-  );
-  const stream = kind === "page" ? routeStreamMetadata({ context, layoutFiles, templateFiles, specialFiles }) : void 0;
-  const cssImports = kind === "page" ? collectCssImports(
-    context,
-    cssEntryOrder({ routeFile, layoutFiles, templateFiles, specialFiles, slotFiles }),
-    { route: true }
-  ) : [];
-  if (kind === "page") attachLazyReferenceCss(context, clientReferences);
-  const interception = parts.interception;
-  return {
-    mode: interception ? "dynamic" : inferRouteMode(parts, usesRequest, segmentConfig),
-    hasStaticParams: interception ? false : hasStaticParams,
-    usesRequest,
-    ...handlerUsesRevalidationApi ? { handlerUsesRevalidationApi: true } : {},
-    ...dynamicErrorApi ? { dynamicErrorApi } : {},
-    client,
-    clientReferences,
-    cssImports,
-    sourceFiles,
-    ...kind === "page" ? serverActionFileFact(context, sourceFiles) : {},
-    ...stream ? { stream } : {},
-    maxDuration: maxDurationFromSources([source, ...layoutSources]),
-    ppr: interception ? false : ppr,
-    ...segmentConfig ? { segmentConfig } : {},
-    ...routerEntryFact(context, {
-      kind,
-      client,
-      clientReferences,
-      sourceFiles,
-      // Only slot-derived interception entries carry a slotDir.
-      slotInterceptor: false,
-      table
-    })
-  };
-}
-function routerEntryFact(context, options) {
-  if (options.kind !== "page") return {};
-  const reasons = [];
-  if (options.table.parallelRoutes && !options.slotInterceptor) reasons.push("parallel-routes");
-  reasons.push(...alwaysClientEntryReasons());
-  if (!options.client && options.clientReferences.length === 0) {
-    if (routeUsesLinkComponent(context, options.sourceFiles)) reasons.push("link");
-  } else if (routeUsesNavigation(context, options.sourceFiles)) {
-    reasons.push("router-api");
-  }
-  reasons.push(...routeClientEntryReasons(context, options.sourceFiles));
-  if (reasons.length === 0) return {};
-  return { needsRouterEntry: true, clientEntryReasons: [...new Set(reasons)] };
-}
-function addClientEntryReason(route, reason) {
-  const reasons = route.clientEntryReasons ?? [];
-  if (!reasons.includes(reason)) route.clientEntryReasons = [...reasons, reason];
-  route.needsRouterEntry = true;
-}
-function routeStreamMetadata(options) {
-  const existingSpecialFiles = options.specialFiles.filter((item) => existsSync3(item));
-  const hasLoadingBoundary = existingSpecialFiles.some(
-    (file) => /(^|[/\\])loading\.[^.]+$/.test(file)
-  );
-  const ancestorClientReferences = collectClientReferences(options.context, [
-    ...options.layoutFiles,
-    ...options.templateFiles
-  ]);
-  return {
-    ...hasLoadingBoundary ? { hasLoadingBoundary } : {},
-    ...ancestorClientReferences.length > 0 ? { ancestorClientReferences: ancestorClientReferences.map((reference) => reference.id) } : {}
-  };
-}
-function hasStaticParamsExport(source) {
-  const searchable = stripCommentsAndStrings(source);
-  return /\bexport\s+(?:async\s+)?function\s+(?:params|generateStaticParams)\b/.test(searchable) || /\bexport\s+const\s+(?:params|generateStaticParams)\b/.test(searchable);
-}
-function chainSlotDirs(appPath, routeFilePath) {
-  const dirs = [];
-  let dir = path4.dirname(routeFilePath);
-  while (dir.startsWith(appPath)) {
-    dirs.push(...slotDirectoriesIn(dir));
-    if (dir === appPath) break;
-    dir = path4.dirname(dir);
-  }
-  return dirs.reverse();
-}
-function slotTreeFiles(slotDirs) {
-  const files = [];
-  const pattern = slotConventionPattern();
-  for (const dir of slotDirs) {
-    for (const file of listFilesSync(dir)) {
-      if (pattern.test(toPosixPath(file))) files.push(file);
-    }
-  }
-  return files;
-}
-function appendSlotDerivedRoutes(context, routes, slotPages, table) {
-  const appPath = context.appPath;
-  const patterns = new Set(routes.filter((route) => !route.interception).map((route) => route.pattern));
-  const interceptionKeys = new Set(
-    routes.filter((route) => route.interception).map((route) => `${route.pattern}#${route.interception.base}`)
-  );
-  const candidates = slotPages.map(({ file, relative }) => {
-    const segments = relative.split("/");
-    const slotIndex = segments.findIndex(isSlotSegment);
-    const slotDir = path4.join(appPath, ...segments.slice(0, slotIndex + 1));
-    return {
-      file,
-      relative,
-      slotDir,
-      ownerDir: path4.dirname(slotDir),
-      parts: routeParts(relative.replace(pageOrRouteTrailing(), "")),
-      innerNames: segments.slice(slotIndex + 1, -1).filter((name) => !isSlotSegment(name) && !isGroupSegment(name))
-    };
-  }).sort((a, b) => b.ownerDir.length - a.ownerDir.length);
-  for (const candidate of candidates) {
-    const { parts } = candidate;
-    if (parts.interception) {
-      const key = `${parts.pattern}#${parts.interception.base}`;
-      if (interceptionKeys.has(key)) continue;
-      interceptionKeys.add(key);
-      routes.push(
-        withDeferredFacts(
-          appPath,
-          {
-            id: `intercept-${sanitizeIdPart(candidate.relative.replace(pageOrRouteTrailing(), ""))}`,
-            kind: "page",
-            route: parts.route,
-            pattern: parts.pattern,
-            file: candidate.file,
-            params: parts.params,
-            catchAll: parts.catchAll,
-            ...parts.catchAllOptional ? { catchAllOptional: true } : {},
-            interception: { ...parts.interception, slotDir: candidate.slotDir }
-          },
-          () => ({
-            ...emptyDerivedFacts,
-            ...routerEntryFact(context, {
-              kind: "page",
-              client: false,
-              clientReferences: [],
-              sourceFiles: [],
-              slotInterceptor: true,
-              table
-            })
-          })
-        )
-      );
-      continue;
-    }
-    if (patterns.has(parts.pattern)) continue;
-    patterns.add(parts.pattern);
-    const childrenDefault = childrenDefaultFile(candidate.ownerDir, candidate.innerNames);
-    const anchor = childrenDefault ?? slotConventionFile(path4.join(candidate.ownerDir, "@children"), "page") ?? slotConventionFile(candidate.ownerDir, "page") ?? candidate.file;
-    const layoutFiles = findLayouts(appPath, anchor);
-    const templateFiles = findConventionFiles(appPath, anchor, "template");
-    const specialFiles = boundaryConventions().flatMap(
-      (name) => findConventionFiles(appPath, anchor, name)
-    );
-    const slotDirs = chainSlotDirs(appPath, anchor);
-    const slotFiles = slotTreeFiles(slotDirs);
-    const extraBoundaries = new Set(extraBoundaryConventionNames());
-    const forbiddenPaths = extraBoundaries.has("forbidden") ? findConventionFiles(appPath, anchor, "forbidden").filter((item) => existsSync3(item)) : [];
-    const unauthorizedPaths = extraBoundaries.has("unauthorized") ? findConventionFiles(appPath, anchor, "unauthorized").filter((item) => existsSync3(item)) : [];
-    const templatePaths = templateFiles.filter((item) => existsSync3(item));
-    routes.push(
-      withDeferredFacts(
-        appPath,
-        {
-          id: `slot-${routeId(parts.route || "/")}`,
-          kind: "page",
-          route: parts.route,
-          pattern: parts.pattern,
-          file: anchor,
-          params: parts.params,
-          catchAll: parts.catchAll,
-          ...parts.catchAllOptional ? { catchAllOptional: true } : {},
-          ...templatePaths.length > 0 ? { templateFiles: templatePaths } : {},
-          ...slotDirs.length > 0 ? { slotDirs } : {},
-          synthetic: true,
-          syntheticSlotDir: candidate.slotDir,
-          ...childrenDefault ? { childrenDefault } : {},
-          ...forbiddenPaths.length > 0 ? { forbiddenFiles: forbiddenPaths } : {},
-          ...unauthorizedPaths.length > 0 ? { unauthorizedFiles: unauthorizedPaths } : {}
-        },
-        () => derivedRouteFacts(context, {
-          leadFiles: childrenDefault ? [childrenDefault] : [],
-          layoutFiles,
-          templateFiles,
-          specialFiles,
-          slotFiles,
-          clientFile: childrenDefault,
-          table
-        })
-      )
-    );
-  }
-}
-var emptyDerivedFacts = {
-  mode: "dynamic",
-  hasStaticParams: false,
-  usesRequest: true,
-  client: false,
-  clientReferences: [],
-  cssImports: [],
-  sourceFiles: []
-};
-function derivedRouteFacts(context, options) {
-  const { leadFiles, layoutFiles, templateFiles, specialFiles, slotFiles } = options;
-  const entryFiles = [...leadFiles, ...layoutFiles, ...templateFiles, ...specialFiles, ...slotFiles];
-  const sourceFiles = collectSourceFiles(context, entryFiles);
-  const clientReferences = collectClientReferences(context, entryFiles);
-  const cssImports = collectCssImports(
-    context,
-    cssEntryOrder({
-      ...options.leadIsRouteFile ? { routeFile: leadFiles[0] } : { leadFiles },
-      layoutFiles,
-      templateFiles,
-      specialFiles,
-      slotFiles
-    }),
-    { route: true }
-  );
-  attachLazyReferenceCss(context, clientReferences);
-  const client = options.clientFile ? isClientModule(context, options.clientFile) : false;
-  return {
-    ...emptyDerivedFacts,
-    client,
-    clientReferences,
-    cssImports,
-    sourceFiles,
-    ...routerEntryFact(context, {
-      kind: "page",
-      client,
-      clientReferences,
-      sourceFiles,
-      slotInterceptor: false,
-      table: options.table
-    })
-  };
-}
-function appendDefaultDerivedRoutes(context, routes, defaultPages, table) {
-  const appPath = context.appPath;
-  const patterns = new Set(routes.filter((route) => !route.interception).map((route) => route.pattern));
-  for (const { file, relative } of defaultPages) {
-    const dir = path4.dirname(file);
-    if (conventionFileName(dir, "page")) continue;
-    const parts = routeParts(relative.replace(pageOrRouteTrailing(), ""));
-    if (parts.interception) continue;
-    if (patterns.has(parts.pattern)) continue;
-    patterns.add(parts.pattern);
-    const layoutFiles = findLayouts(appPath, file);
-    const templateFiles = findConventionFiles(appPath, file, "template");
-    const specialFiles = boundaryConventions().flatMap(
-      (name) => findConventionFiles(appPath, file, name)
-    );
-    const slotDirs = chainSlotDirs(appPath, file);
-    const slotFiles = slotTreeFiles(slotDirs);
-    const extraBoundaries = new Set(extraBoundaryConventionNames());
-    const forbiddenPaths = extraBoundaries.has("forbidden") ? findConventionFiles(appPath, file, "forbidden").filter((item) => existsSync3(item)) : [];
-    const unauthorizedPaths = extraBoundaries.has("unauthorized") ? findConventionFiles(appPath, file, "unauthorized").filter((item) => existsSync3(item)) : [];
-    const templatePaths = templateFiles.filter((item) => existsSync3(item));
-    routes.push(
-      withDeferredFacts(
-        appPath,
-        {
-          id: `default-${routeId(parts.route || "/")}`,
-          kind: "page",
-          route: parts.route,
-          pattern: parts.pattern,
-          file,
-          params: parts.params,
-          catchAll: parts.catchAll,
-          ...parts.catchAllOptional ? { catchAllOptional: true } : {},
-          ...templatePaths.length > 0 ? { templateFiles: templatePaths } : {},
-          ...slotDirs.length > 0 ? { slotDirs } : {},
-          ...forbiddenPaths.length > 0 ? { forbiddenFiles: forbiddenPaths } : {},
-          ...unauthorizedPaths.length > 0 ? { unauthorizedFiles: unauthorizedPaths } : {}
-        },
-        () => derivedRouteFacts(context, {
-          leadFiles: [file],
-          leadIsRouteFile: true,
-          layoutFiles,
-          templateFiles,
-          specialFiles,
-          slotFiles,
-          clientFile: file,
-          table
-        })
-      )
-    );
-  }
-}
-function findLayouts(appPath, routeFilePath) {
-  return findConventionFiles(appPath, routeFilePath, "layout");
-}
-async function collectNotFoundCss(appPath) {
-  const notFoundFile = conventionFileName(appPath, "not-found");
-  if (!notFoundFile) return [];
-  return collectFileCss(appPath, [notFoundFile]);
-}
-async function collectFileCss(appPath, files, options = {}) {
-  const existing = files.filter((file) => existsSync3(file));
-  if (existing.length === 0) return [];
-  const context = createScanContext(
-    appPath,
-    options.includeGlobalCss ? () => /* @__PURE__ */ new Set() : void 0
-  );
-  return collectCssImports(context, existing);
-}
-function findConventionFiles(appPath, routeFilePath, name) {
-  const base = conventionBase(name);
-  const files = [];
-  let dir = path4.dirname(routeFilePath);
-  while (dir.startsWith(appPath)) {
-    files.push(conventionFileName(dir, base) ?? path4.join(dir, `${base}.tsx`));
-    if (dir === appPath) break;
-    dir = path4.dirname(dir);
-  }
-  return files.reverse();
-}
-function conventionBase(name) {
-  const match = new RegExp(`\\.(${pageExtensions2().join("|")})$`).exec(name);
-  return match ? name.slice(0, -match[0].length) : name;
-}
-function findGlobalError(appPath) {
-  return conventionFileName(appPath, globalErrorBase);
-}
-function matchRoute(routes, pathname) {
-  const normalized = normalizePathname(pathname);
-  for (const route of routes) {
-    if (route.interception) continue;
-    const match = routeRegex(route).exec(normalized);
-    if (!match) continue;
-    return { route, params: routeMatchParams(route, match) };
-  }
-  return null;
-}
-function normalizePathname(pathname) {
-  return pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
-}
-function routeMatchParams(route, match) {
-  const params = {};
-  route.params.forEach((name, index) => {
-    const decoded = safeDecode(match[index + 1] ?? "");
-    params[name] = decoded === `[${name}]` ? encodeURIComponent(decoded) : decoded;
-  });
-  if (route.catchAll) {
-    params[route.catchAll] = (match[route.params.length + 1] ?? "").split("/").filter(Boolean).map(safeDecode);
-  }
-  return params;
-}
-function matchInterception(routes, pathname, fromPath) {
-  if (!fromPath) return null;
-  const target = normalizePathname(pathname);
-  const from = normalizePathname(fromPath);
-  if (target === from) return null;
-  let best = null;
-  let bestDepth = -1;
-  for (const route of routes) {
-    const interception = route.interception;
-    if (!interception) continue;
-    const match = routeRegex(route).exec(target);
-    if (!match) continue;
-    const basePattern = interception.basePattern ? `/${interception.basePattern}` : "";
-    if (!new RegExp(`^${basePattern}(?:/.*)?$`).test(from)) continue;
-    const depth = interception.base.split("/").filter(Boolean).length;
-    if (depth <= bestDepth) continue;
-    bestDepth = depth;
-    best = { route, params: routeMatchParams(route, match) };
-  }
-  return best;
-}
-function selectRouteForRequest(routes, pathname, nav) {
-  const target = normalizePathname(pathname);
-  if (nav) {
-    const intercepted = matchInterception(routes, target, nav.children);
-    if (intercepted) {
-      if (!intercepted.route.interception?.slotDir) {
-        return {
-          route: intercepted.route,
-          params: intercepted.params,
-          childrenPath: target,
-          targetPath: target
-        };
-      }
-      const host = hostMatch(routes, nav.children);
-      if (host) return { ...host, targetPath: target };
-    }
-  }
-  const matched = matchRoute(routes, target);
-  if (!matched) return null;
-  if (nav && matched.route.synthetic && nav.children) {
-    const primary = matchRoute(
-      routes.filter((route) => !route.synthetic),
-      target
-    );
-    const syntheticOwner = matched.route.syntheticSlotDir ? path4.dirname(matched.route.syntheticSlotDir) : void 0;
-    const primaryFromOwner = primary && syntheticOwner ? path4.relative(syntheticOwner, primary.route.file) : void 0;
-    if (primary && primaryFromOwner !== void 0 && primaryFromOwner !== ".." && !primaryFromOwner.startsWith(`..${path4.sep}`)) {
-      return {
-        route: primary.route,
-        params: primary.params,
-        childrenPath: target,
-        targetPath: target
-      };
-    }
-    const host = hostMatch(routes, nav.children);
-    if (host && host.route !== matched.route && matched.route.syntheticSlotDir && host.route.slotDirs?.includes(matched.route.syntheticSlotDir)) {
-      return { ...host, targetPath: target };
-    }
-  }
-  return {
-    route: matched.route,
-    params: matched.params,
-    childrenPath: target,
-    targetPath: target
-  };
-}
-function parseNavState(request) {
-  if (!request.headers.get("x-pnext-soft-nav")) return void 0;
-  const raw = request.headers.get("x-pnext-nav-state");
-  if (!raw) return {};
-  try {
-    const parsed = JSON.parse(decodeURIComponent(raw));
-    if (parsed && typeof parsed === "object") return parsed;
-  } catch {
-  }
-  return {};
-}
-function hostMatch(routes, fromPath) {
-  if (!fromPath) return null;
-  const from = normalizePathname(fromPath);
-  const host = matchRoute(routes, from);
-  if (host?.route.kind !== "page") return null;
-  return { route: host.route, params: host.params, childrenPath: from, targetPath: from };
-}
-var routeRegexCache = /* @__PURE__ */ new WeakMap();
-function routeRegex(route) {
-  let regex = routeRegexCache.get(route);
-  if (!regex) {
-    regex = new RegExp(`^${route.pattern}$`);
-    routeRegexCache.set(route, regex);
-  }
-  return regex;
-}
-function segmentTokenOf(bare) {
-  const optionalCatchAllMatch = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(bare);
-  if (optionalCatchAllMatch?.[1]) {
-    const name = optionalCatchAllMatch[1];
-    return { route: `:${name}*`, catchAll: name, catchAllOptional: true };
-  }
-  const catchAllMatch = /^\[\.\.\.([^\]]+)\]$/.exec(bare);
-  if (catchAllMatch?.[1]) {
-    return { route: `:${catchAllMatch[1]}*`, pattern: "(.*)", catchAll: catchAllMatch[1] };
-  }
-  const paramMatch = /^\[([^\]]+)\]$/.exec(bare);
-  if (paramMatch?.[1]) {
-    return { route: `:${paramMatch[1]}`, pattern: "([^/]+)", param: paramMatch[1] };
-  }
-  const literal = decodeLiteralSegment(bare);
-  return { route: literal, pattern: escapeRegex2(literal) };
-}
-function isPrivateAppPath(relative) {
-  const segments = relative.split("/");
-  return segments.slice(0, -1).some((segment) => segment.startsWith("_") && !isGroupSegment(segment) && !isSlotSegment(segment));
-}
-function decodeLiteralSegment(segment) {
-  return segment.replace(/%5[Ff]/g, "_");
-}
-function routeParts(routeDir) {
-  const segments = routeDir.split("/").filter(Boolean);
-  let tokens = [];
-  let interception;
-  for (const segment of segments) {
-    if (isGroupSegment(segment) || isSlotSegment(segment)) continue;
-    const marker = interceptionMarkerOf(segment);
-    let bare = segment;
-    if (marker) {
-      bare = segment.slice(marker.length);
-      const base = tokens.slice();
-      const levels = interceptionMarkerLevels(marker);
-      tokens = levels === Number.POSITIVE_INFINITY ? [] : tokens.slice(0, Math.max(0, tokens.length - levels));
-      interception = {
-        marker,
-        base: `/${base.map((token) => token.route).join("/")}`.replace(/\/$/, "") || "/",
-        basePattern: base.map((token) => token.pattern ?? "(.*)").join("/")
-      };
-    }
-    tokens.push(segmentTokenOf(bare));
-  }
-  const params = tokens.filter((token) => token.param).map((token) => token.param);
-  const catchAllToken = tokens.find((token) => token.catchAll);
-  const routeSegments = tokens.map((token) => token.route);
-  const patternSegments = tokens.filter((token) => !token.catchAllOptional).map((token) => token.pattern);
-  const route = `/${routeSegments.join("/")}`.replace(/\/$/, "") || "/";
-  let pattern;
-  if (catchAllToken?.catchAllOptional) {
-    const prefix = patternSegments.length > 0 ? `/${patternSegments.join("/")}` : "";
-    pattern = `${prefix}(?:/(.*))?`;
-    if (pattern === "(?:/(.*))?") pattern = "/?(?:(.*))?";
-  } else {
-    pattern = route === "/" ? "/" : `/${patternSegments.join("/")}`;
-  }
-  return {
-    route,
-    pattern,
-    params,
-    catchAll: catchAllToken?.catchAll,
-    catchAllOptional: Boolean(catchAllToken?.catchAllOptional),
-    interception
-  };
-}
-function dynamicMetadataRouteParts(relative, source) {
-  const name = path4.basename(relative);
-  const dir = path4.dirname(relative) === "." ? "" : path4.dirname(relative);
-  const root = dir === "";
-  const extension = path4.extname(name);
-  const base = name.slice(0, -extension.length);
-  const kind = dynamicMetadataKind(base, root);
-  if (!kind) return void 0;
-  const prefix = routeParts(dir);
-  const generatedParam = metadataGeneratedParam(kind, source);
-  const final = dynamicMetadataFinalSegment(kind, base, dir, Boolean(generatedParam));
-  return {
-    ...appendRouteParts(prefix, final.route, final.pattern, generatedParam ? [generatedParam] : []),
-    metadataRoute: {
-      kind,
-      ...generatedParam ? { generatedParam } : {}
-    }
-  };
-}
-function dynamicMetadataKind(base, root) {
-  if (base === "robots") return root ? "robots" : void 0;
-  if (base === "sitemap") return "sitemap";
-  if (base === "manifest") return root ? "manifest" : void 0;
-  if (/^icon\d*$/.test(base)) return "icon";
-  if (/^apple-icon\d*$/.test(base)) return "apple-icon";
-  if (/^opengraph-image\d*$/.test(base)) return "opengraph-image";
-  if (/^twitter-image\d*$/.test(base)) return "twitter-image";
-  return void 0;
-}
-function metadataGeneratedParam(kind, source) {
-  if (kind === "sitemap" && /\bexport\s+(?:async\s+)?function\s+generateSitemaps\b/.test(source)) {
-    return "__metadata_id__";
-  }
-  if (metadataImageKind(kind) && /\bexport\s+(?:async\s+)?function\s+generateImageMetadata\b/.test(source)) {
-    return "__metadata_id__";
-  }
-  return void 0;
-}
-function dynamicMetadataFinalSegment(kind, base, relativeDir, generated) {
-  if (kind === "robots") return { route: "robots.txt", pattern: "robots\\.txt" };
-  if (kind === "manifest")
-    return { route: "manifest.webmanifest", pattern: "manifest\\.webmanifest" };
-  if (kind === "sitemap") {
-    return generated ? { route: "sitemap/:id.xml", pattern: "sitemap/([^/]+)\\.xml" } : { route: "sitemap.xml", pattern: "sitemap\\.xml" };
-  }
-  const suffix = metadataRouteSuffix(relativeDir);
-  const imageBase = suffix ? `${base}-${suffix}` : base;
-  return generated ? { route: `${imageBase}/:id`, pattern: `${escapeRegex2(imageBase)}/([^/]+)` } : { route: imageBase, pattern: escapeRegex2(imageBase) };
-}
-function appendRouteParts(parts, route, pattern, params) {
-  const prefixRoute = parts.route === "/" ? "" : parts.route;
-  const prefixPattern = parts.pattern === "/" ? "" : parts.pattern;
-  return {
-    ...parts,
-    route: `${prefixRoute}/${route}`.replace(/\/$/, "") || "/",
-    pattern: `${prefixPattern}/${pattern}`,
-    params: [...parts.params, ...params]
-  };
-}
-function metadataImageKind(kind) {
-  return kind === "icon" || kind === "apple-icon" || kind === "opengraph-image" || kind === "twitter-image";
-}
-function metadataRouteUsesRequest(source) {
-  return routeHandlerUsesRequest(source);
-}
-function metadataRouteSuffix(relativeDir) {
-  if (!relativeDir) return "";
-  const segments = relativeDir.split("/").filter(Boolean);
-  if (!segments.some((segment) => isGroupSegment(segment) || isSlotSegment(segment))) return "";
-  return djb2Hash(`/${relativeDir}`).toString(36).slice(0, 6);
-}
-function djb2Hash(value) {
-  let hash = 5381;
-  for (let i = 0; i < value.length; i++) {
-    hash = (hash << 5) + hash + value.charCodeAt(i) & 4294967295;
-  }
-  return hash >>> 0;
-}
-function inferRouteMode(parts, usesRequest, config) {
-  if (config?.dynamic === "force-dynamic") return "dynamic";
-  if (config?.revalidate === 0) return "dynamic";
-  if (config?.fetchCache === "force-no-store") return "dynamic";
-  if (config?.dynamic === "force-static") return "static";
-  if (config?.dynamic === "error") return "static";
-  if (usesRequest) return "dynamic";
-  if (parts.params.length > 0 || parts.catchAll) return "dynamic";
-  return "static";
-}
-function parseSegmentConfig(source) {
-  const searchable = stripComments(source);
-  const parsed = {};
-  const dynamicMatch = /^\s*export\s+const\s+dynamic\s*=\s*['"](auto|force-dynamic|error|force-static)['"]/m.exec(
-    searchable
-  );
-  if (dynamicMatch) parsed.dynamic = dynamicMatch[1];
-  const revalidateMatch = /^\s*export\s+const\s+revalidate\s*=\s*(\d+|false)\s*;?\s*$/m.exec(
-    searchable
-  );
-  if (revalidateMatch) {
-    parsed.revalidate = revalidateMatch[1] === "false" ? false : Number(revalidateMatch[1]);
-  } else {
-    const invalid = /^\s*export\s+const\s+revalidate\s*=\s*(['"]([^'"]*)['"]|-\d+)/m.exec(
-      searchable
-    );
-    if (invalid) parsed.invalidRevalidate = invalid[2] ?? invalid[1];
-  }
-  const fetchCacheMatch = /^\s*export\s+const\s+fetchCache\s*=\s*['"](auto|default-cache|only-cache|force-cache|force-no-store|default-no-store|only-no-store)['"]/m.exec(
-    searchable
-  );
-  if (fetchCacheMatch) parsed.fetchCache = fetchCacheMatch[1];
-  const dynamicParamsMatch = /^\s*export\s+const\s+dynamicParams\s*=\s*(true|false)/m.exec(
-    searchable
-  );
-  if (dynamicParamsMatch) parsed.dynamicParams = dynamicParamsMatch[1] === "true";
-  const runtimeMatch = /^\s*export\s+const\s+runtime\s*=\s*['"](edge|nodejs)['"]/m.exec(searchable);
-  if (runtimeMatch) parsed.runtime = runtimeMatch[1];
-  const prefetchMatch = /^\s*export\s+const\s+prefetch\s*=\s*['"](allow-runtime|partial|unstable_eager)['"]/m.exec(
-    searchable
-  );
-  if (prefetchMatch) parsed.prefetch = prefetchMatch[1];
-  const instantMatch = /^\s*export\s+const\s+unstable_instant\s*=\s*(true|false|\{)/m.exec(
-    searchable
-  );
-  if (instantMatch) parsed.unstableInstant = instantMatch[1] !== "false";
-  return parsed;
-}
-function segmentConfigFromEntries(appPath, entries, parts) {
-  const config = {};
-  let lowestRevalidate;
-  let sawRevalidateFalse = false;
-  const dynamicParamsByName = /* @__PURE__ */ new Map();
-  const allParams = [...parts.params, ...parts.catchAll ? [parts.catchAll] : []];
-  for (const entry of entries) {
-    const parsed = parseSegmentConfig(entry.source);
-    if (parsed.invalidRevalidate !== void 0) {
-      throw new Error(
-        `Invalid revalidate value "${parsed.invalidRevalidate}" on "${parts.route || "/"}", must be a non-negative number or false`
-      );
-    }
-    if (parsed.dynamic) {
-      if (parsed.dynamic === "force-dynamic") config.dynamic = "force-dynamic";
-      else if (!config.dynamic) config.dynamic = parsed.dynamic;
-    }
-    if (parsed.revalidate !== void 0) {
-      if (parsed.revalidate === false) sawRevalidateFalse = true;
-      else {
-        lowestRevalidate = lowestRevalidate === void 0 ? parsed.revalidate : Math.min(lowestRevalidate, parsed.revalidate);
-      }
-    }
-    if (parsed.fetchCache && !config.fetchCache) config.fetchCache = parsed.fetchCache;
-    if (parsed.runtime && !config.runtime) config.runtime = parsed.runtime;
-    if (parsed.prefetch && !config.prefetch) config.prefetch = parsed.prefetch;
-    if (parsed.unstableInstant !== void 0 && config.unstableInstant === void 0) {
-      config.unstableInstant = parsed.unstableInstant;
-    }
-    if (parsed.dynamicParams !== void 0) {
-      const param = paramOfOwnSegment(appPath, entry.file, allParams);
-      if (param !== void 0 && !dynamicParamsByName.has(param)) {
-        dynamicParamsByName.set(param, parsed.dynamicParams);
-      }
-    }
-  }
-  if (lowestRevalidate !== void 0) config.revalidate = lowestRevalidate;
-  else if (sawRevalidateFalse) config.revalidate = false;
-  const governed = allParams.filter((param) => dynamicParamsByName.get(param) === false);
-  if (governed.length > 0) config.dynamicParamsFalse = governed;
-  return Object.keys(config).length > 0 ? config : void 0;
-}
-function paramOfOwnSegment(appPath, file, params) {
-  const segments = toPosixPath(path4.relative(appPath, path4.dirname(file))).split("/");
-  const own = segments[segments.length - 1];
-  return params.find(
-    (param) => own === `[${param}]` || own === `[...${param}]` || own === `[[...${param}]]`
-  );
-}
-function hasUseClientDirective(file, source) {
-  return scanFacts(file, source).useClient;
-}
-function serverActionFileFact(context, sourceFiles) {
-  for (const file of sourceFiles) {
-    if (!fileExists(context, file) || isAssetFile(file)) continue;
-    if (scanFacts(file, readSource(context, file)).useServer) return { serverActionFile: file };
-  }
-  return {};
-}
-function serverActionsUnsupportedMessage(offender) {
-  const file = offender.root ? toPosixPath(path4.relative(offender.root, offender.file)) : offender.file;
-  const reach = offender.route ? `, reachable from the route ${offender.route}` : "";
-  return [
-    `Server actions need next compat, and this app is pure core.`,
-    ``,
-    `  ${file} has a 'use server' directive${reach}.`,
-    ``,
-    `pnext will not build this app: core has no server-action registry and no`,
-    `dispatch endpoint, so the action could only render as a form that submits`,
-    `nowhere.`,
-    ``,
-    `Fix it one of two ways:`,
-    `  1. Enable compat in pnext.config.ts:`,
-    `       export default { compat: { next: true } }`,
-    `  2. Or delete the 'use server' directive from ${file}, if those exports are`,
-    `     only ever called on the server (in core the directive does nothing).`
-  ].join("\n");
-}
-function assertNoServerActionsWithoutCompat(routes, compatEnabled, root) {
-  if (compatEnabled) return;
-  const offender = routes.find((route) => route.serverActionFile);
-  if (!offender) return;
-  throw new Error(
-    serverActionsUnsupportedMessage({
-      file: offender.serverActionFile,
-      route: offender.route,
-      root
-    })
-  );
-}
-function isClientModule(context, file) {
-  const key = path4.resolve(file);
-  let client = context.useClient.get(key);
-  if (client === void 0) {
-    client = hasUseClientDirective(file, readSource(context, file));
-    context.useClient.set(key, client);
-  }
-  return client;
-}
-function collectClientReferences(context, entryFiles) {
-  const references = /* @__PURE__ */ new Map();
-  const visited = /* @__PURE__ */ new Set();
-  for (const file of entryFiles) {
-    if (fileExists(context, file)) {
-      if (!isClientModule(context, file) && defaultReexportsClientModule(context, file)) {
-        addClientReference(references, clientReference(file, "default"));
-      }
-    }
-    collectFromFile(context, file, references, visited);
-  }
-  const collected = [...references.values()];
-  const hasRenderedReference = collected.some((reference) => !reference.sideEffect);
-  const filtered = hasRenderedReference ? collected : collected.filter((reference) => !reference.sideEffect);
-  return filtered.sort((a, b) => a.id.localeCompare(b.id));
-}
-function defaultReexportsClientModule(context, file, visited = /* @__PURE__ */ new Set()) {
-  const key = path4.resolve(file);
-  if (visited.has(key)) return false;
-  visited.add(key);
-  const source = readSource(context, file);
-  const specifiers = [];
-  for (const edge of scanFacts(file, source).imports) {
-    if (edge.reexport && edge.exports.includes("default")) specifiers.push(edge.specifier);
-  }
-  const defaultExpr = /export\s+default\s+([A-Za-z_$][\w$]*)(\s*\.\s*default)?\s*;?/.exec(source);
-  if (defaultExpr) {
-    const binding = defaultExpr[1];
-    const namespaced = Boolean(defaultExpr[2]);
-    const importBinding = namespaced ? new RegExp(`import\\s*\\*\\s*as\\s+${binding}\\s+from\\s+['"]([^'"]+)['"]`).exec(source) : new RegExp(`import\\s+${binding}\\s+from\\s+['"]([^'"]+)['"]`).exec(source);
-    if (importBinding?.[1]) specifiers.push(importBinding[1]);
-  }
-  for (const specifier of specifiers) {
-    const resolved = resolveModuleEdge(context, file, specifier);
-    if (!resolved || !fileExists(context, resolved)) continue;
-    if (isClientModule(context, resolved)) return true;
-    if (defaultReexportsClientModule(context, resolved, visited)) return true;
-  }
-  return false;
-}
-function collectFromFile(context, file, references, visited, withinClientBoundary = false) {
-  const visitKey = `${file}\0${withinClientBoundary ? "client" : "server"}`;
-  if (visited.has(visitKey) || !fileExists(context, file)) return;
-  visited.add(visitKey);
-  const clientFile = isClientModule(context, file);
-  if (clientFile) {
-    addClientReference(references, clientReference(file, "default"));
-  }
-  const nestedClientBoundary = withinClientBoundary || clientFile;
-  const imports = [...moduleEdges(context, file)];
-  if (!nestedClientBoundary) imports.push(...publishedClientImports(context, file));
-  for (const imported of imports) {
-    if (isClientModule(context, imported.file)) {
-      if (imported.star) {
-        const importedSource = readSource(context, imported.file);
-        for (const exportName of scanFacts(imported.file, importedSource).exportNames) {
-          if (exportName !== "default") {
-            addClientReference(references, clientReference(imported.file, exportName));
-          }
-        }
-        continue;
-      }
-      if (imported.exports.includes("*")) {
-        throw new Error(
-          `${file} namespace-imports Client Component module ${imported.file}. Import the client component by default or named export instead.`
-        );
-      }
-      if (imported.exports.length === 0) {
-        addClientReference(references, {
-          ...clientReference(imported.file, "*side-effect*"),
-          sideEffect: true
-        });
-        continue;
-      }
-      for (const exportName of imported.exports) {
-        addClientReference(references, {
-          ...clientReference(imported.file, exportName),
-          dynamic: imported.dynamic
-        });
-      }
-      continue;
-    }
-    if (imported.dynamic?.load === "visible") {
-      console.warn(
-        `${file} uses dynamic({ load: 'visible' }) for ${imported.file}, but the target is a Server Component. It will render on the server instead of loading on visibility.`
-      );
-    }
-    collectFromFile(context, imported.file, references, visited, nestedClientBoundary);
-  }
-}
-function addClientReference(references, reference) {
-  const existing = references.get(reference.id);
-  if (!existing) {
-    references.set(reference.id, reference);
-    return;
-  }
-  if (!reference.dynamic) references.set(reference.id, reference);
-}
-function cssEntryOrder(options) {
-  return [
-    ...options.leadFiles ?? [],
-    ...options.layoutFiles,
-    ...options.templateFiles,
-    ...options.routeFile ? [options.routeFile] : [],
-    ...options.specialFiles,
-    ...options.slotFiles
-  ];
-}
-function collectCssImports(context, entryFiles, options = {}) {
-  const imports = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  for (const file of entryFiles) {
-    collectCssFromFile(context, file, imports, visited);
-  }
-  if (!options.route || !getCssExtensions().deferRootNotFoundCss()) return [...imports];
-  const rootNotFound = entryFiles.find(
-    (file) => path4.dirname(file) === context.appPath && /^not-found\.[^.]+$/.test(path4.basename(file))
-  );
-  if (!rootNotFound) return [...imports];
-  const rootNotFoundImports = /* @__PURE__ */ new Set();
-  collectCssFromFile(context, rootNotFound, rootNotFoundImports, /* @__PURE__ */ new Set());
-  if (rootNotFoundImports.size === 0) return [...imports];
-  const matchedImports = /* @__PURE__ */ new Set();
-  for (const file of entryFiles) {
-    if (file === rootNotFound) continue;
-    collectCssFromFile(context, file, matchedImports, /* @__PURE__ */ new Set());
-  }
-  return [...imports].filter((file) => !rootNotFoundImports.has(file) || matchedImports.has(file));
-}
-function collectSourceFiles(context, entryFiles) {
-  const files = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  for (const file of entryFiles) {
-    collectSourceFile(context, file, files, visited);
-  }
-  return [...files].sort();
-}
-function collectSourceFile(context, file, files, visited) {
-  if (visited.has(file) || !fileExists(context, file)) return;
-  visited.add(file);
-  files.add(file);
-  if (isAssetFile(file)) return;
-  for (const imported of moduleEdges(context, file)) {
-    collectSourceFile(context, imported.file, files, visited);
-  }
-}
-function collectCssFromFile(context, file, imports, visited) {
-  if (visited.has(file) || !fileExists(context, file)) return;
-  visited.add(file);
-  if (isCssFile2(file)) {
-    if (!context.globalCssImports().has(path4.resolve(file))) imports.add(file);
-    return;
-  }
-  const clientFile = isClientModule(context, file);
-  for (const imported of moduleEdges(context, file)) {
-    if (isCssFile2(imported.file)) {
-      if (!context.globalCssImports().has(path4.resolve(imported.file))) imports.add(imported.file);
-      continue;
-    }
-    if (!clientFile && isLazyClientEdge(context, imported)) continue;
-    collectCssFromFile(context, imported.file, imports, visited);
-  }
-}
-function isLazyClientEdge(context, edge) {
-  if (!edge.dynamic || ssrClientReference({ dynamic: edge.dynamic })) return false;
-  return isClientModule(context, edge.file);
-}
-function attachLazyReferenceCss(context, references) {
-  for (const reference of references) {
-    if (ssrClientReference(reference)) continue;
-    const css = collectCssImports(context, [reference.file]);
-    if (css.length > 0) reference.cssImports = css;
-  }
-}
-function readScanSource(context, file, visited = /* @__PURE__ */ new Set()) {
-  const key = path4.resolve(file);
-  if (visited.has(key)) return "";
-  visited.add(key);
-  const source = readSource(context, file);
-  const parts = [source];
-  for (const edge of scanFacts(file, source).imports) {
-    if (!edge.reexport || !edge.specifier.startsWith(".")) continue;
-    const resolved = resolveModuleEdge(context, file, edge.specifier);
-    if (!resolved || !existsSync3(resolved)) continue;
-    parts.push(readScanSource(context, resolved, visited));
-  }
-  return parts.join("\n");
-}
-function readSource(context, file) {
-  const key = path4.resolve(file);
-  let source = context.sources.get(key);
-  if (source === void 0) {
-    source = rewriteLiteralDynamicCalls(readSourceSync(key), file);
-    context.sources.set(key, source);
-  }
-  return source;
-}
-var linkSpecifiers = /* @__PURE__ */ new Set(["next/link", "@wular/pnext/link"]);
-var navigationSpecifiers = /* @__PURE__ */ new Set([
-  ...linkSpecifiers,
-  "next/form",
-  "next/navigation",
-  "next/router",
-  "@wular/pnext/navigation",
-  "@wular/pnext/navigation/client"
-]);
-var rootNavigationExports = /* @__PURE__ */ new Set([
-  "*",
-  "default",
-  "Link",
-  "permanentRedirect",
-  "redirect",
-  "useLinkStatus",
-  "useParams",
-  "usePathname",
-  "useRoute",
-  "useRouter",
-  "useSearchParams"
-]);
-function importReachesNavigation(edge) {
-  if (navigationSpecifiers.has(edge.specifier)) return true;
-  if (edge.specifier !== "@wular/pnext") return false;
-  return edge.exports.length === 0 || edge.exports.some((name) => rootNavigationExports.has(name));
-}
-function routeUsesLinkComponent(context, files) {
-  for (const file of files) {
-    if (!fileExists(context, file) || isAssetFile(file)) continue;
-    const key = path4.resolve(file);
-    let uses = context.usesLink.get(key);
-    if (uses === void 0) {
-      const facts = scanFacts(file, readSource(context, file));
-      uses = facts.imports.some((edge) => linkSpecifiers.has(edge.specifier));
-      context.usesLink.set(key, uses);
-    }
-    if (uses) return true;
-  }
-  return false;
-}
-function routeUsesNavigation(context, files) {
-  for (const file of files) {
-    if (!fileExists(context, file) || isAssetFile(file)) continue;
-    const key = path4.resolve(file);
-    let uses = context.usesNavigation.get(key);
-    if (uses === void 0) {
-      const facts = scanFacts(file, readSource(context, file));
-      uses = facts.imports.some(importReachesNavigation);
-      context.usesNavigation.set(key, uses);
-    }
-    if (uses) return true;
-  }
-  return false;
-}
-function routeClientEntryReasons(context, files) {
-  const reasons = [];
-  for (const file of files) {
-    if (!fileExists(context, file) || isAssetFile(file)) continue;
-    const key = path4.resolve(file);
-    let fileReasons = context.entryReasons.get(key);
-    if (fileReasons === void 0) {
-      fileReasons = sourceClientEntryReasons(readSource(context, file));
-      context.entryReasons.set(key, fileReasons);
-    }
-    reasons.push(...fileReasons);
-  }
-  return reasons;
-}
-function usesRequestImportDataForFiles(context, files) {
-  for (const file of files) {
-    const key = path4.resolve(file);
-    let usesRequestImport = context.requestImportUsage.get(key);
-    if (usesRequestImport === void 0) {
-      usesRequestImport = sourceUsesRegisteredRequestApi(readSource(context, file));
-      context.requestImportUsage.set(key, usesRequestImport);
-    }
-    if (usesRequestImport) return true;
-  }
-  return false;
-}
-function routeDependencyClassification(context, kind, files) {
-  const sources = files.filter((file) => !isAssetFile(file)).map((file) => ({ file, source: readSource(context, file) }));
-  return classifyRouteDependencies({ kind, files: sources });
-}
-function moduleEdges(context, file) {
-  const key = path4.resolve(file);
-  let edges = context.edges.get(key);
-  if (!edges) {
-    edges = moduleEdgesFromSource(context, file, readSource(context, file));
-    context.edges.set(key, edges);
-  }
-  return edges;
-}
-function resolveModuleEdge(context, file, specifier) {
-  return resolveModuleAlias(specifier) ?? resolveImport(context.root, file, specifier, context.workspaceRoot) ?? getBundlerExtensions().resolveRouteDependency(context.root, file, specifier) ?? getCssExtensions().resolveCssDependency(context.root, file, specifier);
-}
-function publishedClientImports(context, file) {
-  const source = readSource(context, file);
-  const found = [];
-  for (const edge of scanFacts(file, source).imports) {
-    if (resolveModuleEdge(context, file, edge.specifier)) continue;
-    found.push(...publishedClientEdges(context, file, edge.specifier, edge.exports));
-  }
-  return found;
-}
-function publishedClientEdges(context, file, specifier, requested) {
-  const cacheKey = `${file}\0${specifier}\0${requested.join(",")}`;
-  const cached = context.edges.get(cacheKey);
-  if (cached) return cached;
-  const entry = resolvePublishedEdge(context, file, specifier, "import");
-  const edges = entry ? publishedClientExports(context, entry, requested, /* @__PURE__ */ new Set()) : [];
-  context.edges.set(cacheKey, edges);
-  return edges;
-}
-function resolvePublishedEdge(context, file, specifier, kind) {
-  return resolveModuleEdge(context, file, specifier) ?? resolvePackageSpecifier(context.root, file, specifier, [kind, "default"]);
-}
-function publishedClientExports(context, file, requested, visiting) {
-  const key = path4.resolve(file);
-  if (visiting.has(key) || !fileExists(context, key)) return [];
-  visiting.add(key);
-  const source = readSource(context, key);
-  if (hasUseClientDirective(key, source)) {
-    visiting.delete(key);
-    const names = [...scanFacts(key, source).exportNames, ...commonJsRouteExportNames(source)];
-    const exports = requested.filter((name) => names.includes(name));
-    return exports.length > 0 ? [{ file: key, exports }] : [];
-  }
-  const facts = scanFacts(key, source);
-  const found = [];
-  for (const edge of facts.imports) {
-    if (!edge.reexport) continue;
-    const map = { ...esmReexportMap(source, edge.specifier), ...edge.exportMap };
-    const next = edge.star ? requested.filter((name) => name !== "default") : requested.map((name) => map[name]).filter((name) => Boolean(name));
-    const target = resolvePublishedEdge(context, key, edge.specifier, "import");
-    if (target && next.length > 0) {
-      found.push(...publishedClientExports(context, target, next, visiting));
-    }
-  }
-  for (const edge of facts.requires) {
-    const map = commonJsRequireReexportMap(source, edge.specifier);
-    const next = map.star ? requested : requested.map((name) => map.names[name]).filter((name) => Boolean(name));
-    const target = resolvePublishedEdge(context, key, edge.specifier, "require");
-    if (target && next.length > 0) {
-      found.push(...publishedClientExports(context, target, next, visiting));
-    }
-  }
-  visiting.delete(key);
-  return found;
-}
-function moduleEdgesFromSource(context, file, source) {
-  const dynamicNames = pnextDynamicImportNames(source, file);
-  assertSupportedDynamicCalls(file, source, dynamicNames);
-  const ordered = [];
-  const facts = scanFacts(file, source);
-  for (const edge of facts.imports) {
-    const resolved = resolveModuleEdge(context, file, edge.specifier);
-    if (!resolved) continue;
-    ordered.push({
-      file: resolved,
-      exports: [...edge.exports],
-      index: edge.index,
-      ...edge.star ? { star: true } : {}
-    });
-  }
-  ordered.sort((a, b) => a.index - b.index);
-  const imports = ordered.map(({ index: _index, ...edge }) => edge);
-  for (const imported of dynamicImportEdgesFromSource(context, file, source, dynamicNames))
-    imports.push(imported);
-  return imports;
-}
-function esmReexportMap(source, specifier) {
-  const escaped = escapeRegex2(specifier);
-  const names = {};
-  const pattern = new RegExp(`\\bexport\\s*\\{([^}]*)\\}\\s*from\\s*["']${escaped}["']`, "g");
-  for (const clause of source.matchAll(pattern)) {
-    for (const item of (clause[1] ?? "").split(",")) {
-      const parts = item.trim().split(/\s+as\s+/);
-      const imported = parts[0]?.trim();
-      const exported = (parts[1] ?? parts[0])?.trim();
-      if (imported && exported && /^[$\w]+$/.test(imported) && /^[$\w]+$/.test(exported)) {
-        names[exported] = imported;
-      }
-    }
-  }
-  return names;
-}
-function commonJsRequireReexportMap(source, specifier) {
-  const escaped = escapeRegex2(specifier);
-  const names = {};
-  const direct = new RegExp(
-    `exports\\.([A-Za-z_$][\\w$]*)\\s*=\\s*require\\(\\s*["']${escaped}["']\\s*\\)\\.([A-Za-z_$][\\w$]*)`,
-    "g"
-  );
-  for (const match of source.matchAll(direct)) {
-    names[match[1]] = match[2];
-  }
-  const binding = new RegExp(
-    `(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*require\\(\\s*["']${escaped}["']\\s*\\)`
-  ).exec(source)?.[1];
-  if (binding) {
-    const local = escapeRegex2(binding);
-    const assignment = new RegExp(
-      `exports\\.([A-Za-z_$][\\w$]*)\\s*=\\s*${local}\\.([A-Za-z_$][\\w$]*)`,
-      "g"
-    );
-    for (const match of source.matchAll(assignment)) {
-      names[match[1]] = match[2];
-    }
-    const getter = new RegExp(
-      `Object\\.defineProperty\\(\\s*exports\\s*,\\s*["']([A-Za-z_$][\\w$]*)["'](?:(?!Object\\.defineProperty)[\\s\\S]){0,300}?return\\s+${local}\\.([A-Za-z_$][\\w$]*)`,
-      "g"
-    );
-    for (const match of source.matchAll(getter)) {
-      names[match[1]] = match[2];
-    }
-    const helper = new RegExp(
-      `(?:^|[,\\{])\\s*([A-Za-z_$][\\w$]*)\\s*:\\s*\\(\\s*\\)\\s*=>\\s*${local}\\.([A-Za-z_$][\\w$]*)`,
-      "g"
-    );
-    for (const match of source.matchAll(helper)) {
-      names[match[1]] = match[2];
-    }
-  }
-  const star = new RegExp(
-    `module\\.exports\\s*=\\s*(?:require\\(\\s*["']${escaped}["']\\s*\\)|${binding ?? "(?!)"})(?=\\s*(?:;|$))`,
-    "m"
-  ).test(source);
-  return { names, star };
-}
-function commonJsRouteExportNames(source) {
-  return [
-    .../* @__PURE__ */ new Set([
-      ...[...source.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=/g)].map((match) => match[1]),
-      ...[
-        ...source.matchAll(
-          /\bObject\.defineProperty\(\s*exports\s*,\s*["']([A-Za-z_$][\w$]*)["']/g
-        )
-      ].map((match) => match[1])
-    ])
-  ].filter((name) => name !== "__esModule");
-}
-function assertSupportedDynamicCalls(file, source, dynamicNames) {
-  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
-    if (!/\bimport\s*\(/.test(call.source)) {
-      throw new Error(
-        `${file} uses dynamic() without a literal import. PNext supports dynamic('./module') or dynamic(() => import('./module')).`
-      );
-    }
-    if (!/\bimport\s*\(\s*['"][^'"]+['"]\s*\)/.test(call.source)) {
-      throw new Error(
-        `${file} uses a non-literal dynamic import. PNext supports dynamic('./module') or dynamic(() => import('./module')).`
-      );
-    }
-  }
-}
-function dynamicImportEdgesFromSource(context, file, source, dynamicNames) {
-  const imports = [];
-  if (dynamicNames.size === 0) return imports;
-  const optionObjects = dynamicOptionObjects(source);
-  for (const fact of dynamicCallFacts(source, file)) {
-    if (!dynamicNames.has(fact.name)) continue;
-    const resolved = resolveModuleEdge(context, file, fact.specifier);
-    if (!resolved) continue;
-    imports.push({
-      file: resolved,
-      exports: [fact.exportName],
-      dynamic: dynamicOptionsForFact(source, fact, optionObjects)
-    });
-  }
-  return imports;
-}
-function dynamicOptionObjects(source) {
-  const options = /* @__PURE__ */ new Map();
-  const pattern = /const\s+([A-Za-z_$][\w$]*)\s*=\s*({[\s\S]*?})\s*(?:as\s+const\s*)?;/g;
-  let match;
-  while (match = pattern.exec(source)) {
-    const [, name, objectSource] = match;
-    if (name && objectSource) options.set(name, dynamicOptionsFromSource(objectSource));
-  }
-  return options;
-}
-function dynamicOptionsForFact(source, fact, optionObjects) {
-  if (fact.optionsStart === void 0 || fact.optionsEnd === void 0) return {};
-  const options = source.slice(fact.optionsStart, fact.optionsEnd);
-  if (/^[A-Za-z_$][\w$]*$/.test(options)) return optionObjects.get(options) ?? {};
-  return dynamicOptionsFromSource(options);
-}
-function dynamicOptionsFromSource(source) {
-  if (!source) return {};
-  return {
-    ...dynamicLoadFromSource(source),
-    ...dynamicRootMarginFromSource(source),
-    ...dynamicSsrFromSource(source),
-    ...dynamicThresholdFromSource(source)
-  };
-}
-function dynamicLoadFromSource(source) {
-  const match = /\bload\s*:\s*['"](render|visible)['"]/.exec(source);
-  return match?.[1] === "render" || match?.[1] === "visible" ? { load: match[1] } : {};
-}
-function dynamicRootMarginFromSource(source) {
-  const match = /\brootMargin\s*:\s*['"]([^'"]+)['"]/.exec(source);
-  return match?.[1] ? { rootMargin: match[1] } : {};
-}
-function dynamicSsrFromSource(source) {
-  const match = /\bssr\s*:\s*(true|false)\b/.exec(source);
-  return match?.[1] ? { ssr: match[1] === "true" } : {};
-}
-function dynamicThresholdFromSource(source) {
-  const numberMatch = /\bthreshold\s*:\s*(-?\d+(?:\.\d+)?)/.exec(source);
-  if (numberMatch?.[1]) return { threshold: Number(numberMatch[1]) };
-  const arrayMatch = /\bthreshold\s*:\s*\[([^\]]*)\]/.exec(source);
-  if (!arrayMatch?.[1]) return {};
-  const threshold = arrayMatch[1].split(",").map((value) => Number(value.trim())).filter(Number.isFinite);
-  return threshold.length > 0 ? { threshold } : {};
-}
-function isCssFile2(file) {
-  return file.endsWith(".css") || getCssExtensions().extraCssExtensions().some((ext) => file.endsWith(ext));
-}
-function isAssetFile(file) {
-  return /\.(css|svg|png|jpe?g|gif|webp|ico|woff2?)$/.test(file) || getCssExtensions().extraCssExtensions().some((ext) => file.endsWith(ext));
-}
-function exportsExperimentalPpr(sources) {
-  return sources.some(
-    (source) => /\bexport\s+const\s+experimental_ppr\s*=\s*true\b/.test(stripComments(source))
-  );
-}
-function usesRequestData(source) {
-  const searchable = stripJsxText(stripCommentsAndStrings(source));
-  return /\b(?:request|searchParams)\b/.test(searchable) || sourceUsesRegisteredRequestApi(source);
-}
-function stripJsxText(source) {
-  return source.replace(
-    />([^<>(){}=;\n]*)</g,
-    (_match, text) => `>${" ".repeat(text.length)}<`
-  );
-}
-function dynamicApiLabel(sources, kind) {
-  const joined = sources.map(stripCommentsAndStrings).join("\n");
-  if (/\bconnection\s*\(/.test(joined)) return "`connection()`";
-  if (/\bcookies\s*\(/.test(joined)) return "`cookies()`";
-  if (/\bheaders\s*\(/.test(joined)) return "`headers()`";
-  if (/\bdraftMode\s*\(/.test(joined)) return "`draftMode()`";
-  if (kind === "handler") {
-    if (/\.formData\b/.test(joined)) return "`request.formData`";
-    if (/\bnextUrl\b/.test(joined)) return "`nextUrl.toString`";
-    if (/\brequest\.url\b|\breq\.url\b/.test(joined)) return "`request.url`";
-  } else if (/\bsearchParams\b/.test(joined)) {
-    return "`await searchParams`, `searchParams.then`, or similar";
-  }
-  return void 0;
-}
-function maxDurationFromSources(sources) {
-  const durations = sources.map((source) => /\bexport\s+const\s+maxDuration\s*=\s*(\d+)\b/.exec(source)?.[1]).filter((value) => Boolean(value)).map((value) => Number(value));
-  return durations.length > 0 ? Math.max(...durations) : void 0;
-}
-function usesRevalidationApis(source) {
-  return /\b(?:revalidatePath|revalidateTag|updateTag|expirePath|expireTag|unstable_expirePath|unstable_expireTag)\s*\(/.test(
-    stripCommentsAndStrings(source)
-  );
-}
-var DESTRUCTURED_PARAM = "<destructured>";
-function routeHandlerUsesRequest(source) {
-  const withoutComments = stripComments(source);
-  const searchable = stripCommentsAndStrings(source);
-  if (sourceUsesRegisteredRequestApi(source)) return true;
-  for (const method of routeHandlerMethods) {
-    for (const params of exportedFunctionParams(withoutComments, method)) {
-      const name = firstParameterName(params);
-      if (name === DESTRUCTURED_PARAM) return true;
-      if (name && referencesName(searchable, name) > 1) return true;
-    }
-  }
-  return false;
-}
-function exportedFunctionParams(source, method) {
-  const params = [];
-  const functionPattern = new RegExp(
-    `\\bexport\\s+(?:async\\s+)?function\\s+${method}\\s*\\(([^)]*)\\)`,
-    "g"
-  );
-  let match;
-  while (match = functionPattern.exec(source)) {
-    params.push(match[1] ?? "");
-  }
-  const arrowPattern = new RegExp(
-    `\\bexport\\s+const\\s+${method}\\s*(?::[^=]+)?=\\s*(?:async\\s*)?(?:\\(([^)]*)\\)|([A-Za-z_$][\\w$]*))\\s*=>`,
-    "g"
-  );
-  while (match = arrowPattern.exec(source)) {
-    params.push(match[1] ?? match[2] ?? "");
-  }
-  return params;
-}
-function firstParameterName(params) {
-  const first = params.split(",")[0]?.trim();
-  if (!first) return void 0;
-  if (first.startsWith("{") || first.startsWith("[")) return DESTRUCTURED_PARAM;
-  const name = /^\.{3}\s*([A-Za-z_$][\w$]*)/.exec(first)?.[1] ?? /^([A-Za-z_$][\w$]*)/.exec(first)?.[1];
-  return name;
-}
-function referencesName(source, name) {
-  const pattern = new RegExp(`\\b${escapeRegex2(name)}\\b`, "g");
-  return [...source.matchAll(pattern)].length;
-}
-function stripCommentsAndStrings(source) {
-  return stripComments(source).replace(/(['"`])(?:\\[\s\S]|(?!\1)[^\\])*\1/g, "");
-}
-function stripComments(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-}
-function rootFromAppPath(appPath) {
-  const normalized = toPosixPath(appPath);
-  return normalized.endsWith("/src/app") ? path4.dirname(path4.dirname(appPath)) : path4.dirname(appPath);
-}
-function clientReference(file, exportName) {
-  return {
-    id: `c-${clientReferenceId(file, exportName)}`,
-    file,
-    exportName
-  };
-}
-function routeId(route) {
-  if (route === "/") return "index";
-  return route.split("/").filter(Boolean).map((segment) => {
-    if (segment.startsWith(":") && segment.endsWith("*"))
-      return `catchall-${sanitizeIdPart(segment.slice(1, -1))}`;
-    if (segment.startsWith(":")) return `param-${sanitizeIdPart(segment.slice(1))}`;
-    return sanitizeIdPart(segment);
-  }).join("-");
-}
-function sanitizeIdPart(value) {
-  return value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "route";
-}
-function routeRank(route) {
-  const spec = route.route.split("/").filter(Boolean).map((segment) => segment.startsWith(":") ? segment.endsWith("*") ? "2" : "1" : "0").join("");
-  return `${spec}:${route.synthetic ? 1 : 0}:${route.route}`;
-}
-function escapeRegex2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export {
-  readSourceSync,
-  readSourceText,
-  isSlotSegment,
-  isGroupSegment,
-  slotConventionFile,
-  slotDirectoriesIn,
-  consumedSegments,
-  matchSegments,
-  matchSlotInterceptor,
-  pathnameSegments,
-  routeFactsVersion,
-  routeFactsResolved,
-  materializeRouteFacts,
-  materializeRouteFactsPaced,
-  setRouteFactsStore,
-  scanRoutes,
-  addClientEntryReason,
-  findLayouts,
-  collectNotFoundCss,
-  collectFileCss,
-  findConventionFiles,
-  findGlobalError,
-  matchRoute,
-  normalizePathname,
-  matchInterception,
-  selectRouteForRequest,
-  parseNavState,
-  serverActionsUnsupportedMessage,
-  assertNoServerActionsWithoutCompat,
-  globalCssHref,
-  publishEmittedAssets,
-  emittedAssetName,
-  assetHref,
-  routeCssAssetNames,
-  routeCssHref,
-  emitFontCssStylesheet,
-  withAssetPrefix,
-  registerCssRuntime,
-  hoistCssImports
-};