@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-8k7pfejn.js

@@ -0,0 +1,1599 @@
+// @bun
+import {
+  dynamicCallsFromSource,
+  pnextDynamicImportNames,
+  rewriteLiteralDynamicCalls
+} from "./index-91x12ykq.js";
+import {
+  conventionFileName,
+  findConventionFiles,
+  findLayouts,
+  pageExtensions,
+  serverActionsUnsupportedMessage
+} from "./index-jepjvcrf.js";
+import {
+  globalCssSourcesForPaths
+} from "./index-2dv4y4wd.js";
+import {
+  readSourceSync
+} from "./index-fp8r0sqs.js";
+import {
+  childrenDefaultFile,
+  interceptionMarkerLevels,
+  interceptionMarkerOf,
+  isGroupSegment,
+  isSlotSegment,
+  slotConventionFile,
+  slotDirectoriesIn
+} from "./index-p77b4kcx.js";
+import {
+  listFiles,
+  listFilesSync,
+  toPosixPath,
+  withDirCache
+} from "./index-20ppawv7.js";
+import {
+  clientReferenceId,
+  ssrClientReference
+} from "./index-ras0sdab.js";
+import {
+  dynamicCallFacts,
+  scanFacts
+} from "./index-z4z9zv3b.js";
+import {
+  resolveImport,
+  resolveModuleAlias,
+  resolvePackageSpecifier
+} from "./index-yz54pxrh.js";
+import {
+  alwaysClientEntryReasons,
+  classifyRouteDependencies,
+  extraBoundaryConventionNames,
+  extraPageExtensions,
+  getBundlerExtensions,
+  getCssExtensions,
+  sourceClientEntryReasons,
+  sourceUsesRegisteredRequestApi
+} from "./index-zqpqyg8p.js";
+
+// src/routing/routes.ts
+import path from "path";
+import { existsSync } from "fs";
+var BASE_ROUTE_HANDLER_EXTENSIONS = ["ts", "tsx", "js", "mjs"];
+function routeHandlerExtensions() {
+  return BASE_ROUTE_HANDLER_EXTENSIONS;
+}
+function allFileExtensions() {
+  return [...new Set([...pageExtensions(), ...routeHandlerExtensions()])];
+}
+var componentConventions = ["loading", "error", "not-found"];
+function boundaryConventions() {
+  return [...componentConventions, ...extraBoundaryConventionNames()];
+}
+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 = undefined;
+  memoRouteFilePattern = undefined;
+  memoDefaultConventionPattern = undefined;
+  memoMetadataCodeFilePattern = undefined;
+  memoPageOrRouteTrailing = undefined;
+  memoSlotConventionPattern = undefined;
+}
+function pageFile() {
+  freshMemos();
+  return memoPageFile ??= extensionRegex("page", pageExtensions());
+}
+function routeFilePattern() {
+  freshMemos();
+  return memoRouteFilePattern ??= extensionRegex("route", routeHandlerExtensions());
+}
+function defaultConventionPattern() {
+  freshMemos();
+  return memoDefaultConventionPattern ??= extensionRegex("default", pageExtensions());
+}
+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)\\.(${pageExtensions().join("|")})$`);
+}
+function extensionRegex(base, extensions) {
+  return new RegExp(`(^|/)${escapeRegex(base)}\\.(${extensions.join("|")})$`);
+}
+function createScanContext(appPath, globalCss, workspaceRoot) {
+  const root = rootFromAppPath(appPath);
+  let memo;
+  return {
+    root,
+    workspaceRoot,
+    appPath,
+    sources: new Map,
+    edges: new Map,
+    requestImportUsage: new Map,
+    exists: new Map,
+    useClient: new Map,
+    usesLink: new Map,
+    usesNavigation: new Map,
+    entryReasons: new Map,
+    globalCssImports: globalCss ?? (() => memo ??= new Set(globalCssSourcesForPaths(root, appPath, workspaceRoot)))
+  };
+}
+function fileExists(context, file) {
+  let hit = context.exists.get(file);
+  if (hit === undefined) {
+    hit = existsSync(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 = 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) {
+    route.sourceFiles;
+    onRoute?.(route);
+  }
+  return routes;
+}
+async function materializeRouteFactsPaced(routes, pause) {
+  for (const route of routes) {
+    await pause();
+    route.sourceFiles;
+  }
+  return routes;
+}
+var factsStore;
+function setRouteFactsStore(store) {
+  factsStore = store;
+}
+function withDeferredFacts(appPath, base, compute) {
+  const entry = base;
+  let facts;
+  const overrides = 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}\x00${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, undefined, workspaceRoot);
+  const routes = [];
+  const slotPageFiles = [];
+  const defaultPageFiles = [];
+  const table = { parallelRoutes: false };
+  for (const file of files) {
+    const relative = toPosixPath(path.relative(appPath, file));
+    const routeFile = path.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) => existsSync(item));
+    const extraBoundaries = new Set(extraBoundaryConventionNames());
+    const forbiddenPaths = kind === "page" && extraBoundaries.has("forbidden") ? findConventionFiles(appPath, routeFile, "forbidden").filter((item) => existsSync(item)) : [];
+    const unauthorizedPaths = kind === "page" && extraBoundaries.has("unauthorized") ? findConventionFiles(appPath, routeFile, "unauthorized").filter((item) => existsSync(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) => existsSync(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) => existsSync(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 = 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) : undefined;
+  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 }) : undefined;
+  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,
+      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) => existsSync(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 = path.dirname(routeFilePath);
+  while (dir.startsWith(appPath)) {
+    dirs.push(...slotDirectoriesIn(dir));
+    if (dir === appPath)
+      break;
+    dir = path.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 = path.join(appPath, ...segments.slice(0, slotIndex + 1));
+    return {
+      file,
+      relative,
+      slotDir,
+      ownerDir: path.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(path.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) => existsSync(item)) : [];
+    const unauthorizedPaths = extraBoundaries.has("unauthorized") ? findConventionFiles(appPath, anchor, "unauthorized").filter((item) => existsSync(item)) : [];
+    const templatePaths = templateFiles.filter((item) => existsSync(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 = path.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) => existsSync(item)) : [];
+    const unauthorizedPaths = extraBoundaries.has("unauthorized") ? findConventionFiles(appPath, file, "unauthorized").filter((item) => existsSync(item)) : [];
+    const templatePaths = templateFiles.filter((item) => existsSync(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
+    })));
+  }
+}
+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) => existsSync(file));
+  if (existing.length === 0)
+    return [];
+  const context = createScanContext(appPath, options.includeGlobalCss ? () => new Set : undefined);
+  return collectCssImports(context, existing);
+}
+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: escapeRegex(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 = path.basename(relative);
+  const dir = path.dirname(relative) === "." ? "" : path.dirname(relative);
+  const root = dir === "";
+  const extension = path.extname(name);
+  const base = name.slice(0, -extension.length);
+  const kind = dynamicMetadataKind(base, root);
+  if (!kind)
+    return;
+  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" : undefined;
+  if (base === "sitemap")
+    return "sitemap";
+  if (base === "manifest")
+    return root ? "manifest" : undefined;
+  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;
+}
+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;
+}
+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: `${escapeRegex(imageBase)}/([^/]+)` } : { route: imageBase, pattern: escapeRegex(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 = new Map;
+  const allParams = [...parts.params, ...parts.catchAll ? [parts.catchAll] : []];
+  for (const entry of entries) {
+    const parsed = parseSegmentConfig(entry.source);
+    if (parsed.invalidRevalidate !== undefined) {
+      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 !== undefined) {
+      if (parsed.revalidate === false)
+        sawRevalidateFalse = true;
+      else {
+        lowestRevalidate = lowestRevalidate === undefined ? 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 !== undefined && config.unstableInstant === undefined) {
+      config.unstableInstant = parsed.unstableInstant;
+    }
+    if (parsed.dynamicParams !== undefined) {
+      const param = paramOfOwnSegment(appPath, entry.file, allParams);
+      if (param !== undefined && !dynamicParamsByName.has(param)) {
+        dynamicParamsByName.set(param, parsed.dynamicParams);
+      }
+    }
+  }
+  if (lowestRevalidate !== undefined)
+    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 : undefined;
+}
+function paramOfOwnSegment(appPath, file, params) {
+  const segments = toPosixPath(path.relative(appPath, path.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 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 = path.resolve(file);
+  let client = context.useClient.get(key);
+  if (client === undefined) {
+    client = hasUseClientDirective(file, readSource(context, file));
+    context.useClient.set(key, client);
+  }
+  return client;
+}
+function collectClientReferences(context, entryFiles) {
+  const references = new Map;
+  const visited = 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 = new Set) {
+  const key = path.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}\x00${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 = new Set;
+  const visited = new Set;
+  for (const file of entryFiles) {
+    collectCssFromFile(context, file, imports, visited);
+  }
+  if (!options.route || !getCssExtensions().deferRootNotFoundCss())
+    return [...imports];
+  const rootNotFound = entryFiles.find((file) => path.dirname(file) === context.appPath && /^not-found\.[^.]+$/.test(path.basename(file)));
+  if (!rootNotFound)
+    return [...imports];
+  const rootNotFoundImports = new Set;
+  collectCssFromFile(context, rootNotFound, rootNotFoundImports, new Set);
+  if (rootNotFoundImports.size === 0)
+    return [...imports];
+  const matchedImports = new Set;
+  for (const file of entryFiles) {
+    if (file === rootNotFound)
+      continue;
+    collectCssFromFile(context, file, matchedImports, new Set);
+  }
+  return [...imports].filter((file) => !rootNotFoundImports.has(file) || matchedImports.has(file));
+}
+function collectSourceFiles(context, entryFiles) {
+  const files = new Set;
+  const visited = 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 (isCssFile(file)) {
+    if (!context.globalCssImports().has(path.resolve(file)))
+      imports.add(file);
+    return;
+  }
+  const clientFile = isClientModule(context, file);
+  for (const imported of moduleEdges(context, file)) {
+    if (isCssFile(imported.file)) {
+      if (!context.globalCssImports().has(path.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 = new Set) {
+  const key = path.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 || !existsSync(resolved))
+      continue;
+    parts.push(readScanSource(context, resolved, visited));
+  }
+  return parts.join(`
+`);
+}
+function readSource(context, file) {
+  const key = path.resolve(file);
+  let source = context.sources.get(key);
+  if (source === undefined) {
+    source = rewriteLiteralDynamicCalls(readSourceSync(key), file);
+    context.sources.set(key, source);
+  }
+  return source;
+}
+var linkSpecifiers = new Set(["next/link", "@wular/pnext/link"]);
+var navigationSpecifiers = new Set([
+  ...linkSpecifiers,
+  "next/form",
+  "next/navigation",
+  "next/router",
+  "@wular/pnext/navigation",
+  "@wular/pnext/navigation/client"
+]);
+var rootNavigationExports = 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 = path.resolve(file);
+    let uses = context.usesLink.get(key);
+    if (uses === undefined) {
+      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 = path.resolve(file);
+    let uses = context.usesNavigation.get(key);
+    if (uses === undefined) {
+      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 = path.resolve(file);
+    let fileReasons = context.entryReasons.get(key);
+    if (fileReasons === undefined) {
+      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 = path.resolve(file);
+    let usesRequestImport = context.requestImportUsage.get(key);
+    if (usesRequestImport === undefined) {
+      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 = path.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}\x00${specifier}\x00${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, 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 = path.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 = escapeRegex(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 = escapeRegex(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 = escapeRegex(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 [
+    ...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 = 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 === undefined || fact.optionsEnd === undefined)
+    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 isCssFile(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(`
+`);
+  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;
+}
+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) : undefined;
+}
+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;
+  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${escapeRegex(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") ? path.dirname(path.dirname(appPath)) : path.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 escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { routeFactsVersion, routeFactsResolved, materializeRouteFacts, materializeRouteFactsPaced, setRouteFactsStore, scanRoutes, addClientEntryReason, collectNotFoundCss, collectFileCss, assertNoServerActionsWithoutCompat };