@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,1431 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  rewriteDynamicCallTargets,
+  rewriteLiteralDynamicCalls,
+  sourceHasDynamicImport
+} from "./index-91x12ykq.js";
+import {
+  applyServerHrefConfig,
+  isReleaseCompile,
+  serverBundleExtraConditions
+} from "./index-3xbr4eyv.js";
+import {
+  frameworkFingerprint
+} from "./index-c0g2wf3z.js";
+import {
+  build,
+  transform
+} from "./index-cjgqs13g.js";
+import {
+  writeFileAtomic
+} from "./index-20ppawv7.js";
+import {
+  traceEnabled
+} from "./index-vz0km5qk.js";
+import {
+  prebundledFile
+} from "./index-y36a0ybw.js";
+import {
+  frameworkRuntimeAliasEntries,
+  pathToFileHref,
+  pnextAliases
+} from "./index-x93hv0sc.js";
+import {
+  productionRelease
+} from "./index-tqn2qnnn.js";
+import {
+  cachedExistsSync,
+  resolveExternalLoadTarget,
+  resolveImport,
+  workspacePackageRoots
+} from "./index-yz54pxrh.js";
+import {
+  applyBundledSourceTransforms,
+  applyServerSourcePreTransforms,
+  applyServerSourceTransforms,
+  extraLoadableExtensions,
+  getAssetExtensions,
+  getBundlerExtensions,
+  getCssExtensions,
+  getImportAliasExtensions,
+  onLoadableExtensionsChanged,
+  serverDefineOptions,
+  sourceNeedsServerTransforms
+} from "./index-zqpqyg8p.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/runtime/loader.ts
+import { createHash as createHash2 } from "crypto";
+import { createRequire } from "module";
+import { existsSync, readFileSync as readFileSync2, realpathSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { mkdir as mkdir3, readFile as readFile3, stat as stat3, writeFile } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/runtime/module-cache.ts
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { mkdir, readFile, stat } from "fs/promises";
+import { createHash, randomUUID } from "crypto";
+import path from "path";
+import { fileURLToPath } from "url";
+function devHeadTrimEnabled() {
+  return process.env.PNEXT_HEAD_TRIM !== "0";
+}
+var watcherFreshRoots = new Set;
+function setDevWatcherFreshness(outPath, trusted) {
+  if (trusted)
+    watcherFreshRoots.add(cacheRoot(outPath));
+  else
+    watcherFreshRoots.delete(cacheRoot(outPath));
+}
+function watcherFreshnessTrusted(root) {
+  return watcherFreshRoots.has(root) && process.env.PNEXT_DEV_WATCH_FRESHNESS !== "0";
+}
+var BINARY_SOURCE = /\.(?:png|jpe?g|gif|webp|avif|ico|bmp|woff2?|ttf|otf|eot|mp[34]|webm|pdf)$/i;
+var MISSING = "missing";
+var frameworkRoot = path.resolve(path.dirname(fileURLToPath(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/runtime/module-cache.ts").href)), "..", "..");
+var portablePaths = new Map;
+var memoPortablePaths = process.env.PNEXT_DEV_GRAPH_FAST !== "0";
+function portableSourcePath(file, workspaceRoot) {
+  if (!memoPortablePaths)
+    return computePortableSourcePath(file, workspaceRoot);
+  const memoKey = `${workspaceRoot}\x00${file}`;
+  const memoized = portablePaths.get(memoKey);
+  if (memoized !== undefined)
+    return memoized;
+  const computed = computePortableSourcePath(file, workspaceRoot);
+  portablePaths.set(memoKey, computed);
+  return computed;
+}
+function computePortableSourcePath(file, workspaceRoot) {
+  const inWorkspace = path.relative(workspaceRoot, file);
+  if (inWorkspace && !inWorkspace.startsWith("..") && !path.isAbsolute(inWorkspace)) {
+    return `w:${toPosix(inWorkspace)}`;
+  }
+  const inFramework = path.relative(frameworkRoot, file);
+  if (inFramework && !inFramework.startsWith("..") && !path.isAbsolute(inFramework)) {
+    return `f:${toPosix(inFramework)}`;
+  }
+  return `a:${toPosix(file)}`;
+}
+function absoluteSourcePath(key, workspaceRoot) {
+  const value = key.slice(2).split("/").join(path.sep);
+  if (key.startsWith("w:"))
+    return path.resolve(workspaceRoot, value);
+  if (key.startsWith("f:"))
+    return path.resolve(frameworkRoot, value);
+  return value;
+}
+var toPosix = (file) => path.sep === "/" ? file : file.split(path.sep).join("/");
+function devSourceIdentity(file, workspaceRoot) {
+  return portableSourcePath(file, workspaceRoot);
+}
+var DEV_SOURCE_MISSING = MISSING;
+function isBinaryDevSource(file) {
+  return BINARY_SOURCE.test(file);
+}
+function devTextSourceHash(source) {
+  return Bun.hash(source).toString(36);
+}
+var caches = new Map;
+var persistFlushes = new Set;
+function flushDevModuleCaches() {
+  for (const flushNow of persistFlushes)
+    flushNow();
+}
+function devModuleCache(config, options) {
+  const root = cacheRoot(config.outPath);
+  const existing = caches.get(root);
+  if (existing)
+    return existing;
+  const created = createDevModuleCache(root, config.workspaceRoot, options);
+  caches.set(root, created);
+  return created;
+}
+function cacheRoot(outPath) {
+  return path.join(outPath, "cache", "server");
+}
+function createDevModuleCache(root, workspaceRoot, options) {
+  const indexFile = path.join(root, "graph.json");
+  const outRoot = `${path.dirname(path.dirname(root))}${path.sep}`;
+  const generated = (file) => file.startsWith(outRoot) || file.includes(`${path.sep}pnext-pages-compat${path.sep}`);
+  const key = createHash("sha256").update(`${options.compileKey}\x00${frameworkFingerprint(root)}`).digest("hex").slice(0, 16);
+  establishCacheTrust(root);
+  const records = indexRecords(readIndexFile(indexFile), key, workspaceRoot);
+  const booted = traceEnabled("server") && records.size > 0 ? new Map([...records].map(([file, record]) => [file, record.srcHash])) : undefined;
+  const pending = new Map;
+  const graphFast = process.env.PNEXT_DEV_GRAPH_FAST !== "0";
+  const settledThisPass = new Map;
+  const refreshedThisPass = new Set;
+  let passes = 0;
+  const closures = new Map;
+  const hashes = new Map;
+  let dirty = false;
+  let flush;
+  let retries = 0;
+  function persist() {
+    if (flush)
+      return;
+    flush = setTimeout(async () => {
+      flush = undefined;
+      if (!dirty)
+        return;
+      const contents = serializeIndex(key, records, workspaceRoot);
+      try {
+        await mkdir(root, { recursive: true });
+        await writeFileAtomic(indexFile, contents);
+        dirty = false;
+      } catch {
+        if (++retries < 3)
+          persist();
+      }
+    }, 50);
+    flush.unref?.();
+  }
+  function flushPersistNow() {
+    if (flush) {
+      clearTimeout(flush);
+      flush = undefined;
+    }
+    if (!dirty)
+      return;
+    dirty = false;
+    try {
+      writeFileSync(indexFile, serializeIndex(key, records, workspaceRoot));
+    } catch {}
+  }
+  persistFlushes.add(flushPersistNow);
+  process.on("exit", flushPersistNow);
+  async function sourceRecord(file) {
+    const inflight = pending.get(file) ?? (graphFast && passes > 0 ? settledThisPass.get(file) : undefined);
+    if (inflight)
+      return inflight;
+    const previous = records.get(file);
+    const next = readSourceRecord(file, previous, options.edges).then((record) => {
+      pending.delete(file);
+      if (record === previous)
+        return record;
+      records.set(file, record);
+      dirty = true;
+      persist();
+      return record;
+    });
+    pending.set(file, next);
+    if (graphFast && passes > 0)
+      settledThisPass.set(file, next);
+    return next;
+  }
+  async function refresh(file) {
+    if (watcherFreshnessTrusted(root))
+      return;
+    const reachable = closures.get(file);
+    if (!reachable)
+      return;
+    if (passes > 0 && refreshedThisPass.has(file))
+      return;
+    refreshedThisPass.add(file);
+    const changed = [];
+    await Promise.all([...reachable].map(async (source) => {
+      const previous = records.get(source);
+      const record = await sourceRecord(source);
+      if (previous?.srcHash !== record.srcHash)
+        changed.push(source);
+    }));
+    if (changed.length > 0)
+      forget(changed);
+  }
+  function forget(changed) {
+    for (const [source, reachable] of closures) {
+      if (!changed.some((target) => reachable.has(target)))
+        continue;
+      closures.delete(source);
+      hashes.delete(source);
+    }
+  }
+  async function serialFrontier(frontier, file) {
+    const reached = [];
+    for (const current of frontier) {
+      const known = current === file ? undefined : closures.get(current);
+      reached.push(known ? { expand: false, targets: known } : { expand: true, targets: (await sourceRecord(current)).imports });
+    }
+    return reached;
+  }
+  async function serialRecords(reachable) {
+    const records2 = [];
+    for (const source of reachable)
+      records2.push(await sourceRecord(source));
+    return records2;
+  }
+  async function closure(file) {
+    const cached = closures.get(file);
+    if (cached)
+      return cached;
+    const seen = new Set([file]);
+    let frontier = [file];
+    while (frontier.length > 0) {
+      const reached = graphFast ? await Promise.all(frontier.map(async (current) => {
+        const known = current === file ? undefined : closures.get(current);
+        return known ? { expand: false, targets: known } : { expand: true, targets: (await sourceRecord(current)).imports };
+      })) : await serialFrontier(frontier, file);
+      const next = [];
+      for (const { expand, targets } of reached) {
+        for (const target of targets) {
+          if (seen.has(target))
+            continue;
+          seen.add(target);
+          if (expand)
+            next.push(target);
+        }
+      }
+      frontier = next;
+    }
+    closures.set(file, seen);
+    return seen;
+  }
+  async function computeGraphHash(file) {
+    const reachable = [...await closure(file)].sort();
+    const records2 = graphFast ? await Promise.all(reachable.map((source) => sourceRecord(source))) : await serialRecords(reachable);
+    const hash = createHash("sha256").update(key).update("\x00");
+    const moved = [];
+    for (const [index, source] of reachable.entries()) {
+      const record = records2[index];
+      hash.update(generated(source) ? "" : portableSourcePath(source, workspaceRoot));
+      hash.update("\x00");
+      hash.update(record.srcHash);
+      hash.update("\x00");
+      if (booted && booted.get(source) !== record.srcHash)
+        moved.push(source);
+    }
+    if (booted && moved.length > 0) {
+      console.log(`dev-cache ${path.basename(file)} renamed: ${moved.length} source(s) differ from the persisted graph
+  ${moved.slice(0, 10).join(`
+  `)}`);
+    }
+    return hash.digest("hex").slice(0, 16);
+  }
+  return {
+    root,
+    graphKey: key,
+    async graphSources(files) {
+      const reachable = new Set;
+      for (const file of files)
+        for (const source of await closure(path.resolve(file)))
+          reachable.add(source);
+      return Promise.all([...reachable].sort().map(async (source) => {
+        const record = await sourceRecord(source);
+        return [source, record.mtimeMs, record.size, record.srcHash];
+      }));
+    },
+    async graphHash(file) {
+      const resolved = path.resolve(file);
+      await refresh(resolved);
+      const existing = hashes.get(resolved);
+      if (existing)
+        return existing;
+      const next = computeGraphHash(resolved).catch((error) => {
+        hashes.delete(resolved);
+        throw error;
+      });
+      hashes.set(resolved, next);
+      return next;
+    },
+    knows(file) {
+      return records.has(path.resolve(file));
+    },
+    async isClientSource(file) {
+      return (await sourceRecord(path.resolve(file))).client;
+    },
+    async packageDemand(file, prune) {
+      const resolved = path.resolve(file);
+      const demand = new Set;
+      if (!prune) {
+        for (const source of await closure(resolved)) {
+          for (const name of (await sourceRecord(source)).packages)
+            demand.add(name);
+        }
+        return [...demand];
+      }
+      const seen = new Set([resolved]);
+      let frontier = [resolved];
+      while (frontier.length > 0) {
+        const kept = (await Promise.all(frontier.map(async (source) => await prune(source) ? undefined : source))).filter((source) => source !== undefined);
+        const reached = await Promise.all(kept.map((source) => sourceRecord(source)));
+        const next = [];
+        for (const record of reached) {
+          for (const name of record.packages)
+            demand.add(name);
+          for (const target of record.imports) {
+            if (seen.has(target))
+              continue;
+            seen.add(target);
+            next.push(target);
+          }
+        }
+        frontier = next;
+      }
+      return [...demand];
+    },
+    hold() {
+      if (passes++ === 0) {
+        refreshedThisPass.clear();
+        settledThisPass.clear();
+      }
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        if (--passes === 0)
+          settledThisPass.clear();
+      };
+    },
+    invalidate(files) {
+      const changed = new Set([...files].map((file) => path.resolve(file)));
+      if (changed.size === 0)
+        return;
+      for (const file of changed) {
+        records.delete(file);
+        pending.delete(file);
+        settledThisPass.delete(file);
+        dirty = true;
+      }
+      forget([...changed]);
+      persist();
+    }
+  };
+}
+var missingRecord = () => ({
+  mtimeMs: 0,
+  size: 0,
+  srcHash: MISSING,
+  imports: [],
+  packages: [],
+  client: false
+});
+async function readSourceRecord(file, previous, edges) {
+  const sync = devHeadTrimEnabled();
+  const stats = sync ? (() => {
+    try {
+      return statSync(file);
+    } catch {
+      return;
+    }
+  })() : await stat(file).catch(() => {
+    return;
+  });
+  if (!stats)
+    return missingRecord();
+  if (previous?.mtimeMs === stats.mtimeMs && previous.size === stats.size) {
+    return previous;
+  }
+  if (isBinaryDevSource(file)) {
+    return {
+      mtimeMs: stats.mtimeMs,
+      size: stats.size,
+      srcHash: `b${stats.size.toString(36)}.${Math.round(stats.mtimeMs).toString(36)}`,
+      imports: [],
+      packages: [],
+      client: false
+    };
+  }
+  const source = sync ? (() => {
+    try {
+      return readFileSync(file, "utf8");
+    } catch {
+      return;
+    }
+  })() : await readFile(file, "utf8").catch(() => {
+    return;
+  });
+  if (source === undefined)
+    return missingRecord();
+  const srcHash = devTextSourceHash(source);
+  const scanned = previous?.srcHash === srcHash ? previous : edges(file, source);
+  return {
+    mtimeMs: stats.mtimeMs,
+    size: stats.size,
+    srcHash,
+    imports: scanned.imports,
+    packages: scanned.packages,
+    client: scanned.client
+  };
+}
+var markers = new Map;
+var wiped = new Set;
+var written = new Set;
+var markerChecks = new Map;
+function markerFile(root) {
+  return path.join(root, ".cache-id");
+}
+function establishCacheTrust(root) {
+  const current = readMarker(root);
+  const generation = `${frameworkFingerprint()}:`;
+  const trusted = current?.startsWith(generation) ? current : undefined;
+  const value = trusted ?? `${generation}${randomUUID()}`;
+  if (!trusted) {
+    writeMarker(root, value);
+    wiped.add(root);
+  }
+  markers.set(root, value);
+  return value;
+}
+function readMarker(root) {
+  try {
+    return readFileSync(markerFile(root), "utf8").trim() || undefined;
+  } catch {
+    return;
+  }
+}
+function writeMarker(root, value) {
+  try {
+    mkdirSync(root, { recursive: true });
+    writeFileSync(markerFile(root), value);
+  } catch {}
+}
+function cacheMarkerIntact(root) {
+  const recorded = markers.get(root);
+  if (recorded === undefined || wiped.has(root))
+    return false;
+  const now = performance.now();
+  if (now - (markerChecks.get(root) ?? -Infinity) < 100)
+    return true;
+  markerChecks.set(root, now);
+  const current = readMarker(root);
+  if (current === recorded)
+    return true;
+  if (!current)
+    writeMarker(root, recorded);
+  else
+    markers.set(root, current);
+  wiped.add(root);
+  return false;
+}
+function noteDevArtifactWritten(file) {
+  const root = artifactCacheRoot(file);
+  if (root && wiped.has(root))
+    written.add(file);
+}
+function devArtifactUsable(file) {
+  if (!cachedExistsSync(file))
+    return false;
+  const root = artifactCacheRoot(file);
+  if (!root || !markers.has(root))
+    return true;
+  return cacheMarkerIntact(root) || written.has(file);
+}
+function artifactCacheRoot(file) {
+  const marker = `${path.sep}cache${path.sep}server${path.sep}`;
+  const index = file.lastIndexOf(marker);
+  return index === -1 ? undefined : file.slice(0, index + marker.length - 1);
+}
+var INDEX_VERSION = 4;
+function compiledSourceGraph(outPath, workspaceRoot) {
+  const graph = new Map;
+  const parsed = readIndexFile(path.join(cacheRoot(outPath), "graph.json"));
+  for (const [source, entry] of Object.entries(parsed?.files ?? {})) {
+    graph.set(absoluteSourcePath(source, workspaceRoot), entry[3].map((file) => absoluteSourcePath(file, workspaceRoot)));
+  }
+  return graph;
+}
+function readIndexFile(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
+function indexRecords(parsed, key, workspaceRoot) {
+  const records = new Map;
+  if (parsed?.key !== key || parsed.version !== INDEX_VERSION)
+    return records;
+  for (const [source, entry] of Object.entries(parsed.files ?? {})) {
+    records.set(absoluteSourcePath(source, workspaceRoot), {
+      mtimeMs: entry[0],
+      size: entry[1],
+      srcHash: entry[2],
+      imports: entry[3].map((file) => absoluteSourcePath(file, workspaceRoot)),
+      packages: entry[4] ?? [],
+      client: entry[5] === 1
+    });
+  }
+  return records;
+}
+function serializeIndex(key, records, workspaceRoot) {
+  const files = {};
+  for (const [source, record] of records) {
+    files[portableSourcePath(source, workspaceRoot)] = [
+      record.mtimeMs,
+      record.size,
+      record.srcHash,
+      record.imports.map((file) => portableSourcePath(file, workspaceRoot)),
+      record.packages,
+      record.client ? 1 : 0
+    ];
+  }
+  return JSON.stringify({ version: INDEX_VERSION, key, files });
+}
+
+// src/dev/restart/node-modules.ts
+import { mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import path2 from "path";
+async function readNodeModuleBundle(recordFile) {
+  const contents = await readFile2(recordFile, "utf8").catch(() => {
+    return;
+  });
+  if (contents === undefined)
+    return;
+  let record;
+  try {
+    record = JSON.parse(contents);
+  } catch {
+    return;
+  }
+  if (typeof record?.code !== "string" || !Array.isArray(record.inputs))
+    return;
+  if (record.inputs.length === 0)
+    return;
+  const held = await Promise.all(record.inputs.map(async ([input, mtimeMs, size]) => {
+    const stats = await stat2(input).catch(() => {
+      return;
+    });
+    return stats?.mtimeMs === mtimeMs && stats.size === size;
+  }));
+  return held.every(Boolean) ? record.code : undefined;
+}
+async function writeNodeModuleBundle(recordFile, inputs, code) {
+  const stated = await Promise.all(inputs.map(async (input) => {
+    const stats = await stat2(input).catch(() => {
+      return;
+    });
+    return stats ? [input, stats.mtimeMs, stats.size] : undefined;
+  }));
+  if (stated.length === 0 || stated.some((entry) => entry === undefined))
+    return;
+  await mkdir2(path2.dirname(recordFile), { recursive: true }).catch(() => {
+    return;
+  });
+  await writeFileAtomic(recordFile, JSON.stringify({ inputs: stated, code })).catch(() => {
+    return;
+  });
+}
+
+// src/runtime/loader.ts
+var require2 = createRequire(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/runtime/loader.ts").href);
+function pagesBundleTargetForRuntime(runtime) {
+  return runtime === "edge" || runtime === "experimental-edge" ? "pages-edge" : "pages";
+}
+function serverBundleConditions(target) {
+  const base = target === "client" ? ["module", "import"] : target === "edge" ? ["react-server", "edge-light", "browser", "module", "import"] : target === "pages-api-edge" ? ["edge-light", "browser", "module", "import"] : target === "pages-api" ? ["node", "require", "import"] : target === "pages-edge" ? ["edge-light", "browser", "module", "import"] : target === "pages" ? ["node", "module", "import"] : ["react-server", "node", "module", "import"];
+  return [...new Set([...serverBundleExtraConditions(target), ...base])];
+}
+function serverBundleRequireConditions(target) {
+  const base = target === "client" ? ["module", "require"] : target === "edge" ? ["react-server", "edge-light", "browser", "module", "require"] : target === "pages-api-edge" ? ["edge-light", "browser", "module", "require"] : target === "pages-api" ? ["node", "require"] : target === "pages-edge" ? ["edge-light", "browser", "module", "require"] : target === "pages" ? ["node", "module", "require"] : ["react-server", "node", "module", "require"];
+  return [...new Set([...serverBundleExtraConditions(target), ...base])];
+}
+var runtimeConfigs = new Map;
+var aliasCache = new WeakMap;
+var packageRootCache = new WeakMap;
+var registeredSignatures = new WeakMap;
+var rootPathCache = new Map;
+var runtimeConfigLookupCache = new Map;
+var firstAliasCache = new Map;
+var transformCache = new Map;
+var pendingTransforms = new Map;
+var nodeModuleTransformCache = new Map;
+var requireSidecarCache = new Map;
+var registeredLoadRoots = new Set;
+var resolveRegistered = false;
+var nodeModulesLoadRegistered = false;
+var pluginsDeferred = false;
+var deferredPluginRoots = new Set;
+var packageJsxLoaders = {
+  ".js": "jsx",
+  ".mjs": "jsx",
+  ".cjs": "jsx"
+};
+function registerServerRuntime(config, sourceFiles = []) {
+  applyServerHrefConfig(config);
+  if (typeof Bun === "undefined" || productionRelease(config))
+    return;
+  nativeStoreFor(config);
+  const sourceRoots = [...new Set(sourceFiles.map((file) => sourceRootForFile(config, file)))].sort();
+  const signature = sourceRoots.join("\x00");
+  let registered = registeredSignatures.get(config);
+  if (!registered) {
+    registered = new Set;
+    registeredSignatures.set(config, registered);
+  }
+  if (registered.has(signature))
+    return;
+  registered.add(signature);
+  const aliases = aliasesForConfig(config);
+  const roots = [
+    ...rootPaths(config.root),
+    ...rootPaths(config.appPath),
+    ...isReleaseCompile() ? [] : rootPaths(path3.join(config.outPath, "cache", "server")),
+    ...rootPaths(path3.join(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..")),
+    ...sourceRoots.flatMap(rootPaths)
+  ];
+  const key = rootPaths(config.appPath).join("\x00");
+  const missingImportError = (specifier) => getImportAliasExtensions().missingImportError(config, specifier);
+  const existing = runtimeConfigs.get(key);
+  if (existing) {
+    for (const root of roots)
+      existing.roots.add(root);
+    for (const [specifier, target] of aliases)
+      existing.aliases.set(specifier, target);
+    existing.resolved = config;
+    existing.missingImportError = missingImportError;
+  } else {
+    runtimeConfigs.set(key, {
+      root: config.root,
+      roots: new Set(roots),
+      aliases: new Map(aliases),
+      resolved: config,
+      missingImportError
+    });
+  }
+  runtimeConfigLookupCache.clear();
+  firstAliasCache.clear();
+  if (pluginsDeferred) {
+    for (const root of roots)
+      deferredPluginRoots.add(root);
+    return;
+  }
+  registerResolvePlugin();
+  registerNodeModulesLoadPlugin();
+  for (const root of roots)
+    registerLoadPlugin(root, rootPaths(config.root).includes(root));
+}
+function deferServerRuntimePlugins() {
+  pluginsDeferred = true;
+}
+function installServerRuntimePlugins() {
+  if (!pluginsDeferred)
+    return;
+  pluginsDeferred = false;
+  registerResolvePlugin();
+  registerNodeModulesLoadPlugin();
+  for (const root of deferredPluginRoots) {
+    const projectRoot = [...runtimeConfigs.values()].some((config) => rootPaths(config.root).includes(root));
+    registerLoadPlugin(root, projectRoot);
+  }
+  deferredPluginRoots.clear();
+}
+function resolveRuntimeTarget(target) {
+  return path3.isAbsolute(target) ? target : require2.resolve(target);
+}
+function aliasesForConfig(config) {
+  let aliases = aliasCache.get(config);
+  if (!aliases) {
+    aliases = new Map;
+    for (const [specifier, target] of Object.entries(coreAliases(config, "server"))) {
+      aliases.set(specifier, resolveRuntimeTarget(target));
+    }
+    aliasCache.set(config, aliases);
+  }
+  return aliases;
+}
+function coreAliases(config, target) {
+  return {
+    ...frameworkRuntimeAliasEntries(),
+    ...pnextAliases(target),
+    ...getImportAliasExtensions().aliases(config, target)
+  };
+}
+var aliasSpecifierFilter = /^(?:@wular\/pnext\/cache|preact(?:\/|$)|react(?:-dom)?(?:\/|$)|react-compiler-runtime$|next(?:\/|$)|server-only$|client-only$|@vercel\/og$)/;
+function registerResolvePlugin() {
+  if (resolveRegistered)
+    return;
+  resolveRegistered = true;
+  Bun.plugin({
+    name: "pnext-server-runtime-resolve",
+    setup(plugin) {
+      plugin.onResolve({ filter: aliasSpecifierFilter }, (args) => {
+        const runtime = runtimeConfigForFile(args.importer);
+        const resolved = runtime?.aliases.get(args.path) ?? firstAliasForSpecifier(args.path);
+        const target = resolved ? serverRequireAlias(args.path, resolved, args.kind) : undefined;
+        if (target)
+          return { path: prebundledFile(target) };
+        const message = (runtime ?? firstRuntimeConfig())?.missingImportError(args.path);
+        if (message)
+          throw new Error(message);
+        return;
+      });
+      plugin.onResolve({ filter: /^[^./].*/ }, ({ path: specifier, importer }) => {
+        const runtime = runtimeConfigForFile(importer);
+        const target = runtime && resolveExternalLoadTarget({
+          root: runtime.root,
+          fromFile: importer,
+          specifier,
+          target: "server"
+        });
+        if (!target)
+          return;
+        return { path: prebundledFile(target) };
+      });
+    }
+  });
+}
+function registerLoadPlugin(root, projectRoot = false) {
+  if (registeredLoadRoots.has(root))
+    return;
+  registeredLoadRoots.add(root);
+  if (traceEnabled("server")) {
+    console.error(`[loadplugin] register root=${root} extras=${currentLoadExtras().join(",")}`);
+  }
+  loadPluginExtras.set(root, currentLoadExtras());
+  Bun.plugin({
+    name: `pnext-server-runtime-load-${hashRoot(root)}`,
+    setup(plugin) {
+      plugin.onLoad({ filter: rootFilter(root, projectRoot) }, async ({ path: file }) => ({
+        contents: await transformSource(file),
+        loader: "js"
+      }));
+    }
+  });
+}
+var loadPluginExtras = new Map;
+function currentLoadExtras() {
+  return extraLoadableExtensions().filter((ext) => /^[a-z0-9]+$/i.test(ext));
+}
+onLoadableExtensionsChanged(() => {
+  for (const [root, seen] of loadPluginExtras) {
+    const fresh = currentLoadExtras().filter((ext) => !seen.includes(ext));
+    if (fresh.length === 0)
+      continue;
+    loadPluginExtras.set(root, [...seen, ...fresh]);
+    const exts = fresh.map(escapeRegex).join("|");
+    const filter = new RegExp(`^${escapeRegex(root)}(?!.*\\/node_modules\\/)(?:/.*)?\\.(?:${exts})$`);
+    Bun.plugin({
+      name: `pnext-server-runtime-load-extras-${hashRoot(root)}-${fresh.join("-")}`,
+      setup(plugin) {
+        plugin.onLoad({ filter }, async ({ path: file }) => ({
+          contents: await transformSource(file),
+          loader: "js"
+        }));
+      }
+    });
+  }
+});
+function registerNodeModulesLoadPlugin() {
+  if (nodeModulesLoadRegistered)
+    return;
+  nodeModulesLoadRegistered = true;
+  Bun.plugin({
+    name: "pnext-server-node-modules-load",
+    setup(plugin) {
+      plugin.onLoad({
+        filter: /\/node_modules\/.*(?:\.mjs|\.esm\.js|\/(?:es|esm|dist\/esm|build\/modern)\/.*\.js)$/
+      }, ({ path: file }) => {
+        if (isRecordedNativeFile(file) || nodeModuleGraphLoadsAsIs(file)) {
+          return { contents: takeNodeModuleSource(file), loader: "js" };
+        }
+        return transformNodeModuleSource(file).then((code) => ({ contents: code, loader: "js" }));
+      });
+    }
+  });
+}
+var nodeModuleImportScanner = new Bun.Transpiler({ loader: "js" });
+function nodeModuleSourceLoadsAsIs(source) {
+  return nodeModuleRelativeImports(source) !== undefined;
+}
+function nodeModuleRelativeImports(source) {
+  if (serverDefineOptions().define || source.includes("use cache"))
+    return;
+  if (/^\s*(?:(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/)\s*)*['"]use (?:client|server)['"]/.test(source)) {
+    return;
+  }
+  try {
+    const relative = [];
+    for (const { path: specifier } of nodeModuleImportScanner.scanImports(source)) {
+      if (specifier.startsWith(".") || specifier.startsWith("/")) {
+        if (!/(?:\.[cm]?js|\.json|\/[^./]+)$/.test(specifier))
+          return;
+        if (specifier.startsWith("."))
+          relative.push(specifier);
+      } else if (aliasSpecifierFilter.test(specifier) || firstAliasForSpecifier(specifier)) {
+        return;
+      }
+    }
+    return relative;
+  } catch {
+    return;
+  }
+}
+var nativeNodeModuleFiles = new Map;
+var nativeNodeModuleStores = new Map;
+var nativeStoreFlushArmed = false;
+var NATIVE_STORE_VERSION = 1;
+var nativeNodeModuleStore = (config) => path3.join(cacheRoot(config.outPath), "native-files.json");
+function statSignature(file) {
+  try {
+    const { mtimeMs, size } = statSync2(file);
+    return `${mtimeMs}:${size}`;
+  } catch {
+    return;
+  }
+}
+function nativeStoreFor(config) {
+  let stored = nativeNodeModuleStores.get(config.outPath)?.files;
+  if (!stored) {
+    stored = new Map;
+    nativeNodeModuleStores.set(config.outPath, { config, files: stored });
+    for (const [file, signature] of Object.entries(readNativeStore(config))) {
+      stored.set(file, signature);
+      nativeNodeModuleFiles.set(path3.resolve(config.workspaceRoot, file), signature);
+    }
+  }
+  return stored;
+}
+function readNativeStore(config) {
+  try {
+    const store = JSON.parse(readFileSync2(nativeNodeModuleStore(config), "utf8"));
+    return store.version === NATIVE_STORE_VERSION ? store.files : {};
+  } catch {
+    return {};
+  }
+}
+function isRecordedNativeFile(file) {
+  const signature = nativeNodeModuleFiles.get(file);
+  return signature !== undefined && signature === statSignature(file);
+}
+function recordNativeNodeModuleFiles(config, files) {
+  const stored = nativeStoreFor(config);
+  let added = false;
+  for (const file of files) {
+    if (nativeNodeModuleFiles.has(file))
+      continue;
+    const signature = statSignature(file);
+    if (!signature)
+      continue;
+    nativeNodeModuleFiles.set(file, signature);
+    stored.set(path3.relative(config.workspaceRoot, file), signature);
+    added = true;
+  }
+  if (!added || nativeStoreFlushArmed)
+    return;
+  nativeStoreFlushArmed = true;
+  process.once("exit", () => {
+    for (const { config: owner, files: files2 } of nativeNodeModuleStores.values()) {
+      try {
+        for (const [file, signature] of Object.entries(readNativeStore(owner))) {
+          if (!files2.has(file))
+            files2.set(file, signature);
+        }
+        writeFileSync2(nativeNodeModuleStore(owner), JSON.stringify({ version: NATIVE_STORE_VERSION, files: Object.fromEntries(files2) }));
+      } catch {}
+    }
+  });
+}
+var nodeModuleScans = new Map;
+var nodeModuleGraphVerdicts = new Map;
+function nodeModuleScan(file) {
+  let scan = nodeModuleScans.get(file);
+  if (scan === undefined) {
+    try {
+      const source = readFileSync2(file, "utf8");
+      const relative = nodeModuleRelativeImports(source);
+      const dir = path3.dirname(file);
+      scan = relative ? {
+        source,
+        imports: relative.map((specifier) => /\.[cm]?js$/.test(specifier) ? path3.resolve(dir, specifier) : Bun.resolveSync(specifier, dir))
+      } : null;
+    } catch {
+      scan = null;
+    }
+    nodeModuleScans.set(file, scan);
+  }
+  return scan;
+}
+function nodeModuleGraphLoadsAsIs(file) {
+  const known = nodeModuleGraphVerdicts.get(file);
+  if (known !== undefined)
+    return known;
+  const seen = new Set;
+  const stack = [file];
+  let verdict = true;
+  while (stack.length > 0 && verdict) {
+    const next = stack.pop();
+    if (seen.has(next) || nodeModuleGraphVerdicts.get(next) === true)
+      continue;
+    seen.add(next);
+    const scan = nodeModuleScan(next);
+    if (!scan)
+      verdict = false;
+    else
+      stack.push(...scan.imports);
+  }
+  if (verdict)
+    for (const covered of seen)
+      nodeModuleGraphVerdicts.set(covered, true);
+  else
+    nodeModuleGraphVerdicts.set(file, false);
+  return verdict;
+}
+function takeNodeModuleSource(file) {
+  const scan = nodeModuleScans.get(file);
+  const source = scan?.source ?? readFileSync2(file, "utf8");
+  if (scan)
+    scan.source = undefined;
+  return source;
+}
+function runtimeConfigForFile(file) {
+  if (!file)
+    return;
+  const key = path3.resolve(file);
+  if (runtimeConfigLookupCache.has(key)) {
+    return runtimeConfigLookupCache.get(key) ?? undefined;
+  }
+  for (const config of runtimeConfigs.values()) {
+    for (const root of config.roots) {
+      if (isInside(root, file)) {
+        runtimeConfigLookupCache.set(key, config);
+        return config;
+      }
+    }
+  }
+  runtimeConfigLookupCache.set(key, null);
+  return;
+}
+function sourceRootForFile(config, file) {
+  const dir = path3.dirname(file);
+  if (isInside(config.appPath, dir))
+    return config.appPath;
+  return packageRootsForConfig(config).find((root) => isInside(root, dir)) ?? dir;
+}
+function packageRootsForConfig(config) {
+  let roots = packageRootCache.get(config);
+  if (!roots) {
+    roots = workspacePackageRoots(config.workspaceRoot);
+    packageRootCache.set(config, roots);
+  }
+  return roots;
+}
+function firstRuntimeConfig() {
+  for (const config of runtimeConfigs.values())
+    return config;
+  return;
+}
+function firstAliasForSpecifier(specifier) {
+  if (firstAliasCache.has(specifier))
+    return firstAliasCache.get(specifier) ?? undefined;
+  for (const config of runtimeConfigs.values()) {
+    const target = config.aliases.get(specifier);
+    if (target) {
+      firstAliasCache.set(specifier, target);
+      return target;
+    }
+  }
+  firstAliasCache.set(specifier, null);
+  return;
+}
+async function transformSource(file) {
+  const fileStat = await stat3(file);
+  const cached = transformCache.get(file);
+  if (cached?.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) {
+    return cached.code;
+  }
+  const pendingKey = `${file}\x00${fileStat.mtimeMs}\x00${fileStat.size}`;
+  const pending = pendingTransforms.get(pendingKey);
+  if (pending)
+    return pending;
+  const started = transformSourceUncached(file, fileStat);
+  pendingTransforms.set(pendingKey, started);
+  try {
+    return await started;
+  } finally {
+    if (pendingTransforms.get(pendingKey) === started)
+      pendingTransforms.delete(pendingKey);
+  }
+}
+async function transformSourceUncached(file, fileStat) {
+  const diskCache = transformCacheFile(file, fileStat);
+  if (diskCache) {
+    const code = await readFile3(diskCache, "utf8").catch(() => {
+      return;
+    });
+    if (code !== undefined) {
+      transformCache.set(file, { mtimeMs: fileStat.mtimeMs, size: fileStat.size, code });
+      return code;
+    }
+  }
+  const runtime = runtimeConfigForFile(file);
+  let raw = await readFile3(file, "utf8");
+  if (/\.mdx?$/.test(file) && !file.includes(`${path3.sep}cache${path3.sep}server${path3.sep}`)) {
+    const { compileMdx } = await import("./compile-53j02j27.js");
+    raw = (await compileMdx(raw, file, runtime?.root ?? path3.dirname(file))).code;
+  }
+  const source = await inlineModuleScopeRequires(rewriteServerSource(raw, file, {
+    root: runtime?.root
+  }), file, runtime?.root);
+  const result = await transform(source, {
+    loader: esbuildLoader(file),
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    sourcefile: file,
+    target: "es2022",
+    ...serverDefineOptions()
+  });
+  transformCache.set(file, {
+    mtimeMs: fileStat.mtimeMs,
+    size: fileStat.size,
+    code: result.code
+  });
+  if (diskCache) {
+    await mkdir3(path3.dirname(diskCache), { recursive: true }).catch(() => {
+      return;
+    });
+    const write = writeFileAtomic(diskCache, result.code).catch(() => {
+      return;
+    });
+    transformWrites.add(write);
+    write.finally(() => transformWrites.delete(write));
+  }
+  return result.code;
+}
+var transformWrites = new Set;
+async function prewarmServerTransforms(root, files) {
+  const loadable = rootFilter(root);
+  await Promise.all([...files].map(async (file) => {
+    if (!loadable.test(file))
+      return;
+    const stats = await stat3(file).catch(() => {
+      return;
+    });
+    if (!stats || !transformCacheFile(file, stats))
+      return;
+    await transformSource(file).catch(() => {
+      return;
+    });
+  }));
+  while (transformWrites.size > 0)
+    await Promise.all([...transformWrites]);
+}
+var transformDiskCacheDisabled = process.env.PNEXT_TRANSFORM_DISK_CACHE === "0";
+var materializedSegment = `${path3.sep}cache${path3.sep}server${path3.sep}`;
+function transformCacheFile(file, fileStat) {
+  if (transformDiskCacheDisabled)
+    return;
+  const at = file.lastIndexOf(materializedSegment);
+  if (at === -1)
+    return;
+  const cacheRoot2 = file.slice(0, at + materializedSegment.length);
+  const key = `${file}\x00${fileStat.mtimeMs}\x00${fileStat.size}\x00${currentLoadExtras().join(",")}\x00${JSON.stringify(serverDefineOptions())}\x00${frameworkFingerprint()}`;
+  return path3.join(cacheRoot2, "transform", `${hashBundleSpecifier(key)}.js`);
+}
+var REQUIRE_CALL = /\b(?:__)?require\(\s*(['"])((?:\.\.?\/|\/|file:\/\/)[^'"]+)\1\s*\)/g;
+async function inlineModuleScopeRequires(source, file, root) {
+  if (!root || !source.includes("require("))
+    return source;
+  const filter = rootFilter(root);
+  const sidecars = new Map;
+  const pending = [];
+  const seen = new Set;
+  for (const match of source.matchAll(REQUIRE_CALL)) {
+    const specifier = match[2];
+    if (seen.has(specifier))
+      continue;
+    seen.add(specifier);
+    const target = requireCallTarget(root, file, specifier);
+    if (!target || !filter.test(target))
+      continue;
+    pending.push(requireCjsSidecar(target).then((sidecar) => {
+      if (sidecar)
+        sidecars.set(specifier, sidecar);
+    }));
+  }
+  if (pending.length === 0)
+    return source;
+  await Promise.all(pending);
+  if (sidecars.size === 0)
+    return source;
+  return source.replace(REQUIRE_CALL, (whole, quote, specifier) => {
+    const sidecar = sidecars.get(specifier);
+    return sidecar ? `require(${quote}${sidecar}${quote})` : whole;
+  });
+}
+function requireCallTarget(root, file, specifier) {
+  if (specifier.startsWith("file://")) {
+    try {
+      return resolveImport(root, file, fileURLToPath2(specifier), runtimeConfigForFile(file)?.resolved.workspaceRoot);
+    } catch {
+      return;
+    }
+  }
+  return resolveImport(root, file, specifier, runtimeConfigForFile(file)?.resolved.workspaceRoot);
+}
+async function requireCjsSidecar(target) {
+  try {
+    const sidecar = requireCjsSidecarPath(target);
+    const fileStat = await stat3(target);
+    const cached = requireSidecarCache.get(target);
+    if (cached?.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size)
+      return sidecar;
+    const runtime = runtimeConfigForFile(target);
+    const source = rewriteServerSource(await readFile3(target, "utf8"), target, {
+      root: runtime?.root
+    });
+    const result = await transform(source, {
+      loader: esbuildLoader(target),
+      jsx: "automatic",
+      jsxImportSource: "preact",
+      sourcefile: target,
+      target: "es2022",
+      format: "cjs",
+      ...serverDefineOptions()
+    });
+    await writeFile(sidecar, result.code);
+    requireSidecarCache.set(target, { mtimeMs: fileStat.mtimeMs, size: fileStat.size });
+    return sidecar;
+  } catch {
+    return;
+  }
+}
+function requireCjsSidecarPath(target) {
+  return `${target.replace(/\.[^./\\]+$/, "")}.pnext-require.cjs`;
+}
+async function transformNodeModuleSource(file) {
+  const fileStat = await stat3(file);
+  const cached = nodeModuleTransformCache.get(file);
+  if (cached?.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) {
+    return cached.code;
+  }
+  const record = nodeModuleBundleRecordFile(file, fileStat);
+  const reused = record ? await readNodeModuleBundle(record) : undefined;
+  if (reused !== undefined) {
+    nodeModuleTransformCache.set(file, {
+      mtimeMs: fileStat.mtimeMs,
+      size: fileStat.size,
+      code: reused
+    });
+    return reused;
+  }
+  const { code, inputs } = await bundleNodeModuleSource(file);
+  nodeModuleTransformCache.set(file, {
+    mtimeMs: fileStat.mtimeMs,
+    size: fileStat.size,
+    code
+  });
+  if (record)
+    writeNodeModuleBundle(record, inputs, code);
+  return code;
+}
+function nodeModuleBundleRecordFile(file, fileStat) {
+  if (transformDiskCacheDisabled)
+    return;
+  const outPath = (runtimeConfigForFile(file) ?? firstRuntimeConfig())?.resolved.outPath;
+  if (!outPath)
+    return;
+  const key = `${file}\x00${fileStat.mtimeMs}\x00${fileStat.size}\x00${currentLoadExtras().join(",")}\x00${JSON.stringify(serverDefineOptions())}\x00${frameworkFingerprint()}`;
+  return path3.join(cacheRoot(outPath), "node-module-bundle", `${hashBundleSpecifier(key)}.json`);
+}
+async function bundleNodeModuleSource(file) {
+  const resolved = runtimeConfigForFile(file)?.resolved;
+  const extensionPlugins = resolved ? getBundlerExtensions().serverEsbuildPlugins(resolved) : [];
+  const result = await build({
+    entryPoints: [
+      (resolved ? getBundlerExtensions().serverBundleEntry(file, path3.dirname(file), file) : undefined) ?? file
+    ],
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    loader: packageJsxLoaders,
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    packages: "external",
+    logLevel: "silent",
+    metafile: true,
+    ...serverDefineOptions(),
+    plugins: [
+      serverAssetPlugin(),
+      ...extensionPlugins,
+      runtimeAliasBuildPlugin(undefined, "server", { bundleRequireAliases: true })
+    ]
+  });
+  const output = result.outputFiles[0];
+  if (!output)
+    throw new Error(`Failed to bundle ${file}`);
+  return {
+    code: applyBundledSourceTransforms(output.text, file),
+    inputs: Object.keys(result.metafile.inputs).map((input) => path3.resolve(input))
+  };
+}
+function needsServerSourceRewrite(source) {
+  return sourceHasDynamicImport(source) || sourceNeedsServerTransforms(source);
+}
+function rewriteServerSource(source, file, options = {}) {
+  const root = options.root ?? path3.dirname(file);
+  const rewritten = sourceHasDynamicImport(source) ? rewriteDynamicCallTargets(rewriteLiteralDynamicCalls(source, file), (specifier) => resolveImport(root, file, specifier, runtimeConfigForFile(file)?.resolved.workspaceRoot), file) : source;
+  if (options.nextFonts === false)
+    return rewritten;
+  if (!sourceNeedsServerTransforms(rewritten))
+    return rewritten;
+  return applyServerSourceTransforms(applyServerSourcePreTransforms(rewritten, file, options.root), file, options.root);
+}
+function serverRequireAlias(specifier, target, kind) {
+  if (kind !== "require-call")
+    return target;
+  if (specifier === "next/navigation" && target.endsWith(`${path3.sep}navigation.ts`)) {
+    return path3.join(path3.dirname(target), "navigation.cjs");
+  }
+  if (specifier === "next/router" && target.endsWith(`${path3.sep}router.ts`)) {
+    return path3.join(path3.dirname(target), "router.cjs");
+  }
+  return target;
+}
+function runtimeAliasBuildPlugin(config, target = "server", options = {}) {
+  const aliases = config ? coreAliases(config, target) : undefined;
+  const reactServerLayerAliases = config && options.reactServerLayer ? getImportAliasExtensions().reactServerLayerAliases(config) : undefined;
+  return {
+    name: "pnext-runtime-build-alias",
+    setup(build2) {
+      build2.onResolve({ filter: /^\.\/preact$/ }, (args) => {
+        const hasRealSibling = [".ts", ".tsx", ".js", ".mjs", ".jsx"].some((ext) => existsSync(path3.join(args.resolveDir, `preact${ext}`)));
+        const compatPreact = path3.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", "compat", "react", "preact.ts");
+        if (hasRealSibling && path3.resolve(args.resolveDir, "preact.ts") !== compatPreact)
+          return;
+        return { path: compatPreact };
+      });
+      build2.onResolve({ filter: /^\.\.\/client\/errors\/primitive-throw$/ }, (args) => {
+        const compatPreact = path3.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", "compat", "react", "preact.ts");
+        if (path3.resolve(args.importer) !== compatPreact)
+          return;
+        return {
+          path: path3.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", "compat", "client", "errors", "primitive-throw.ts")
+        };
+      });
+      build2.onResolve({ filter: aliasSpecifierFilter }, (args) => {
+        const resolved = aliases?.[args.path] ?? firstAliasForSpecifier(args.path);
+        if (!resolved)
+          return;
+        const requireTarget = serverRequireAlias(args.path, resolved, args.kind);
+        if (requireTarget !== resolved)
+          return { path: requireTarget };
+        if (options.bundleRequireAliases && args.kind === "require-call") {
+          const layerTarget = serverRequireAlias(args.path, reactServerLayerAliases?.[args.path] ?? resolved, args.kind);
+          return { path: path3.isAbsolute(layerTarget) ? layerTarget : require2.resolve(layerTarget) };
+        }
+        return {
+          path: path3.isAbsolute(resolved) ? pathToFileHref(resolved) : resolved,
+          external: true
+        };
+      });
+    }
+  };
+}
+function isInside(root, file) {
+  const relative = path3.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+function rootPaths(root) {
+  const key = path3.resolve(root);
+  const cached = rootPathCache.get(key);
+  if (cached)
+    return cached;
+  const paths = new Set([path3.resolve(root)]);
+  try {
+    paths.add(realpathSync.native(root));
+  } catch {}
+  const resolved = [...paths];
+  rootPathCache.set(key, resolved);
+  return resolved;
+}
+function rootFilter(root, projectRoot = false) {
+  const extras = currentLoadExtras().map(escapeRegex);
+  const exts = [projectRoot ? "tsx?|jsx" : "[jt]sx?", ...extras].join("|");
+  const vendorGuard = vendorLoadsNatively() ? `${root.endsWith(`${path3.sep}cache${path3.sep}server`) ? "(?!\\/vendor\\/)" : ""}(?!.*\\/cache\\/server\\/vendor\\/)` : "";
+  const serverGuard = [...runtimeConfigs.values()].flatMap((runtime) => rootPaths(path3.join(runtime.resolved.outPath, "server"))).map((serverRoot) => `(?!${escapeRegex(serverRoot)}(?:/|$))`).join("");
+  return new RegExp(`^${serverGuard}${escapeRegex(root)}${vendorGuard}(?!.*\\/node_modules\\/)(?!\\/next\\.config\\.(?:js|cjs|mjs|ts)$)(?:/.*)?\\.(?:${exts})$`);
+}
+function esbuildLoader(file) {
+  if (file.endsWith(".tsx"))
+    return "tsx";
+  if (file.endsWith(".ts"))
+    return "ts";
+  return "jsx";
+}
+function hashRoot(value) {
+  let hash = 5381;
+  for (const char of value)
+    hash = (hash << 5) + hash ^ char.charCodeAt(0);
+  return (hash >>> 0).toString(36);
+}
+function hashBundleSpecifier(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 16);
+}
+function vendorLoadsNatively() {
+  return process.env.PNEXT_VENDOR_DIST_NATIVE !== "0";
+}
+var serverIgnoredAssetFilter = /\.(?:css|scss|sass|woff2?|ttf|otf|eot|png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/;
+function isCssFile(file) {
+  return file.endsWith(".css");
+}
+function isStaticImageFile(file) {
+  return /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/.test(file);
+}
+function resolveAssetPath(specifier, resolveDir) {
+  const [sourcePath = "", hash = ""] = specifier.split("#", 2);
+  const resolved = path3.isAbsolute(sourcePath) ? sourcePath : path3.resolve(resolveDir, sourcePath);
+  return hash ? `${resolved}#${hash}` : resolved;
+}
+async function staticImageModuleSource(config, file) {
+  const [sourcePath = ""] = file.split("#", 1);
+  const bytes = new Uint8Array(await readFile3(sourcePath));
+  const emitted = [];
+  const emit = (relative, data) => {
+    emitted.push({ relative, bytes: data });
+    return `/${relative}`;
+  };
+  const compat = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit });
+  const source = compat ?? coreStaticAssetModule(sourcePath, bytes, emit);
+  if (config) {
+    for (const asset of emitted) {
+      const target = path3.join(config.outPath, "public", ...asset.relative.split("/"));
+      await mkdir3(path3.dirname(target), { recursive: true });
+      if (!existsSync(target))
+        await Bun.write(target, asset.bytes);
+    }
+  }
+  return source;
+}
+function coreStaticAssetModule(sourcePath, bytes, emit) {
+  const ext = path3.extname(sourcePath).toLowerCase() || ".bin";
+  const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 8);
+  const base = path3.basename(sourcePath, path3.extname(sourcePath)).replace(/[^A-Za-z0-9_-]+/g, "-");
+  const relative = getAssetExtensions().staticAssetRelativePath({ sourcePath, hash, base, ext });
+  const src = emit(relative, bytes);
+  return `const src = ${JSON.stringify(src)};
+export default src;
+export { src };
+`;
+}
+function serverAssetPlugin(config) {
+  return {
+    name: "pnext-empty-server-assets",
+    setup(build2) {
+      build2.onResolve({ filter: serverIgnoredAssetFilter }, (args) => {
+        const resolved = resolveAssetPath(args.path, args.resolveDir);
+        if (getAssetExtensions().hasLoaderRuleFor(resolved)) {
+          return;
+        }
+        return { path: resolved, namespace: "pnext-empty-server-asset" };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "pnext-empty-server-asset" }, async (args) => ({
+        contents: getCssExtensions().loadCssModuleForClient(args.path) ?? (isCssFile(args.path) ? "" : isStaticImageFile(args.path) ? await staticImageModuleSource(config, args.path) : 'export default "";'),
+        loader: "js"
+      }));
+    }
+  };
+}
+
+export { devHeadTrimEnabled, setDevWatcherFreshness, devSourceIdentity, DEV_SOURCE_MISSING, isBinaryDevSource, devTextSourceHash, flushDevModuleCaches, devModuleCache, cacheRoot, noteDevArtifactWritten, devArtifactUsable, compiledSourceGraph, pagesBundleTargetForRuntime, serverBundleConditions, serverBundleRequireConditions, packageJsxLoaders, registerServerRuntime, deferServerRuntimePlugins, installServerRuntimePlugins, coreAliases, aliasSpecifierFilter, nodeModuleSourceLoadsAsIs, statSignature, recordNativeNodeModuleFiles, firstAliasForSpecifier, prewarmServerTransforms, transformCacheFile, needsServerSourceRewrite, rewriteServerSource, serverRequireAlias, runtimeAliasBuildPlugin, hashBundleSpecifier, vendorLoadsNatively, serverIgnoredAssetFilter, serverAssetPlugin };