@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/server-mt4a994c.js

@@ -0,0 +1,1835 @@
+// @bun
+import {
+  contentType,
+  withForwardedHeaders
+} from "./index-5hr4062s.js";
+import {
+  DEFERRED_DYNAMIC_SIDECAR,
+  buildClientEntries,
+  buildClientEntry,
+  clientCacheKeyParts,
+  clientCacheStaticHash,
+  clientSourceHash,
+  deferredDynamicRefById,
+  prebuiltRuntimeDir,
+  registerDeferredDynamicRef
+} from "./index-nyrba2kr.js";
+import {
+  writeTypegen
+} from "./index-wpfhfbs4.js";
+import {
+  handleRouteModule
+} from "./index-qpwsgt3a.js";
+import {
+  assertNoServerActionsWithoutCompat,
+  materializeRouteFactsPaced,
+  routeFactsResolved,
+  routeFactsVersion,
+  scanRoutes,
+  setRouteFactsStore
+} from "./index-8k7pfejn.js";
+import {
+  clearDevRouteBundleKeys,
+  devClientModuleHref,
+  devClientReferenceGroups,
+  devClientReferenceModules,
+  devModuleGraph,
+  devRouteModuleLoaders,
+  devServerModuleHref,
+  drainPreplanBuilds,
+  importDevModule,
+  warmDevModulePipeline
+} from "./index-1011cscr.js";
+import {
+  getClientActionBundler
+} from "./index-n4hxpng2.js";
+import"./index-x3yn4ywm.js";
+import {
+  cacheRoot,
+  deferServerRuntimePlugins,
+  installServerRuntimePlugins,
+  registerServerRuntime,
+  setDevWatcherFreshness
+} from "./index-vvmmknm1.js";
+import"./index-91x12ykq.js";
+import {
+  clearMetadataFileCaches,
+  clientEntryName,
+  discoverStaticMetadataFiles,
+  errorLogTrace,
+  flushDevProfileLines,
+  formatProfileDuration,
+  internalErrorHtml,
+  metadataRouteHandlerModule,
+  recordDevProfileLine,
+  renderGlobalNotFoundResponse,
+  renderPageResponse,
+  staticMetadataCacheControl,
+  withDevReloadScript
+} from "./index-3tf1xjsp.js";
+import {
+  findLayouts,
+  matchRoute,
+  parseNavState,
+  selectRouteForRequest
+} from "./index-jepjvcrf.js";
+import {
+  applyProxyResponse,
+  createProxyRunner,
+  validateProxyFiles
+} from "./index-kq8kpzye.js";
+import {
+  serverBundleTargetForRuntime
+} from "./index-3xbr4eyv.js";
+import"./index-rn8dyr1f.js";
+import {
+  buildClientReferenceCss,
+  buildGlobalCss,
+  buildRouteCss,
+  clearGlobalCssSourceCache,
+  isCssFile,
+  setGlobalCssSourceStore,
+  warmCssPipeline
+} from "./index-2dv4y4wd.js";
+import {
+  formatDuration
+} from "./index-73z4esab.js";
+import"./index-y2jr2n72.js";
+import {
+  getFontExtensions,
+  nextCompatEnabled
+} from "./index-web361b8.js";
+import {
+  restartCacheEnabled
+} from "./index-knp0s912.js";
+import {
+  frameworkFingerprint
+} from "./index-c0g2wf3z.js";
+import {
+  escapeHtml
+} from "./index-ye9hmsvf.js";
+import {
+  setRequestRuntime
+} from "./index-z88qv16t.js";
+import"./index-fp8r0sqs.js";
+import"./index-cjgqs13g.js";
+import"./index-yhxkxghe.js";
+import"./index-fkp000p1.js";
+import"./index-p77b4kcx.js";
+import {
+  ensureDir,
+  exactNameIndex,
+  hasExactName,
+  listFiles,
+  writeFileAtomic,
+  writeText
+} from "./index-20ppawv7.js";
+import {
+  markBoot
+} from "./index-tq1f96v7.js";
+import {
+  traceEnabled
+} from "./index-vz0km5qk.js";
+import {
+  abortUpstreamFetchOnDisconnect,
+  bootstrapCompat,
+  bootstrapCompatBoot
+} from "./index-5gyr4emz.js";
+import"./index-y36a0ybw.js";
+import"./index-x93hv0sc.js";
+import {
+  markErrorLogged
+} from "./index-jcsjq3d1.js";
+import"./index-tqn2qnnn.js";
+import"./index-6kp9r0d9.js";
+import {
+  ssrClientReference
+} from "./index-ras0sdab.js";
+import {
+  flushWorkUnit,
+  flushWorkUnitOnClose,
+  getWorkUnit,
+  runWithWorkUnit,
+  setPhase,
+  setWorkUnitRoute
+} from "./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-z4z9zv3b.js";
+import {
+  clearAppTreeResolutions,
+  clearResolverFsCache,
+  workspacePackageRoots
+} from "./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import {
+  finalizeResponse,
+  getAssetExtensions,
+  getBundlerExtensions,
+  getRequestExtensions,
+  getRouterProtocolExtensions,
+  reportRequestError,
+  runInitHooks,
+  runRequestWarmHooks,
+  withRouteRuntime
+} from "./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-4399bvd2.js";
+import"./index-rt9qq1va.js";
+
+// src/dev/server.ts
+import { existsSync as existsSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { readFile as readFile3, readdir as readdir2, rm as rm2, stat as stat3, watch } from "fs/promises";
+import path5 from "path";
+
+// src/dev/restart/client-key.ts
+import { readFileSync, writeFileSync } from "fs";
+import { mkdir, readFile, stat } from "fs/promises";
+import path from "path";
+var INDEX_VERSION = 1;
+var caches = new Map;
+function keyCache(config) {
+  const file = path.join(config.outPath, "cache", "client", "keys.json");
+  const existing = caches.get(file);
+  if (existing)
+    return existing;
+  const created = { file, routes: readIndex(file), dirty: false, retries: 0 };
+  caches.set(file, created);
+  process.on("exit", () => {
+    if (!created.dirty)
+      return;
+    created.dirty = false;
+    try {
+      writeFileSync(created.file, serializeIndex(created.routes));
+    } catch {}
+  });
+  return created;
+}
+async function devClientCacheKey(config, route, nextCompat) {
+  if (!restartCacheEnabled())
+    return (await clientCacheKeyParts(route, nextCompat, config)).key;
+  const cache = keyCache(config);
+  const staticHash = clientCacheStaticHash(route, nextCompat, config);
+  const entry = cache.routes.get(route.id);
+  if (entry?.static === staticHash) {
+    const revalidated = await revalidate(entry.files);
+    if (revalidated) {
+      if (revalidated !== entry.files) {
+        cache.routes.set(route.id, { ...entry, files: revalidated });
+        persist(cache);
+      }
+      return entry.key;
+    }
+  }
+  const parts = await clientCacheKeyParts(route, nextCompat, config, staticHash);
+  cache.routes.set(route.id, {
+    static: parts.staticHash,
+    key: parts.key,
+    files: parts.sources.map(sourceEntry)
+  });
+  persist(cache);
+  return parts.key;
+}
+function sourceEntry(source) {
+  return [source.file, source.mtimeMs, source.size, source.hash];
+}
+async function revalidate(files) {
+  let moved = false;
+  const checked = await Promise.all(files.map(async (entry) => {
+    const [file, mtimeMs, size, hash] = entry;
+    const stats = await stat(file).catch(() => {
+      return;
+    });
+    if (!stats)
+      return;
+    if (stats.mtimeMs === mtimeMs && stats.size === size)
+      return entry;
+    const source = await readFile(file, "utf8").catch(() => {
+      return;
+    });
+    if (source === undefined || clientSourceHash(source) !== hash)
+      return;
+    moved = true;
+    return [file, stats.mtimeMs, stats.size, hash];
+  }));
+  if (checked.some((entry) => entry === undefined))
+    return;
+  return moved ? checked : files;
+}
+function persist(cache) {
+  cache.dirty = true;
+  if (cache.flush)
+    return;
+  cache.flush = setTimeout(async () => {
+    cache.flush = undefined;
+    if (!cache.dirty)
+      return;
+    const contents = serializeIndex(cache.routes);
+    try {
+      await mkdir(path.dirname(cache.file), { recursive: true });
+      await writeFileAtomic(cache.file, contents);
+      cache.dirty = false;
+    } catch {
+      if (++cache.retries < 3)
+        persist(cache);
+    }
+  }, 50);
+  cache.flush.unref?.();
+}
+function readIndex(file) {
+  const routes = new Map;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return routes;
+  }
+  if (parsed?.version !== INDEX_VERSION)
+    return routes;
+  for (const [id, entry] of Object.entries(parsed.routes ?? {})) {
+    if (entry?.key && entry.static && Array.isArray(entry.files))
+      routes.set(id, entry);
+  }
+  return routes;
+}
+function serializeIndex(routes) {
+  return JSON.stringify({
+    version: INDEX_VERSION,
+    routes: Object.fromEntries(routes)
+  });
+}
+
+// src/dev/client-chunk-store.ts
+import { createHash } from "crypto";
+import { link, mkdir as mkdir2, readFile as readFile2, readdir, rm, stat as stat2, unlink } from "fs/promises";
+import path2 from "path";
+function clientChunkStoreDir(outPath) {
+  return path2.join(outPath, "cache", "client-store");
+}
+function contentHash(data) {
+  return createHash("sha1").update(data).digest("hex");
+}
+async function contentAddressDir(dir, storeDir) {
+  await mkdir2(storeDir, { recursive: true });
+  const files = await listFiles(dir);
+  await Promise.all(files.map((file) => contentAddressFile(file, storeDir)));
+}
+async function contentAddressFile(file, storeDir) {
+  const data = await readFile2(file);
+  const storePath = path2.join(storeDir, `${contentHash(data)}${path2.extname(file)}`);
+  if (!await pathExists(storePath)) {
+    try {
+      await link(file, storePath);
+      return;
+    } catch {
+      await copyFileFallback(file, storePath);
+      return;
+    }
+  }
+  try {
+    await unlink(file);
+    await link(storePath, file);
+  } catch {}
+}
+async function copyFileFallback(file, storePath) {
+  try {
+    const data = await readFile2(file);
+    await Bun.write(storePath, data);
+  } catch {}
+}
+async function pathExists(target) {
+  return stat2(target).then(() => true).catch(() => false);
+}
+async function sweepClientChunkStore(storeDir) {
+  let entries;
+  try {
+    entries = await readdir(storeDir);
+  } catch {
+    return;
+  }
+  await Promise.allSettled(entries.map(async (entry) => {
+    const full = path2.join(storeDir, entry);
+    const info = await stat2(full).catch(() => null);
+    if (info && info.nlink <= 1)
+      await rm(full, { force: true });
+  }));
+}
+
+// src/dev/restart/route-facts.ts
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import path3 from "path";
+
+// src/dev/restart/record.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+var hash = (value) => Bun.hash(value).toString(36);
+function recordCacheKey(config, version) {
+  try {
+    const shape = JSON.stringify(config, (_key, value) => typeof value === "function" ? "[fn]" : value);
+    return hash(`${version}
+${frameworkFingerprint(cacheRoot(config.outPath))}
+${shape}`);
+  } catch {
+    return;
+  }
+}
+function lazyRecordCacheKey(config, version) {
+  let key;
+  let computed = false;
+  return () => {
+    if (!computed) {
+      computed = true;
+      key = recordCacheKey(config, version);
+    }
+    return key;
+  };
+}
+function sourceEntries(files) {
+  const entries = [];
+  for (const file of files) {
+    const entry = sourceEntry2(file);
+    if (!entry)
+      return;
+    entries.push(entry);
+  }
+  return entries;
+}
+function sourceEntry2(file) {
+  try {
+    const source = readFileSync2(file, "utf8");
+    const info = statSync(file, { throwIfNoEntry: false });
+    if (!info)
+      return;
+    return [file, info.mtimeMs, info.size, hash(source)];
+  } catch {
+    return;
+  }
+}
+function revalidate2(files) {
+  let moved = false;
+  const checked = [];
+  for (const entry of files) {
+    const [file, mtimeMs, size, contentHash2] = entry;
+    const info = statSync(file, { throwIfNoEntry: false });
+    if (!info)
+      return;
+    if (info.mtimeMs === mtimeMs && info.size === size) {
+      checked.push(entry);
+      continue;
+    }
+    let source;
+    try {
+      source = readFileSync2(file, "utf8");
+    } catch {
+      return;
+    }
+    if (hash(source) !== contentHash2)
+      return;
+    moved = true;
+    checked.push([file, info.mtimeMs, info.size, contentHash2]);
+  }
+  return moved ? checked : files;
+}
+
+// src/dev/restart/route-facts.ts
+var RECORD_VERSION = 1;
+function installRouteFactsCache(config) {
+  if (!restartCacheEnabled())
+    return;
+  if (process.env.PNEXT_DEV_FACTS_CACHE === "0")
+    return;
+  const cache = {
+    dir: path3.join(config.outPath, "cache", "route-facts"),
+    key: lazyRecordCacheKey(config, RECORD_VERSION),
+    written: new Set
+  };
+  setRouteFactsStore(createStore(cache));
+}
+function recordFile(cache, routeId) {
+  return path3.join(cache.dir, `${hash(routeId)}.json`);
+}
+function createStore(cache) {
+  return {
+    load(routeId) {
+      const record = readRecord(cache, routeId);
+      if (!record) {
+        stats.misses += 1;
+        return;
+      }
+      const revalidated = revalidate2(record.files);
+      if (!revalidated) {
+        stats.misses += 1;
+        return;
+      }
+      stats.hits += 1;
+      if (revalidated !== record.files) {
+        cache.written.delete(routeId);
+        write(cache, routeId, revalidated, record.facts);
+      }
+      return record.facts;
+    },
+    save(routeId, facts) {
+      const files = factsSources(facts);
+      if (!files)
+        return;
+      write(cache, routeId, files, facts);
+    }
+  };
+}
+function readRecord(cache, routeId) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(recordFile(cache, routeId), "utf8"));
+  } catch {
+    return;
+  }
+  if (parsed?.version !== RECORD_VERSION || parsed.key !== cache.key())
+    return;
+  if (!parsed.facts || !Array.isArray(parsed.files))
+    return;
+  return parsed;
+}
+function write(cache, routeId, files, facts) {
+  const key = cache.key();
+  if (!key || cache.written.has(routeId))
+    return;
+  cache.written.add(routeId);
+  const contents = JSON.stringify({
+    version: RECORD_VERSION,
+    key,
+    files,
+    facts
+  });
+  try {
+    mkdirSync(cache.dir, { recursive: true });
+    writeFileSync2(recordFile(cache, routeId), contents);
+  } catch {}
+}
+function factsSources(facts) {
+  const entries = [];
+  for (const file of facts.sourceFiles) {
+    const entry = sourceEntry2(file);
+    if (!entry)
+      return;
+    entries.push(entry);
+  }
+  return entries;
+}
+var stats = { hits: 0, misses: 0 };
+if (traceEnabled("server")) {
+  process.on("exit", () => console.log(`route-facts hits=${stats.hits} misses=${stats.misses}`));
+}
+
+// src/dev/restart/global-css.ts
+import { mkdirSync as mkdirSync2, existsSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import path4 from "path";
+var RECORD_VERSION2 = 1;
+function installGlobalCssCache(config) {
+  if (!restartCacheEnabled())
+    return;
+  if (process.env.PNEXT_DEV_GLOBAL_CSS_CACHE === "0")
+    return;
+  const dir = path4.join(config.outPath, "cache", "global-css");
+  setGlobalCssSourceStore(createStore2(dir, lazyRecordCacheKey(config, RECORD_VERSION2)));
+}
+function createStore2(dir, cacheKey) {
+  const written = new Map;
+  const recordFile2 = (walkKey) => path4.join(dir, `${hash(walkKey)}.json`);
+  return {
+    load(walkKey) {
+      const key = cacheKey();
+      const record = key ? readRecord2(recordFile2(walkKey), key) : undefined;
+      if (!key || !record) {
+        stats2.misses += 1;
+        return;
+      }
+      if (record.missing.some((file) => existsSync(file))) {
+        stats2.misses += 1;
+        return;
+      }
+      const revalidated = revalidate2(record.files);
+      if (!revalidated) {
+        stats2.misses += 1;
+        return;
+      }
+      stats2.hits += 1;
+      if (revalidated !== record.files) {
+        write2(recordFile2(walkKey), key, written, walkKey, revalidated, record.missing, record.sources);
+      }
+      return record.sources;
+    },
+    save(walkKey, sources, visited, missing) {
+      const key = cacheKey();
+      if (!key)
+        return;
+      const files = sourceEntries(visited);
+      if (!files)
+        return;
+      write2(recordFile2(walkKey), key, written, walkKey, files, missing, sources);
+    }
+  };
+}
+function readRecord2(file, key) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(file, "utf8"));
+  } catch {
+    return;
+  }
+  if (parsed?.version !== RECORD_VERSION2 || parsed.key !== key)
+    return;
+  if (!Array.isArray(parsed.files) || !Array.isArray(parsed.sources))
+    return;
+  if (!Array.isArray(parsed.missing))
+    return;
+  return parsed;
+}
+function write2(file, key, written, walkKey, files, missing, sources) {
+  const contents = JSON.stringify({
+    version: RECORD_VERSION2,
+    key,
+    files,
+    missing,
+    sources
+  });
+  if (written.get(walkKey) === contents)
+    return;
+  written.set(walkKey, contents);
+  try {
+    mkdirSync2(path4.dirname(file), { recursive: true });
+    writeFileSync3(file, contents);
+  } catch {}
+}
+var stats2 = { hits: 0, misses: 0 };
+if (traceEnabled("server")) {
+  process.on("exit", () => console.log(`global-css hits=${stats2.hits} misses=${stats2.misses}`));
+}
+
+// src/dev/server.ts
+import { malformedUrlResponse, repeatedSlashRedirect, trailingSlashRedirect } from "../../../src/routing/href.ts";
+import { runWithCacheScope } from "../../../src/request/cache.ts";
+var DEV_IDLE_TIMEOUT_SECONDS = 60;
+var DEV_IDLE_TIMEOUT_MS = DEV_IDLE_TIMEOUT_SECONDS * 1000;
+var DEV_PAGE_STALL_WARNING_MS = 20000;
+var clientBuilds = new Map;
+var clientChunks = new Map;
+var clientBuildStopWaiters = new Set;
+function failInFlightClientBuilds(reason) {
+  const err = new Error(reason);
+  for (const reject of clientBuildStopWaiters)
+    reject(err);
+  clientBuildStopWaiters.clear();
+  clientBuilds.clear();
+}
+var indexedClientDirs = new Set;
+var routeLayoutFiles = new Map;
+var assetBuilds = new Map;
+var routeCacheKeys = new Map;
+var appKey = (outPath, key) => `${outPath}\x00${key}`;
+function clearAppKeyed(map, outPath) {
+  for (const key of map.keys())
+    if (key.startsWith(`${outPath}\x00`))
+      map.delete(key);
+}
+var compiledRoutes = new Set;
+function invalidateDevCaches(config, changed, structural) {
+  devModuleGraph(config).invalidate(changed);
+  if (structural) {
+    clearResolverFsCache();
+    clearAppTreeResolutions();
+    clearMetadataFileCaches();
+    routeLayoutFiles.clear();
+  }
+  clearGlobalCssSourceCache();
+  clearDevRouteBundleKeys();
+  clearAppKeyed(assetBuilds, config.outPath);
+  clearAppKeyed(routeCacheKeys, config.outPath);
+  indexedClientDirs.clear();
+  compiledRoutes.clear();
+  evictStaleClientCaches(config.outPath);
+}
+async function evictStaleClientCaches(outPath) {
+  const keep = Number(process.env.PNEXT_DEV_CLIENT_CACHE_KEEP || 32);
+  if (!Number.isFinite(keep) || keep <= 0)
+    return;
+  const clientRoot = path5.join(outPath, "cache", "client");
+  try {
+    const entries = await readdir2(clientRoot);
+    if (entries.length <= keep)
+      return;
+    const dated = await Promise.all(entries.map(async (entry) => {
+      const full = path5.join(clientRoot, entry);
+      const info = await stat3(full).catch(() => null);
+      return { full, mtime: info?.mtimeMs ?? 0 };
+    }));
+    dated.sort((a, b) => b.mtime - a.mtime);
+    await Promise.allSettled(dated.slice(keep).map((entry) => rm2(entry.full, { recursive: true, force: true })));
+    await sweepClientChunkStore(clientChunkStoreDir(outPath));
+  } catch {}
+}
+async function removeLeakedStaleCaches(outPath) {
+  try {
+    const entries = await readdir2(outPath);
+    await Promise.allSettled(entries.filter((entry) => entry.startsWith(".cache-stale-")).map((entry) => rm2(path5.join(outPath, entry), { recursive: true, force: true })));
+  } catch {}
+}
+async function startDevServer(options) {
+  const { config, port, hostname } = options;
+  const bootTime = Date.now();
+  warmCssPipeline(config, { dev: true });
+  markBoot("boot:css-warm");
+  await bootstrapCompatBoot(config);
+  markBoot("boot:compat");
+  deferServerRuntimePlugins();
+  registerServerRuntime(config);
+  runInitHooks(config);
+  removeLeakedStaleCaches(config.outPath);
+  evictStaleClientCaches(config.outPath);
+  installRouteFactsCache(config);
+  installGlobalCssCache(config);
+  markBoot("boot:registry");
+  let routes = await scanRoutes(config.appPath, config.workspaceRoot);
+  setDevClientRoutes(config, routes);
+  markBoot("boot:scanRoutes");
+  await validateProxyFiles(config);
+  let proxyRunner = createProxyRunner(config);
+  const exactNames = exactNameIndex(config.root);
+  markBoot("boot:proxy");
+  let devImportVersion = String(Date.now());
+  if (restartCacheEnabled())
+    proxyRunner.warm({ dev: true, devImportVersion });
+  markBoot("boot:proxy-warm");
+  publishRuntime();
+  const clients = new Set;
+  let generation = 0;
+  let watcher;
+  let inFlight = 0;
+  function publishRuntime() {
+    setRequestRuntime({ config, routes, dev: true, devImportVersion });
+  }
+  const TYPEGEN_MAX_WAIT_MS = 3000;
+  async function typegenPause() {
+    if (process.env.PNEXT_DEV_TYPEGEN_PACE === "0")
+      return;
+    const deadline = performance.now() + TYPEGEN_MAX_WAIT_MS;
+    do {
+      await new Promise((resolve) => setTimeout(resolve, inFlight > 0 ? 25 : 0));
+    } while (inFlight > 0 && performance.now() < deadline);
+  }
+  async function typegenInBackground() {
+    const generation2 = routes;
+    try {
+      await writeTypegen(config, await materializeRouteFactsPaced(generation2, typegenPause));
+    } catch (error) {
+      if (generation2 === routes)
+        logDevPreloadError("typegen", error);
+    }
+    if (generation2 === routes)
+      syncWatchRoots();
+  }
+  async function reload(change) {
+    const structural = change.renamed && change.files.some((file) => !existsSync2(file) || !devModuleGraph(config).knows(file));
+    invalidateDevCaches(config, change.files, structural);
+    if (isCssOnlyChange(change.files)) {
+      generation++;
+      broadcast(clients, "css-update");
+      return;
+    }
+    if (structural) {
+      routes = await scanRoutes(config.appPath, config.workspaceRoot);
+      setDevClientRoutes(config, routes);
+    }
+    await validateProxyFiles(config);
+    proxyRunner = createProxyRunner(config);
+    devImportVersion = `${Date.now()}`;
+    proxyRunner.warm({ dev: true, devImportVersion });
+    publishRuntime();
+    typegenInBackground();
+    watchedFactsVersion = -1;
+    syncWatchRoots();
+    generation++;
+    broadcast(clients, "reload");
+  }
+  function eagerInvalidate(file) {
+    devModuleGraph(config).invalidate([file]);
+    clearDevRouteBundleKeys();
+    clearAppKeyed(routeCacheKeys, config.outPath);
+  }
+  let watchedFactsVersion = -1;
+  function syncWatchRoots() {
+    if (watchedFactsVersion === routeFactsVersion())
+      return;
+    watchedFactsVersion = routeFactsVersion();
+    watcher = refreshWatcher(config, routes, watcher, reload, bootTime, eagerInvalidate);
+  }
+  syncWatchRoots();
+  markBoot("boot:watcher");
+  const server = Bun.serve({
+    hostname,
+    port,
+    idleTimeout: DEV_IDLE_TIMEOUT_SECONDS,
+    fetch(request, server2) {
+      inFlight++;
+      return runWithWorkUnit("render", () => handleDevRequest(request, server2)).catch((error) => devLastResortResponse(error, request)).finally(() => {
+        inFlight--;
+      });
+    },
+    error: (error) => devLastResortError(error)
+  });
+  async function handleDevRequest(request, server2) {
+    const prologueStart = performance.now();
+    await bootstrapCompat(config, { serve: true });
+    installServerRuntimePlugins();
+    const unit = getWorkUnit();
+    const badRequest = malformedUrlResponse(request);
+    if (badRequest)
+      return badRequest;
+    request = withForwardedHeaders(request, server2);
+    let url = new URL(request.url);
+    const slashRedirect = repeatedSlashRedirect(url);
+    if (slashRedirect)
+      return slashRedirect;
+    const profile = devRequestProfile(request, url);
+    if (profile)
+      logDevProfile(profile, "prologue (bootstrap/headers/url)", prologueStart);
+    let pageLog = startDevPageStallTimer(pendingDevPageLoadLog(routes, request, url));
+    let afterResponse;
+    const logAbort = () => {
+      const pending = pageLog;
+      pageLog = undefined;
+      logDevPageAbort(pending);
+    };
+    request.signal.addEventListener("abort", logAbort, { once: true });
+    const finish = async (response) => {
+      const pending = pageLog;
+      pageLog = undefined;
+      request.signal.removeEventListener("abort", logAbort);
+      const finalized = await profileDevStep(profile, "finalize response", () => finalizeResponse(response, { method: request.method, url: new URL(request.url), headers: request.headers }, { routeKind: unit?.routeKind ?? "html", routeMode: unit?.routeMode, dev: true }));
+      const logged = logDevPageResponse(pending, finalized);
+      const tasks = afterResponse;
+      afterResponse = undefined;
+      setTimeout(() => {
+        tasks?.();
+        syncWatchRoots();
+      }, 0);
+      if (profile)
+        flushDevProfileLines();
+      abortUpstreamFetchOnDisconnect(logged.body, request.signal);
+      return flushWorkUnitOnClose(logged, unit, request.signal);
+    };
+    try {
+      const canonicalRedirect = trailingSlashRedirect(config, url);
+      if (canonicalRedirect)
+        return finish(canonicalRedirect);
+      const initialPrefetchResponse = maybeDevPagePrefetchResponse(routes, url.pathname, request);
+      if (initialPrefetchResponse)
+        return finish(initialPrefetchResponse);
+      let proxyResponse;
+      const proxyResult = await profileDevStep(profile, "proxy", () => proxyRunner(request, { dev: true, devImportVersion }));
+      if (proxyResult instanceof Response)
+        return finish(proxyResult);
+      if (proxyResult) {
+        request = proxyResult.request;
+        proxyResponse = proxyResult.response;
+        url = new URL(request.url);
+        const rewrittenLog = pendingDevPageLoadLog(routes, request, url, pageLog?.start);
+        clearDevPageStallTimer(pageLog);
+        pageLog = startDevPageStallTimer(rewrittenLog);
+        const rewrittenPrefetchResponse = maybeDevPagePrefetchResponse(routes, url.pathname, request);
+        if (rewrittenPrefetchResponse)
+          return finish(applyProxyResponse(rewrittenPrefetchResponse, proxyResponse));
+      }
+      if (url.pathname === "/__pnext/events") {
+        server2.timeout(request, 0);
+        return finish(eventStream(clients, generation));
+      }
+      const assetResponse = await profileDevStep(profile, "built asset lookup", () => maybeBuiltAsset(config, routes, url.pathname));
+      if (assetResponse)
+        return finish(applyProxyResponse(assetResponse, proxyResponse));
+      const clientChunkResponse = await profileDevStep(profile, "client chunk lookup", () => maybeDevClientChunk(config, url.pathname));
+      if (clientChunkResponse)
+        return finish(applyProxyResponse(clientChunkResponse, proxyResponse));
+      const runtimeResponse = maybePrebuiltRuntime(config, url.pathname);
+      if (runtimeResponse)
+        return finish(applyProxyResponse(runtimeResponse, proxyResponse));
+      const dynChunkMatch = /^\/__pnext\/client-dyn\/([A-Za-z0-9-]+)\.js$/.exec(url.pathname);
+      if (dynChunkMatch?.[1]) {
+        const id = dynChunkMatch[1];
+        const file = await profileDevStep(profile, `client dyn chunk ${id}`, () => devDynamicEntryFile(config, routes, id, url.searchParams.get("r")));
+        if (!file)
+          return finish(applyProxyResponse(new Response("not found", { status: 404 }), proxyResponse));
+        return finish(applyProxyResponse(devResponse(await readFile3(file), "text/javascript; charset=utf-8"), proxyResponse));
+      }
+      const clientMatch = /^\/__pnext\/client\/(.+)\.js$/.exec(url.pathname);
+      if (clientMatch?.[1]) {
+        const route = routes.find((item) => item.id === clientMatch[1] && (item.client || item.clientReferences.length > 0 || item.needsRouterEntry));
+        if (!route)
+          return finish(applyProxyResponse(new Response("not found", { status: 404 }), proxyResponse));
+        const file = await profileDevStep(profile, `client build ${route.route}`, () => buildDevClient(config, route));
+        return finish(applyProxyResponse(devResponse(await profileDevStep(profile, "client read", () => readFile3(file)), "text/javascript; charset=utf-8"), proxyResponse));
+      }
+      const metadataFile = await profileDevStep(profile, "static metadata file", () => maybeStaticMetadataFile(config, url));
+      if (metadataFile) {
+        setWorkUnitRoute("static-asset");
+        return finish(applyProxyResponse(metadataFile, proxyResponse));
+      }
+      const staticResponse = await profileDevStep(profile, "static lookup", () => maybeStaticFile(config.publicPath, url.pathname, exactNames));
+      if (staticResponse) {
+        setWorkUnitRoute("static-asset", "static");
+        return finish(applyProxyResponse(staticResponse, proxyResponse));
+      }
+      if (getAssetExtensions().staticAssetPublicPrefixes().some((prefix) => url.pathname.startsWith(prefix))) {
+        const emitted = await maybeStaticFile(path5.join(config.outPath, "public"), url.pathname, exactNames);
+        if (emitted) {
+          setWorkUnitRoute("static-asset", "static");
+          return finish(applyProxyResponse(emitted, proxyResponse));
+        }
+      }
+      const staticAssetPathname = getNextStaticAssetPathname(url.pathname, config.basePath, config.assetPrefix);
+      if (staticAssetPathname) {
+        const outPublicStatic = await maybeStaticFile(path5.join(config.outPath, "public"), staticAssetPathname, exactNames);
+        if (outPublicStatic) {
+          setWorkUnitRoute("static-asset", "static");
+          return finish(applyProxyResponse(outPublicStatic, proxyResponse));
+        }
+        const staticChunk = maybeStaticClientChunk(config, staticAssetPathname);
+        if (staticChunk) {
+          setWorkUnitRoute("static-asset", "static");
+          return finish(applyProxyResponse(staticChunk, proxyResponse));
+        }
+        setWorkUnitRoute("static-asset", "static");
+        return finish(applyProxyResponse(new Response("Not Found", {
+          status: 404,
+          headers: {
+            "cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+            "content-type": "text/plain;charset=utf-8"
+          }
+        }), proxyResponse));
+      }
+      const canonicalRequest = request;
+      const canonicalUrl = new URL(request.url);
+      for (const [index, interceptor] of getRequestExtensions().interceptors.entries()) {
+        const result = await profileDevStep(profile, `interceptor ${interceptor.name || index}`, () => interceptor(request, { config }));
+        if (result instanceof Response)
+          return finish(applyProxyResponse(result, proxyResponse));
+        if (result) {
+          request = result.request;
+          url = new URL(request.url);
+        }
+      }
+      const nav = parseNavState(request);
+      const matched = profileDevSyncStep(profile, "match route", () => selectRouteForRequest(routes, url.pathname, nav));
+      if (!matched) {
+        return finish(applyProxyResponse(await renderGlobalNotFoundResponse({
+          config,
+          url,
+          request: canonicalRequest,
+          dev: true,
+          devImportVersion
+        }), proxyResponse));
+      }
+      if (matched.route.kind === "handler") {
+        setWorkUnitRoute("route-handler");
+        setPhase("handler");
+        return finish(applyProxyResponse(await profileDevStep(profile, `handler ${matched.route.route}`, () => handleRoute(config, matched.route, canonicalRequest, matched.params, devImportVersion)), proxyResponse));
+      }
+      setWorkUnitRoute("html", matched.route.mode === "static" ? "static" : "dynamic");
+      assertNoServerActionsWithoutCompat([matched.route], nextCompatEnabled(config), config.root);
+      pageRequestsSeen++;
+      noteDevCompileStart(matched.route);
+      noteDevRouteServed(config, matched.route);
+      const eagerClient = !deferClientStage();
+      if (eagerClient)
+        preloadDevClient(config, matched.route, profile);
+      const preloadAssets = () => {
+        preloadDevPageAssets(config, matched.route, profile);
+        if (!eagerClient)
+          preloadDevClient(config, matched.route, profile);
+      };
+      afterResponse = preloadAssets;
+      if (!deferAssetPreload()) {
+        afterResponse = undefined;
+        preloadAssets();
+      }
+      const layoutFiles = profileDevSyncStep(profile, "find layouts", () => devLayoutFiles(config, matched.route.file));
+      let loaders;
+      preloadDevClientReferences(config, matched.route, profile);
+      try {
+        loaders = await profileDevStep(profile, `route module loaders ${matched.route.route}`, () => devRouteModuleLoaders(config, matched.route, layoutFiles));
+      } catch (error) {
+        logDevRouteLoaderFallback(matched.route, error);
+      }
+      preloadDevFonts(config, profile);
+      return finish(applyProxyResponse(await profileDevStep(profile, `render page ${matched.route.route}`, () => withRouteRuntime(matched.route.segmentConfig?.runtime, () => renderPageResponse({
+        config,
+        route: matched.route,
+        params: matched.params,
+        url: canonicalUrl,
+        request: request.method.toUpperCase() === "POST" ? new Request(canonicalRequest.url, { headers: canonicalRequest.headers }) : canonicalRequest,
+        dev: true,
+        devImportVersion,
+        layoutFiles,
+        moduleLoader: loaders?.moduleLoader,
+        clientModuleLoader: loaders?.clientModuleLoader,
+        ...nav ? {
+          nav: {
+            soft: true,
+            state: nav,
+            childrenPath: matched.childrenPath,
+            targetPath: matched.targetPath
+          }
+        } : {}
+      }))), proxyResponse));
+    } catch (error) {
+      request.signal.removeEventListener("abort", logAbort);
+      await reportRequestError(error, { method: request.method, url: request.url, headers: request.headers }, { phase: unit?.phase, routeKind: unit?.routeKind });
+      logDevPageError(pageLog);
+      flushWorkUnit(unit);
+      return devLastResortResponse(error, request);
+    }
+  }
+  const warmup = options.warm ? afterReady(() => warmDev(config, routes)).catch((error) => logDevPreloadError("warm", error)) : undefined;
+  Promise.resolve(warmup).then(typegenInBackground);
+  return Object.assign(server, { warmup });
+}
+function devLastResortResponse(error, request) {
+  let route = request.url;
+  try {
+    route = new URL(request.url).pathname;
+  } catch {}
+  return devLastResortError(error, route, request.url, request);
+}
+function devLastResortError(error, route = "(unknown)", url = route, request) {
+  const resolved = error instanceof Error ? error : new Error(String(error));
+  if (markErrorLogged(resolved))
+    console.error(errorLogTrace(resolved));
+  let html;
+  try {
+    html = internalErrorHtml({
+      error: resolved,
+      route,
+      url,
+      digest: resolved.digest
+    });
+  } catch {
+    html = `<!DOCTYPE html><html><head><meta charset="utf-8"><title>pnext error</title></head><body><h1>pnext could not render this request</h1><pre>${escapeHtml(resolved.stack ?? resolved.message)}</pre></body></html>`;
+  }
+  return new Response(withDevReloadScript(html, request), {
+    status: 500,
+    headers: { "content-type": "text/html; charset=utf-8" }
+  });
+}
+function afterReady(task) {
+  return new Promise((resolve) => setTimeout(() => resolve(task()), 0));
+}
+async function warmDev(config, routes) {
+  await bootstrapCompat(config, { serve: true });
+  installServerRuntimePlugins();
+  runRequestWarmHooks(config);
+  await warmDevModulePipeline(config);
+  await warmDevRoutes(config, routes);
+}
+var WARM_ROUTES = 3;
+var pageRequestsSeen = 0;
+async function warmDevRoutes(config, routes) {
+  const wanted = readDevRouteHistory(config).map((id) => routes.find((route) => route.id === id && route.kind === "page")).filter((route) => Boolean(route)).slice(0, WARM_ROUTES);
+  if (wanted.length === 0)
+    return;
+  if (deferAssetPreload() && pageRequestsSeen > 0)
+    return;
+  await buildDevAsset(config, "/assets/global.css", () => buildGlobalCss(config, { dev: true }));
+  for (const route of wanted) {
+    if (pageRequestsSeen > 0)
+      return;
+    await warmDevRoute(config, route).catch(() => {
+      return;
+    });
+  }
+}
+async function warmDevRoute(config, route) {
+  noteDevCompileStart(route);
+  const start = performance.now();
+  const layoutFiles = devLayoutFiles(config, route.file);
+  const hasClient = route.client || route.clientReferences.length > 0;
+  await Promise.allSettled([
+    route.cssImports.length > 0 ? buildDevAsset(config, `/assets/${route.id}.css`, () => buildRouteCss(config, route, { dev: true })) : Promise.resolve(),
+    devRouteModuleLoaders(config, route, layoutFiles),
+    hasClient ? buildDevClient(config, route) : Promise.resolve(),
+    warmDevClientReferences(config, route),
+    warmDevPageModule(config, route)
+  ]);
+  noteDevCompileDone(route, performance.now() - start);
+}
+async function warmDevPageModule(config, route) {
+  if (process.env.PNEXT_DEV_WARM_PAGE_MODULE === "0" || !route.client || route.kind !== "page") {
+    return;
+  }
+  const href = await devServerModuleHref(config, route.file, undefined, {
+    conditionTarget: serverBundleTargetForRuntime(route.segmentConfig?.runtime)
+  });
+  await drainPreplanBuilds();
+  await import(href);
+}
+async function warmDevClientReferences(config, route) {
+  if (process.env.PNEXT_DEV_WARM_CLIENT_REFS === "0")
+    return;
+  const evaluate = process.env.PNEXT_DEV_PRELOAD_REF_IMPORTS !== "0";
+  const target = serverBundleTargetForRuntime(route.segmentConfig?.runtime);
+  const { batched, perModule } = devClientReferenceGroups(config, route);
+  await Promise.allSettled([
+    batched.length > 0 ? devClientReferenceModules(config, route, { evaluate }).catch((error) => {
+      console.debug(`PNext dev warm failed for the client references of ${route.route}; falling back to per-module loading.`, error);
+      throw error;
+    }) : Promise.resolve(),
+    ...perModule.map(async (file) => {
+      const href = await devClientModuleHref(config, file, undefined, target);
+      if (evaluate) {
+        try {
+          await importDevModule(href, { warm: true });
+        } catch (error) {
+          console.debug(`PNext dev warm evaluation failed for client reference ${file}.`, error);
+          throw error;
+        }
+      }
+    })
+  ]);
+}
+var HISTORY_LIMIT = 8;
+var history;
+var historyWrite;
+function historyFile(config) {
+  return path5.join(cacheRoot(config.outPath), "warm.json");
+}
+function readDevRouteHistory(config) {
+  if (history)
+    return history;
+  try {
+    const parsed = JSON.parse(readFileSync5(historyFile(config), "utf8"));
+    history = Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : [];
+  } catch {
+    history = [];
+  }
+  return history;
+}
+function noteDevRouteServed(config, route) {
+  if (route.kind !== "page")
+    return;
+  const seen = readDevRouteHistory(config);
+  if (seen[0] === route.id)
+    return;
+  history = [route.id, ...seen.filter((id) => id !== route.id)].slice(0, HISTORY_LIMIT);
+  if (historyWrite)
+    return;
+  historyWrite = setTimeout(() => {
+    historyWrite = undefined;
+    writeText(historyFile(config), JSON.stringify(history ?? [])).catch(() => {
+      return;
+    });
+  }, 500);
+  historyWrite.unref?.();
+}
+function logDevRouteLoaderFallback(route, error) {
+  console.error([
+    `PNext dev route bundle failed for ${route.route}; falling back to per-module loading.`,
+    error instanceof Error ? error.stack ?? error.message : String(error)
+  ].join(`
+`));
+}
+function devRequestProfile(request, url) {
+  if (!traceEnabled("server"))
+    return;
+  return {
+    label: `${request.method} ${url.pathname}`,
+    start: performance.now()
+  };
+}
+async function profileDevStep(profile, label, task) {
+  if (!profile)
+    return task();
+  const start = performance.now();
+  try {
+    return await task();
+  } finally {
+    logDevProfile(profile, label, start);
+  }
+}
+function profileDevSyncStep(profile, label, task) {
+  if (!profile)
+    return task();
+  const start = performance.now();
+  try {
+    return task();
+  } finally {
+    logDevProfile(profile, label, start);
+  }
+}
+function logDevProfile(profile, label, start) {
+  const end = performance.now();
+  recordDevProfileLine(`dev-profile ${profile.label} ${label} in ${formatProfileDuration(end - start)} (@${formatProfileDuration(start - profile.start)}..+${formatProfileDuration(end - profile.start)})`);
+}
+async function handleRoute(config, route, request, params, devImportVersion) {
+  const routeHref = await devServerModuleHref(config, route.file, devImportVersion, {
+    conditionTarget: serverBundleTargetForRuntime(route.segmentConfig?.runtime)
+  });
+  await drainPreplanBuilds();
+  const imported = await import(routeHref);
+  const module = metadataRouteHandlerModule(imported, route) ?? imported;
+  return withRouteRuntime(route.segmentConfig?.runtime, () => runWithCacheScope(() => handleRouteModule(module, request, params, { routeFile: route.file })));
+}
+function routeClientCacheKey(config, route) {
+  const existing = routeCacheKeys.get(appKey(config.outPath, route.id));
+  if (existing)
+    return existing;
+  const key = devClientCacheKey(config, route, Boolean(config.compat?.next));
+  routeCacheKeys.set(appKey(config.outPath, route.id), key);
+  return key;
+}
+function preloadDevClient(config, route, profile) {
+  if (!route.client && route.clientReferences.length === 0 && !route.needsRouterEntry)
+    return;
+  profileDevStep(profile, `client preload ${route.route}`, () => buildDevClient(config, route)).catch((error) => logDevPreloadError(`client build for ${route.route}`, error)).finally(() => {
+    if (profile)
+      flushDevProfileLines();
+  });
+}
+function preloadDevClientReferences(config, route, profile) {
+  if (process.env.PNEXT_DEV_PRELOAD_REFS === "0")
+    return;
+  if (route.clientReferences.length > 0) {
+    profileDevStep(profile, `client references preload ${route.route}`, () => warmDevClientReferences(config, route)).catch((error) => logDevPreloadError(`client references for ${route.route}`, error));
+  }
+  profileDevStep(profile, `page module preload ${route.route}`, () => warmDevPageModule(config, route)).then(() => preloadDevFonts(config, profile)).catch((error) => logDevPreloadError(`page module for ${route.route}`, error));
+}
+function preloadDevFonts(config, profile) {
+  return profileDevStep(profile, "font prewarm", () => getFontExtensions().prewarmFontAssets(config, { dev: true })).catch((error) => logDevPreloadError("font prewarm", error));
+}
+function deferClientStage() {
+  return process.env.PNEXT_DEV_CLIENT_STAGE !== "eager";
+}
+function deferAssetPreload() {
+  return process.env.PNEXT_DEV_ASSET_PRELOAD !== "eager";
+}
+function preloadDevPageAssets(config, route, profile) {
+  profileDevStep(profile, "asset preload /assets/global.css", () => buildDevAsset(config, "/assets/global.css", () => buildGlobalCss(config, { dev: true }))).catch((error) => logDevPreloadError("global css build", error));
+  if (route.cssImports.length === 0)
+    return;
+  profileDevStep(profile, `asset preload /assets/${route.id}.css`, () => buildDevAsset(config, `/assets/${route.id}.css`, () => buildRouteCss(config, route, { dev: true }))).catch((error) => logDevPreloadError(`route css build for ${route.route}`, error));
+}
+function devLayoutFiles(config, routeFile) {
+  const cached = routeLayoutFiles.get(routeFile);
+  if (cached)
+    return cached;
+  const files = findLayouts(config.appPath, routeFile).filter((file) => existsSync2(file));
+  routeLayoutFiles.set(routeFile, files);
+  return files;
+}
+function logDevPreloadError(label, error) {
+  console.error([
+    `PNext dev preload failed for ${label}.`,
+    error instanceof Error ? error.stack ?? error.message : String(error)
+  ].join(`
+`));
+}
+function findDeferredDynamicReference(routes, id) {
+  for (const route of routes) {
+    const reference = route.clientReferences.find((item) => item.id === id && item.dynamic && !ssrClientReference(item));
+    if (reference)
+      return { route, reference };
+  }
+  const registered = deferredDynamicRefById(id);
+  if (registered)
+    return {
+      route: routes.find((item) => item.id === registered.routeId),
+      reference: { id, ...registered }
+    };
+  return;
+}
+async function devDynamicEntryFile(config, routes, id, routeId) {
+  const scoped = routeId ? routes.find((route2) => route2.id === routeId) : undefined;
+  const route = scoped ?? findDeferredDynamicReference(routes, id)?.route;
+  if (!route)
+    return;
+  const outDir = path5.dirname(await buildDevClient(config, route));
+  const file = path5.join(outDir, `${id}.js`);
+  return isInside(outDir, file) && existsSync2(file) ? file : undefined;
+}
+async function loadDeferredDynamicSidecar(outDir) {
+  try {
+    const parsed = JSON.parse(await readFile3(path5.join(outDir, DEFERRED_DYNAMIC_SIDECAR), "utf8"));
+    for (const [id, ref] of Object.entries(parsed)) {
+      if (ref?.file && ref.exportName)
+        registerDeferredDynamicRef(id, ref);
+    }
+  } catch {}
+}
+var devClientRouteSets = new Map;
+function setDevClientRoutes(config, routes) {
+  devClientRouteSets.set(config.outPath, routes);
+}
+function devClientBatchRoutes(config, route) {
+  const all = devClientRouteSets.get(config.outPath);
+  if (!all?.some((candidate) => candidate.id === route.id))
+    return [route];
+  return all.filter((candidate) => candidate.client || candidate.clientReferences.length > 0 || candidate.needsRouterEntry);
+}
+async function buildDevClient(config, route) {
+  const batchRoutes = devClientBatchRoutes(config, route);
+  const cacheKeys = await Promise.all(batchRoutes.map((entry) => routeClientCacheKey(config, entry)));
+  const cacheKey = batchRoutes.length === 1 ? cacheKeys[0] : `batch-${clientSourceHash([...cacheKeys].sort().join(`
+`))}`;
+  const outDir = path5.join(config.outPath, "cache", "client", cacheKey);
+  const outFile = path5.join(outDir, `${clientEntryName(route)}.js`);
+  const existing = clientBuilds.get(outDir);
+  if (existing)
+    return existing;
+  if (existsSync2(outFile)) {
+    if (!indexedClientDirs.has(outDir)) {
+      await indexClientChunks(outDir);
+      await loadDeferredDynamicSidecar(outDir);
+      indexedClientDirs.add(outDir);
+    }
+    return outFile;
+  }
+  const inner = (async () => {
+    await ensureDir(outDir);
+    if (nextCompatEnabled(config))
+      await getClientActionBundler()?.ensureArmed();
+    const file = batchRoutes.length === 1 ? await buildClientEntry({ config, route, outDir, dev: true }) : await (async () => {
+      await buildClientEntries({
+        config,
+        routes: batchRoutes,
+        outDir,
+        dev: true,
+        hasServerActions: true
+      });
+      return outFile;
+    })();
+    await contentAddressDir(outDir, clientChunkStoreDir(config.outPath));
+    await indexClientChunks(outDir);
+    indexedClientDirs.add(outDir);
+    return file;
+  })();
+  let unregister = () => {
+    return;
+  };
+  const stopSignal = new Promise((_, reject) => {
+    clientBuildStopWaiters.add(reject);
+    unregister = () => void clientBuildStopWaiters.delete(reject);
+  });
+  inner.catch(() => {
+    return;
+  });
+  const build = Promise.race([inner, stopSignal]).finally(() => {
+    unregister();
+    clientBuilds.delete(outDir);
+  });
+  clientBuilds.set(outDir, build);
+  return build;
+}
+async function maybeDevClientChunk(config, pathname) {
+  const chunkMatch = /^\/__pnext\/client\/chunks\/(.+\.js)$/.exec(pathname);
+  if (!chunkMatch?.[1])
+    return null;
+  const file = await resolveDevClientChunk(config, chunkMatch[1]);
+  return file ? devChunkResponse(await readFile3(file)) : null;
+}
+async function resolveDevClientChunk(config, name) {
+  const indexed = clientChunks.get(name);
+  if (indexed && existsSync2(indexed))
+    return indexed;
+  await Promise.allSettled([...clientBuilds.values()]);
+  const settled = clientChunks.get(name);
+  if (settled && existsSync2(settled))
+    return settled;
+  const clientRoot = path5.join(config.outPath, "cache", "client");
+  for (const generation of await readdir2(clientRoot).catch(() => [])) {
+    const chunksDir = path5.join(clientRoot, generation, "chunks");
+    const file = path5.join(chunksDir, name);
+    if (!isInside(chunksDir, file) || !existsSync2(file))
+      continue;
+    clientChunks.set(name, file);
+    return file;
+  }
+  return;
+}
+function maybePrebuiltRuntime(config, pathname) {
+  const match = /^\/__pnext\/runtime\/([0-9a-f]+)\/(.+\.js)$/.exec(pathname);
+  if (!match?.[1] || !match[2])
+    return null;
+  const dir = prebuiltRuntimeDir(config, match[1]);
+  const file = path5.join(dir, match[2]);
+  if (!isInside(dir, file) || !existsSync2(file))
+    return null;
+  return devChunkResponse(readFileSync5(file));
+}
+function maybeStaticClientChunk(config, staticAssetPathname) {
+  const match = /^\/_next\/static\/chunks\/([^/]+\.js)$/.exec(staticAssetPathname);
+  if (!match?.[1])
+    return null;
+  const chunk = getBundlerExtensions().staticClientChunks(config).find((item) => item.name === match[1]);
+  return chunk ? devChunkResponse(chunk.contents) : null;
+}
+async function indexClientChunks(outDir) {
+  const chunksDir = path5.join(outDir, "chunks");
+  if (!existsSync2(chunksDir))
+    return;
+  for (const file of await listFiles(chunksDir)) {
+    if (file.endsWith(".js"))
+      clientChunks.set(path5.basename(file), file);
+  }
+}
+async function maybeStaticMetadataFile(config, url) {
+  const target = url.pathname.replace(/^\/+/, "");
+  const file = discoverStaticMetadataFiles(config.appPath).find((item) => item.outputPath === target);
+  if (!file || !existsSync2(file.file))
+    return null;
+  return new Response(await readFile3(file.file), {
+    headers: { "content-type": file.contentType, "cache-control": staticMetadataCacheControl }
+  });
+}
+async function maybeStaticFile(publicPath, pathname, exactNames) {
+  const filePath = path5.join(publicPath, pathname.replace(/^\/+/, ""));
+  if (!isInside(publicPath, filePath) || !existsSync2(filePath))
+    return null;
+  if (exactNames && !hasExactName(exactNames, publicPath, path5.relative(publicPath, filePath))) {
+    return null;
+  }
+  const fileStat = await stat3(filePath);
+  if (!fileStat.isFile())
+    return null;
+  return devResponse(await readFile3(filePath), contentType(filePath));
+}
+function getNextStaticAssetPathname(pathname, basePath, assetPrefix) {
+  if (pathname.startsWith("/_next/static/"))
+    return pathname;
+  const normalizedBasePath = normalizePathPrefix(basePath);
+  if (normalizedBasePath && pathname.startsWith(`${normalizedBasePath}/_next/static/`)) {
+    return pathname.slice(normalizedBasePath.length);
+  }
+  const normalizedAssetPrefix = normalizePathPrefix(assetPrefix);
+  if (normalizedAssetPrefix && pathname.startsWith(`${normalizedAssetPrefix}/_next/static/`)) {
+    return pathname.slice(normalizedAssetPrefix.length);
+  }
+  return null;
+}
+function normalizePathPrefix(prefix) {
+  if (!prefix)
+    return null;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(prefix))
+    return null;
+  const normalized = `/${prefix.replace(/^\/+|\/+$/g, "")}`;
+  if (normalized === "/")
+    return null;
+  return normalized;
+}
+function findClientReferenceCss(routes, id) {
+  return routes.flatMap((route) => route.clientReferences).find((reference) => reference.id === id && reference.cssImports?.length);
+}
+function builtAssetPathname(config, pathname) {
+  if (pathname.startsWith("/assets/"))
+    return pathname;
+  const alias = /^\/_next\/static\/([^/]+)$/.exec(pathname);
+  return alias?.[1] && nextCompatEnabled(config) ? `/assets/${alias[1]}` : null;
+}
+async function maybeBuiltAsset(config, routes, requestPathname) {
+  const pathname = builtAssetPathname(config, requestPathname);
+  if (!pathname)
+    return null;
+  if (pathname === "/assets/global.css") {
+    await buildDevAsset(config, pathname, () => buildGlobalCss(config, { dev: true }));
+  } else {
+    const cssMatch = /^\/assets\/(.+)\.css$/.exec(pathname);
+    const route = cssMatch?.[1] ? routes.find((item) => item.id === cssMatch[1]) : undefined;
+    const reference = !route && cssMatch?.[1] ? findClientReferenceCss(routes.filter(routeFactsResolved), cssMatch[1]) ?? findClientReferenceCss(routes, cssMatch[1]) : undefined;
+    if (route) {
+      await buildDevAsset(config, pathname, () => buildRouteCss(config, route, { dev: true }));
+    } else if (reference) {
+      await buildDevAsset(config, pathname, () => buildClientReferenceCss(config, reference, { dev: true }));
+    }
+  }
+  const outPath = config.outPath;
+  const filePath = path5.join(outPath, "cache", pathname.replace(/^\/+/, ""));
+  if (!isInside(path5.join(outPath, "cache"), filePath) || !existsSync2(filePath))
+    return null;
+  const fileStat = await stat3(filePath);
+  if (!fileStat.isFile())
+    return null;
+  return new Response(await readFile3(filePath), {
+    headers: { "content-type": contentType(filePath) }
+  });
+}
+function buildDevAsset(config, pathname, build) {
+  const key = appKey(config.outPath, pathname);
+  const existing = assetBuilds.get(key);
+  if (existing)
+    return existing;
+  const next = build().catch((error) => {
+    assetBuilds.delete(key);
+    throw error;
+  });
+  assetBuilds.set(key, next);
+  return next;
+}
+function maybeDevPagePrefetchResponse(routes, pathname, request) {
+  if (!isDevPagePrefetchRequest(request))
+    return null;
+  const matched = matchRoute(routes, pathname);
+  if (matched?.route.kind !== "page")
+    return null;
+  return devPagePrefetchResponse();
+}
+function isDevPagePrefetchRequest(request) {
+  if (request.method.toUpperCase() !== "GET")
+    return false;
+  return headerHasPrefetchToken(request.headers.get("sec-purpose")) || headerHasPrefetchToken(request.headers.get("purpose")) || getRouterProtocolExtensions().prefetchRequestHeaders().some((header) => request.headers.get(header) === "1");
+}
+function headerHasPrefetchToken(value) {
+  return Boolean(value?.split(/[;,\s]+/).some((token) => token.toLowerCase() === "prefetch"));
+}
+function devPagePrefetchResponse() {
+  return new Response(null, {
+    status: 204,
+    headers: {
+      "cache-control": "no-store",
+      "x-pnext-dev-prefetch": "skipped"
+    }
+  });
+}
+function pendingDevPageLoadLog(routes, request, url, start = performance.now()) {
+  const matched = matchRoute(routes, url.pathname);
+  if (matched?.route.kind !== "page")
+    return;
+  return {
+    method: request.method,
+    pathname: url.pathname,
+    route: matched.route.route,
+    start
+  };
+}
+function startDevPageStallTimer(pending) {
+  if (!pending)
+    return pending;
+  const delay = Math.max(0, DEV_PAGE_STALL_WARNING_MS - (performance.now() - pending.start));
+  pending.stallTimer = setTimeout(() => {
+    console.warn(formatDevPageStallWarning({
+      method: pending.method,
+      pathname: pending.pathname,
+      route: pending.route,
+      elapsedMs: performance.now() - pending.start
+    }));
+  }, delay);
+  pending.stallTimer.unref?.();
+  return pending;
+}
+function clearDevPageStallTimer(pending) {
+  if (!pending?.stallTimer)
+    return;
+  clearTimeout(pending.stallTimer);
+  pending.stallTimer = undefined;
+}
+function formatDevPageStallWarning(entry) {
+  const route = entry.route === entry.pathname ? "" : dim(`(${entry.route})`);
+  return [
+    yellow("\u26A0"),
+    dim("page"),
+    dim(entry.method),
+    cyan(entry.pathname),
+    route,
+    yellow("still rendering"),
+    dim("after"),
+    durationLabel(entry.elapsedMs),
+    dim("- no response yet")
+  ].filter(Boolean).join(" ");
+}
+function devPageAbortNote(durationMs) {
+  return durationMs >= DEV_IDLE_TIMEOUT_MS ? "dev server idle timeout" : undefined;
+}
+function logDevPageResponse(pending, response) {
+  if (!pending)
+    return response;
+  clearDevPageStallTimer(pending);
+  logDevPageLoad({
+    method: pending.method,
+    pathname: pending.pathname,
+    route: pending.route,
+    status: response.status,
+    durationMs: performance.now() - pending.start
+  });
+  return response;
+}
+function logDevPageError(pending) {
+  if (!pending)
+    return;
+  clearDevPageStallTimer(pending);
+  logDevPageLoad({
+    method: pending.method,
+    pathname: pending.pathname,
+    route: pending.route,
+    status: 500,
+    durationMs: performance.now() - pending.start
+  });
+}
+function logDevPageAbort(pending) {
+  if (!pending)
+    return;
+  clearDevPageStallTimer(pending);
+  const durationMs = performance.now() - pending.start;
+  logDevPageLoad({
+    method: pending.method,
+    pathname: pending.pathname,
+    route: pending.route,
+    status: 499,
+    durationMs,
+    note: devPageAbortNote(durationMs)
+  });
+}
+function noteDevCompileStart(route) {
+  if (compiledRoutes.has(route.file))
+    return;
+  compiledRoutes.add(route.file);
+  console.log(`${cyan("\u25CB")} ${dim("Compiling")} ${cyan(route.route)} ${dim("...")}`);
+}
+function noteDevCompileDone(route, durationMs) {
+  console.log(`${green("\u2713")} ${dim("Compiled")} ${cyan(route.route)} ${dim("in")} ${durationLabel(durationMs)}`);
+}
+function logDevPageLoad(entry) {
+  console.log(formatDevPageLoadLog(entry));
+}
+function formatDevPageLoadLog(entry) {
+  const route = entry.route === entry.pathname ? "" : dim(`(${entry.route})`);
+  return [
+    dim("page"),
+    dim(entry.method),
+    cyan(entry.pathname),
+    route,
+    statusLabel(entry.status),
+    dim("in"),
+    durationLabel(entry.durationMs),
+    entry.note ? yellow(`(${entry.note})`) : ""
+  ].filter(Boolean).join(" ");
+}
+function statusLabel(status) {
+  const label = String(status);
+  if (status >= 500)
+    return red(label);
+  if (status >= 400)
+    return yellow(label);
+  if (status >= 300)
+    return cyan(label);
+  return green(label);
+}
+function durationLabel(durationMs) {
+  const label = formatDuration(durationMs);
+  if (durationMs >= 1000)
+    return yellow(label);
+  if (durationMs >= 250)
+    return cyan(label);
+  return green(label);
+}
+function dim(value) {
+  return color(2, 22, value);
+}
+function red(value) {
+  return color(31, 39, value);
+}
+function yellow(value) {
+  return color(33, 39, value);
+}
+function green(value) {
+  return color(32, 39, value);
+}
+function cyan(value) {
+  return color(36, 39, value);
+}
+function color(open, close, value) {
+  if (!process.stdout.isTTY)
+    return value;
+  return `\x1B[${open}m${value}\x1B[${close}m`;
+}
+function devResponse(body, contentType2) {
+  return new Response(body, {
+    headers: {
+      "content-type": contentType2,
+      "cache-control": "no-store"
+    }
+  });
+}
+function devChunkResponse(body) {
+  return new Response(body, {
+    headers: {
+      "content-type": "text/javascript; charset=utf-8",
+      "cache-control": "public, max-age=31536000, immutable"
+    }
+  });
+}
+function isInside(root, file) {
+  const relative = path5.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function refreshWatcher(config, routes, current, onChange, bootTime, onEvent) {
+  const roots = devWatchRoots(config, routes);
+  const rootsKey = roots.join("\x00");
+  if (current?.rootsKey === rootsKey)
+    return current;
+  current?.stop();
+  return watchRoots(roots, rootsKey, config.outPath, onChange, bootTime, onEvent);
+}
+function devWatchRoots(config, routes) {
+  const packageRoots = workspacePackageRoots(config.workspaceRoot);
+  const roots = new Set([config.appPath]);
+  for (const route of routes.filter(routeFactsResolved)) {
+    for (const file of route.sourceFiles) {
+      if (isInside(config.appPath, file))
+        continue;
+      const packageRoot = packageRoots.find((root) => isInside(root, file));
+      if (packageRoot)
+        roots.add(packageWatchRoot(packageRoot, file));
+      else {
+        const projectRoot = projectWatchRoot(config.root, file);
+        if (projectRoot)
+          roots.add(projectRoot);
+      }
+    }
+  }
+  return [...roots].sort();
+}
+function projectWatchRoot(root, file) {
+  if (!isInside(root, file))
+    return;
+  const [segment, ...rest] = path5.relative(root, file).split(path5.sep);
+  if (!segment || rest.length === 0)
+    return;
+  if (segment === "node_modules" || segment.startsWith("."))
+    return;
+  return path5.join(root, segment);
+}
+function packageWatchRoot(packageRoot, file) {
+  const relative = path5.relative(packageRoot, file);
+  const [firstSegment] = relative.split(path5.sep);
+  if (!firstSegment || firstSegment === ".." || path5.isAbsolute(relative))
+    return packageRoot;
+  return path5.join(packageRoot, firstSegment);
+}
+function isCssOnlyChange(files) {
+  return files.length > 0 && files.every((file) => isCssFile(file) && !/\.module\.[^.]+$/.test(file) && existsSync2(file));
+}
+var recursiveWatchBroken = false;
+function watchRoots(roots, rootsKey, outPath, onChange, bootTime, onEvent) {
+  const controller = new AbortController;
+  let pending;
+  let running = false;
+  let batch = { files: [], renamed: false };
+  async function flush() {
+    if (running || batch.files.length === 0)
+      return;
+    const change = batch;
+    batch = { files: [], renamed: false };
+    running = true;
+    try {
+      await onChange(change);
+    } finally {
+      running = false;
+    }
+    if (batch.files.length > 0)
+      await flush();
+  }
+  function schedule(file, renamed) {
+    if (predatesBoot(file, bootTime))
+      return;
+    onEvent(file);
+    batch.files.push(file);
+    batch.renamed ||= renamed;
+    if (pending)
+      clearTimeout(pending);
+    pending = setTimeout(() => {
+      pending = undefined;
+      flush();
+    }, isCssOnlyChange(batch.files) ? 4 : 40);
+  }
+  for (const root of roots) {
+    watchRoot(root, controller.signal, schedule, () => {
+      recursiveWatchBroken = true;
+      setDevWatcherFreshness(outPath, false);
+    });
+  }
+  if (!recursiveWatchBroken)
+    setDevWatcherFreshness(outPath, true);
+  return {
+    rootsKey,
+    stop() {
+      if (pending)
+        clearTimeout(pending);
+      controller.abort();
+    }
+  };
+}
+function predatesBoot(file, bootTime) {
+  const info = statSync2(file, { throwIfNoEntry: false });
+  return Boolean(info?.isFile() && info.mtimeMs <= bootTime);
+}
+var ignoredWatchSegment = /(?:^|[\\/])(?:node_modules|\.[^\\/]+)(?:[\\/]|$)/;
+function isIgnoredWatchPath(relativeFile) {
+  return ignoredWatchSegment.test(relativeFile);
+}
+async function watchRoot(root, signal, onChange, onBroken) {
+  try {
+    const watcher = watch(root, { recursive: true, signal });
+    for await (const event of watcher) {
+      if (!event.filename)
+        onChange(root, true);
+      else if (!ignoredWatchSegment.test(event.filename))
+        onChange(path5.resolve(root, event.filename), event.eventType === "rename");
+    }
+  } catch (error) {
+    if (signal.aborted || error instanceof Error && error.name === "AbortError")
+      return;
+    onBroken();
+  }
+}
+function eventStream(clients, generation) {
+  let client;
+  const stream = new ReadableStream({
+    start(controller) {
+      client = { controller };
+      clients.add(client);
+      controller.enqueue(new TextEncoder().encode(`event: ready
+data: ${generation}
+
+`));
+    },
+    cancel() {
+      if (client)
+        clients.delete(client);
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
+    }
+  });
+}
+function broadcast(clients, event) {
+  const payload = new TextEncoder().encode(`event: ${event}
+data: ${Date.now()}
+
+`);
+  for (const client of clients) {
+    try {
+      client.controller.enqueue(payload);
+    } catch {
+      clients.delete(client);
+    }
+  }
+}
+export {
+  devLastResortError,
+  devPageAbortNote,
+  failInFlightClientBuilds,
+  formatDevPageLoadLog,
+  formatDevPageStallWarning,
+  isDevPagePrefetchRequest,
+  isIgnoredWatchPath,
+  startDevServer
+};