@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,4130 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  devDynamicSplitEnabled,
+  rewriteDeferredDynamicImports,
+  rewriteLiteralDynamicCalls
+} from "./index-91x12ykq.js";
+import {
+  ISLAND_BOUNDARY_ERROR_DIGEST_ATTRIBUTE,
+  ISLAND_BOUNDARY_ERROR_ELEMENT,
+  ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE,
+  ISLAND_STATIC_CHILDREN_ATTRIBUTE,
+  clientEntryName
+} from "./index-3tf1xjsp.js";
+import {
+  findLayouts
+} from "./index-jepjvcrf.js";
+import {
+  cssModuleClientPlugin
+} from "./index-2dv4y4wd.js";
+import {
+  createVerboseLogger,
+  formatDuration
+} from "./index-73z4esab.js";
+import {
+  assetContentHash,
+  withAssetPrefix
+} from "./index-y2jr2n72.js";
+import {
+  frameworkFingerprint
+} from "./index-c0g2wf3z.js";
+import {
+  readSourceSync,
+  readSourceText
+} from "./index-fp8r0sqs.js";
+import {
+  ensureDir,
+  listFiles,
+  readText,
+  writeText
+} from "./index-20ppawv7.js";
+import {
+  traceEnabled
+} from "./index-vz0km5qk.js";
+import {
+  frameworkRuntimeAliasEntries,
+  publicEnvDefines
+} from "./index-x93hv0sc.js";
+import {
+  dim
+} from "./index-6kp9r0d9.js";
+import {
+  clientReferenceId,
+  ssrClientReference
+} from "./index-ras0sdab.js";
+import {
+  scanFacts
+} from "./index-z4z9zv3b.js";
+import {
+  getExternalPackagePolicy,
+  resolveImport,
+  resolveLinkedPackageSpecifier
+} from "./index-yz54pxrh.js";
+import {
+  applyClientSourceAsyncPreTransforms,
+  applyClientSourceTransforms,
+  getAssetExtensions,
+  getBundlerExtensions,
+  getCompatModeExtensions,
+  getImportAliasExtensions,
+  hasClientSourceAsyncPreTransforms
+} from "./index-zqpqyg8p.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+
+// src/client/build.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync, statSync as statSync3 } from "fs";
+import { copyFile, mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import path5 from "path";
+import {
+  build as build3
+} from "esbuild";
+
+// src/client/chunk-fold.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { unlink } from "fs/promises";
+import path from "path";
+import { build } from "esbuild";
+
+// src/client/profile.ts
+var enabled = traceEnabled("client");
+var totals = new Map;
+var spans = new Map;
+function unionMs(intervals) {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+  let total = 0;
+  let [openStart, openEnd] = sorted[0] ?? [0, 0];
+  for (const [start, end] of sorted.slice(1)) {
+    if (start > openEnd) {
+      total += openEnd - openStart;
+      [openStart, openEnd] = [start, end];
+    } else if (end > openEnd) {
+      openEnd = end;
+    }
+  }
+  return total + (openEnd - openStart);
+}
+var clientProfile = {
+  enabled,
+  time(phase, task) {
+    if (!enabled)
+      return task();
+    const start = performance.now();
+    try {
+      return task();
+    } finally {
+      totals.set(phase, (totals.get(phase) ?? 0) + (performance.now() - start));
+    }
+  },
+  async timeAsync(phase, task) {
+    if (!enabled)
+      return task();
+    const start = performance.now();
+    try {
+      return await task();
+    } finally {
+      (spans.get(phase) ?? spans.set(phase, []).get(phase)).push([start, performance.now()]);
+    }
+  },
+  count(key, by = 1) {
+    if (!enabled)
+      return;
+    totals.set(key, (totals.get(key) ?? 0) + by);
+  },
+  reset() {
+    totals.clear();
+    spans.clear();
+  },
+  snapshot() {
+    return {
+      ...Object.fromEntries(totals),
+      ...Object.fromEntries([...spans].map(([phase, list]) => [phase, unionMs(list)]))
+    };
+  },
+  report(label) {
+    if (!enabled)
+      return;
+    const snap = this.snapshot();
+    const line = Object.entries(snap).map(([phase, value]) => `${phase} ${value < 100 ? value.toFixed(1) : Math.round(value)}`).join(" \xB7 ");
+    console.log(`pnext client profile [${label}] ${line}`);
+    this.reset();
+  }
+};
+
+// src/client/chunk-fold.ts
+function ignoreMissing() {
+  return;
+}
+var namedClause = String.raw`\{([^}]*)\}`;
+async function foldInitialChunks(options) {
+  if (process.env.PNEXT_CHUNK_FOLD === "0")
+    return options.metafile;
+  if (!options.buildOptions.minify)
+    return options.metafile;
+  return foldChunks(options);
+}
+async function foldChunks({ outDir, metafile, buildOptions }) {
+  let folded = metafile;
+  const groups = clientProfile.time("foldGroups", () => coLoadGroups(metafile));
+  clientProfile.count("foldGroup#", groups.length);
+  clientProfile.count("foldOutput#", Object.keys(metafile.outputs).length);
+  if (groups.length === 0)
+    return folded;
+  const state = await clientProfile.timeAsync("foldRead", () => createFoldState(outDir, metafile));
+  for (const group of groups) {
+    const mutation = { started: false };
+    try {
+      folded = await foldGroup({ outDir, metafile: folded, buildOptions }, group, mutation, state);
+    } catch (error) {
+      if (mutation.started)
+        throw error;
+      reportFoldFailure(group, error);
+      break;
+    }
+  }
+  return folded;
+}
+function reportFoldFailure(group, error) {
+  const names = group.map((member) => path.basename(member)).join(", ");
+  const message = error instanceof Error ? error.message : String(error);
+  if (process.env.PNEXT_CHUNK_FOLD === "strict") {
+    throw new Error(`client chunk fold failed for [${names}]: ${message}`);
+  }
+  console.warn(`pnext: client chunk fold skipped [${names}] \u2014 ${message}`);
+}
+async function foldGroup({ outDir, metafile, buildOptions }, members, mutation, state) {
+  if (members.length < 2)
+    return metafile;
+  const chunksDir = path.join(outDir, "chunks");
+  const memberNames = members.map((output) => path.basename(output));
+  if (memberNames.some((name) => !existsSync(path.join(chunksDir, name))))
+    return metafile;
+  const sources = new Map(await Promise.all(memberNames.map(async (name) => {
+    const file = path.join(chunksDir, name);
+    return [name, state.outputs.get(file)?.text ?? await readText(file)];
+  })));
+  const aliases = memberAliases(memberNames, sources);
+  if (!aliases)
+    return metafile;
+  const rewrites = new Map;
+  const rewrite = memberRewriter(memberNames, aliases, chunksDir);
+  const rewritable = clientProfile.time("foldRewrite", () => {
+    for (const file of state.referrersOf(memberNames)) {
+      if (memberNames.includes(path.basename(file)))
+        continue;
+      const output = state.outputs.get(file);
+      if (!output)
+        continue;
+      const next = rewrite(output.text, file);
+      if (next === null)
+        return false;
+      if (next !== output.text)
+        rewrites.set(file, next);
+    }
+    return true;
+  });
+  if (!rewritable)
+    return metafile;
+  const merged = await clientProfile.timeAsync("foldBuild", () => buildMergedChunk(chunksDir, memberNames, aliases, buildOptions));
+  if (!merged)
+    return metafile;
+  mutation.started = true;
+  await Promise.all([...rewrites].map(([file, source]) => {
+    const next = source.replaceAll(MERGED_PLACEHOLDER, merged.name);
+    state.set(file, foldOutput(next));
+    return writeText(file, next);
+  }));
+  await Promise.all(memberNames.flatMap((name) => [
+    unlink(path.join(chunksDir, name)).catch(ignoreMissing),
+    unlink(path.join(chunksDir, `${name}.map`)).catch(ignoreMissing)
+  ]));
+  for (const name of memberNames)
+    state.remove(path.join(chunksDir, name));
+  state.set(path.join(chunksDir, merged.name), foldOutput(merged.text));
+  return mergeMetafile(metafile, members, path.join(chunksDir, merged.name), merged.bytes);
+}
+function coLoadGroups(metafile) {
+  const dynamicTargets = new Set;
+  for (const output of Object.values(metafile.outputs)) {
+    for (const imported of output.imports ?? []) {
+      if (imported.kind === "dynamic-import")
+        dynamicTargets.add(imported.path);
+    }
+  }
+  const entries = Object.keys(metafile.outputs).filter((file) => metafile.outputs[file]?.entryPoint && !dynamicTargets.has(file));
+  if (entries.length === 0)
+    return [];
+  const available = availability(metafile, entries, dynamicTargets);
+  const roots = [...available.keys()];
+  const groups = new Map;
+  for (const file of Object.keys(metafile.outputs)) {
+    if (!file.endsWith(".js"))
+      continue;
+    if (entries.includes(file) || dynamicTargets.has(file))
+      continue;
+    const mask = roots.map((root) => available.get(root).has(file) ? "1" : "0").join("");
+    if (!mask.includes("1"))
+      continue;
+    (groups.get(mask) ?? groups.set(mask, []).get(mask)).push(file);
+  }
+  return [...groups.values()].filter((group) => group.length > 1 && entries.some((entry) => available.get(entry).has(group[0]))).map((group) => [...group].sort());
+}
+function availabilityAt(available, file, memo) {
+  const own = available.get(file);
+  if (own)
+    return own;
+  const cached = memo.get(file);
+  if (cached)
+    return cached;
+  let acc;
+  for (const set of available.values()) {
+    if (!set.has(file))
+      continue;
+    acc = acc === undefined ? new Set(set) : intersect(acc, set);
+  }
+  const answer = acc ?? new Set([file]);
+  memo.set(file, answer);
+  return answer;
+}
+function entryFloors(metafile, entries, closures) {
+  const dynamicEdges = new Map;
+  for (const [file, output] of Object.entries(metafile.outputs)) {
+    for (const imported of output.imports ?? []) {
+      if (imported.kind !== "dynamic-import")
+        continue;
+      (dynamicEdges.get(file) ?? dynamicEdges.set(file, []).get(file)).push(imported.path);
+    }
+  }
+  const floors = new Map;
+  for (const entry of entries) {
+    const own = closures.get(entry);
+    const seen = new Set(own);
+    const queue = [...own];
+    for (const current of queue) {
+      for (const target of dynamicEdges.get(current) ?? []) {
+        if (seen.has(target))
+          continue;
+        for (const file of closures.get(target) ?? staticClosure(metafile, target)) {
+          if (seen.has(file))
+            continue;
+          seen.add(file);
+          queue.push(file);
+        }
+        const floor = floors.get(target);
+        floors.set(target, floor ? intersect(floor, own) : new Set(own));
+      }
+    }
+  }
+  return floors;
+}
+function availability(metafile, entries, dynamicTargets) {
+  const available = new Map;
+  const closures = new Map;
+  for (const root of [...entries, ...dynamicTargets]) {
+    closures.set(root, staticClosure(metafile, root));
+    available.set(root, new Set(closures.get(root)));
+  }
+  for (const [target, floor] of entryFloors(metafile, entries, closures)) {
+    const set = available.get(target);
+    if (set)
+      for (const file of floor)
+        set.add(file);
+  }
+  const importersOf = new Map;
+  for (const [file, output] of Object.entries(metafile.outputs)) {
+    for (const imported of output.imports ?? []) {
+      if (imported.kind !== "dynamic-import")
+        continue;
+      (importersOf.get(imported.path) ?? importersOf.set(imported.path, []).get(imported.path)).push(file);
+    }
+  }
+  const memo = new Map;
+  for (let round = 0;round < dynamicTargets.size + 1; round += 1) {
+    let changed = false;
+    for (const target of dynamicTargets) {
+      const importers = importersOf.get(target) ?? [];
+      let inherited;
+      for (const importer of importers) {
+        const from = availabilityAt(available, importer, memo);
+        inherited = inherited === undefined ? new Set(from) : intersect(inherited, from);
+      }
+      const next = new Set([...closures.get(target), ...inherited ?? []]);
+      if (next.size !== available.get(target).size) {
+        available.set(target, next);
+        memo.clear();
+        changed = true;
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return available;
+}
+function staticClosure(metafile, root) {
+  const seen = new Set([root]);
+  const queue = [root];
+  for (const current of queue) {
+    for (const imported of metafile.outputs[current]?.imports ?? []) {
+      if (imported.kind !== "import-statement")
+        continue;
+      if (seen.has(imported.path))
+        continue;
+      seen.add(imported.path);
+      queue.push(imported.path);
+    }
+  }
+  return seen;
+}
+function intersect(a, b) {
+  return new Set([...a].filter((item) => b.has(item)));
+}
+function memberAliases(memberNames, sources) {
+  const aliases = new Map;
+  for (const [index, name] of memberNames.entries()) {
+    const source = sources.get(name);
+    if (/export\s*\*/.test(source))
+      return;
+    const clauses = [
+      ...source.matchAll(new RegExp(String.raw`export\s*${namedClause}\s*(?!from)`, "g"))
+    ];
+    const clause = clauses.at(-1);
+    const names = new Map;
+    for (const part of clause?.[1]?.split(",") ?? []) {
+      const exported = part.split(" as ").at(-1)?.trim();
+      if (exported)
+        names.set(exported, `$${index}${exported}`);
+    }
+    aliases.set(name, names);
+  }
+  return aliases;
+}
+function memberRewriter(memberNames, aliases, chunksDir) {
+  const memberPattern = memberNames.map(escapeRegex).join("|");
+  const specifier = String.raw`"\.[^"]*(?:${memberPattern})"`;
+  const vetoes = [
+    new RegExp(String.raw`import\s*\*\s*as\s*[\w$]+\s*from\s*${specifier}`),
+    new RegExp(String.raw`export\s*\*[^;]*from\s*${specifier}`),
+    new RegExp(String.raw`import\(\s*${specifier}`),
+    new RegExp(String.raw`"[^".][^"]*(?:${memberPattern})"`)
+  ];
+  const namedImport = new RegExp(String.raw`(import|export)\s*${namedClause}\s*from\s*(${specifier})`, "g");
+  const sideEffectImport = new RegExp(String.raw`import\s*(${specifier})`, "g");
+  const nameOf = (spec) => memberNames.find((name) => spec.includes(name));
+  const rename = (clause, member) => clause.split(",").map((part) => {
+    const [imported, local] = part.split(" as ").map((item) => item.trim());
+    if (!imported)
+      return part;
+    const alias = aliases.get(member)?.get(imported);
+    if (!alias)
+      return part;
+    return `${alias} as ${local ?? imported}`;
+  }).join(",");
+  return (source, file) => {
+    for (const veto of vetoes)
+      if (veto.test(source))
+        return null;
+    const mergedHref = path.relative(path.dirname(file), path.join(chunksDir, MERGED_PLACEHOLDER)).split(path.sep).join("/");
+    const href = mergedHref.startsWith(".") ? mergedHref : `./${mergedHref}`;
+    return source.replace(namedImport, (_all, keyword, clause, spec) => `${keyword}{${rename(clause, nameOf(spec))}}from"${href}"`).replace(sideEffectImport, () => `import"${href}"`);
+  };
+}
+var MERGED_PLACEHOLDER = "\x00pnext-merged\x00";
+async function buildMergedChunk(chunksDir, memberNames, aliases, buildOptions) {
+  const barrel = memberNames.map((name) => {
+    const names = aliases.get(name);
+    const spec = JSON.stringify(`./${name}`);
+    if (names.size === 0)
+      return `import ${spec};`;
+    const clause = [...names].map(([exported, alias]) => `${exported} as ${alias}`).join(",");
+    return `export {${clause}} from ${spec};`;
+  }).join(`
+`);
+  const barrelPath = path.join(chunksDir, "__pnext-fold-barrel.js");
+  await writeText(barrelPath, barrel);
+  try {
+    const result = await build({
+      minify: buildOptions.minify,
+      sourcemap: buildOptions.sourcemap,
+      target: buildOptions.target,
+      format: buildOptions.format ?? "esm",
+      bundle: true,
+      entryPoints: [barrelPath],
+      outfile: path.join(chunksDir, "__pnext-fold-merged.js"),
+      write: false,
+      plugins: [
+        {
+          name: "pnext-fold-members",
+          setup(builder) {
+            builder.onResolve({ filter: /.*/ }, (args) => {
+              if (args.kind === "entry-point")
+                return;
+              const base = path.basename(args.path);
+              if (memberNames.includes(base))
+                return { path: path.join(chunksDir, base) };
+              return { path: args.path, external: true };
+            });
+          }
+        }
+      ]
+    });
+    const js = result.outputFiles?.find((file) => file.path.endsWith(".js"));
+    if (!js)
+      return;
+    const hash = createHash("sha256").update(js.contents).digest("hex").slice(0, 8).toUpperCase();
+    const name = `shared-init-${hash}.js`;
+    const map = result.outputFiles?.find((file) => file.path.endsWith(".js.map"));
+    let contents = new TextDecoder().decode(js.contents);
+    if (map) {
+      contents = contents.replace(/# sourceMappingURL=.*$/m, `# sourceMappingURL=${name}.map`);
+      await writeText(path.join(chunksDir, `${name}.map`), new TextDecoder().decode(map.contents));
+    }
+    await writeText(path.join(chunksDir, name), contents);
+    return { name, text: contents, bytes: Buffer.byteLength(contents) };
+  } finally {
+    await unlink(barrelPath).catch(ignoreMissing);
+  }
+}
+function foldOutput(text) {
+  return { text, specifiers: [...text.matchAll(/"[./][^"]*"/g)].map((match) => match[0]) };
+}
+async function createFoldState(outDir, metafile) {
+  const outputs = new Map;
+  const referrers = new Map;
+  const index = (file, output, add) => {
+    for (const spec of output.specifiers) {
+      const base = path.basename(spec.slice(1, -1));
+      const set = referrers.get(base) ?? referrers.set(base, new Set).get(base);
+      if (add)
+        set.add(file);
+      else
+        set.delete(file);
+    }
+  };
+  const files = new Set;
+  for (const name of Object.keys(metafile.outputs)) {
+    if (!name.endsWith(".js"))
+      continue;
+    const resolved = path.resolve(name);
+    const local = existsSync(resolved) ? resolved : path.join(outDir, path.basename(name));
+    if (existsSync(local))
+      files.add(local);
+  }
+  const list = [...files];
+  const texts = await Promise.all(list.map((file) => readText(file)));
+  for (const [at, file] of list.entries()) {
+    const output = foldOutput(texts[at]);
+    outputs.set(file, output);
+    index(file, output, true);
+  }
+  return {
+    outputs,
+    referrersOf(names) {
+      const seen = new Set;
+      for (const name of names)
+        for (const file of referrers.get(name) ?? [])
+          seen.add(file);
+      return seen;
+    },
+    set(file, output) {
+      const previous = outputs.get(file);
+      if (previous)
+        index(file, previous, false);
+      outputs.set(file, output);
+      index(file, output, true);
+    },
+    remove(file) {
+      const previous = outputs.get(file);
+      if (previous)
+        index(file, previous, false);
+      outputs.delete(file);
+    }
+  };
+}
+function mergeMetafile(metafile, members, mergedPath, bytes) {
+  const memberSet = new Set(members);
+  const merged = path.relative(process.cwd(), mergedPath);
+  const outputs = {};
+  const mergedImports = [];
+  const mergedInputs = {};
+  for (const [file, output] of Object.entries(metafile.outputs)) {
+    const remap = (list) => {
+      const seen = new Set;
+      return list.flatMap((imported) => {
+        const target = memberSet.has(imported.path) ? merged : imported.path;
+        const key = `${target}:${imported.kind}`;
+        if (seen.has(key))
+          return [];
+        seen.add(key);
+        return [{ ...imported, path: target }];
+      });
+    };
+    if (memberSet.has(file)) {
+      Object.assign(mergedInputs, output.inputs);
+      for (const imported of remap(output.imports ?? [])) {
+        if (imported.path !== merged)
+          mergedImports.push(imported);
+      }
+      continue;
+    }
+    outputs[file] = { ...output, imports: remap(output.imports ?? []) };
+  }
+  outputs[merged] = {
+    imports: mergedImports,
+    exports: [],
+    inputs: mergedInputs,
+    bytes
+  };
+  return { ...metafile, outputs };
+}
+
+// src/client/entry.ts
+import path2 from "path";
+function routerModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "./router/index.ts");
+}
+function actionRouterModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/actions/router.ts");
+}
+function actionClientModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/actions/client.ts");
+}
+function navCompatModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/client/nav.ts");
+}
+function islandContextModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../render/island-context.ts");
+}
+function staticSlotsModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../render/static-slots-revive.ts");
+}
+function serializeModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../utils/serialize.ts");
+}
+function layoutSegmentHelperSource(nextCompat) {
+  const seed = `
+function pnextIslandMask(vnode, root) {
+  const mask = root.__pnextMask ??= [root.getAttribute('data-pnext-id'), 0];
+  Object.defineProperty(vnode, '__m', { enumerable: true, get() { return (this.__c || this).__pnextMask ??= mask; } });
+}`;
+  if (!nextCompat)
+    return `${seed}
+function pnextIslandVNode(h, Component, props, children, root) {
+  const vnode = children !== undefined ? h(Component, props, children) : h(Component, props);
+  pnextIslandMask(vnode, root);
+  return vnode;
+}
+`;
+  return `${seed}
+import { LayoutSegmentContext as __PNextLayoutSegmentContext, RouteParamsContext as __PNextRouteParamsContext } from ${JSON.stringify(islandContextModulePath())};
+function pnextIslandReadJson(root, attr) {
+  const raw = root && root.getAttribute ? root.getAttribute(attr) : null;
+  if (!raw) return null;
+  try { return JSON.parse(raw); } catch (e) { return null; }
+}
+function pnextIslandVNode(h, Component, props, children, root) {
+  // An explicit undefined children argument clobbers props.children in
+  // preact's createElement; plain children travel inside the parsed props.
+  let vnode = children !== undefined ? h(Component, props, children) : h(Component, props);
+  pnextIslandMask(vnode, root);
+  const segments = pnextIslandReadJson(root, 'data-pnext-layout-segments');
+  if (segments) vnode = h(__PNextLayoutSegmentContext.Provider, { value: segments }, vnode);
+  const params = pnextIslandReadJson(root, 'data-pnext-params');
+  if (params) vnode = h(__PNextRouteParamsContext.Provider, { value: params }, vnode);
+  return vnode;
+}
+`;
+}
+function islandVNodeExpr(componentExpr, propsExpr, childrenExpr, rootExpr) {
+  return `pnextIslandVNode(h, ${componentExpr}, ${propsExpr}, ${childrenExpr}, ${rootExpr})`;
+}
+function holeSeamSource() {
+  return `
+class PnextHole extends Component {
+  componentDidMount() {
+    if (this.base) this.base.__pnextHole = this;
+  }
+  componentWillUnmount() {
+    if (this.base && this.base.__pnextHole === this) this.base.__pnextHole = undefined;
+  }
+  componentWillReceiveProps(next) {
+    // A soft navigation re-adopts the parent from the incoming document's DOM;
+    // the previous document's grafted content must not outlive its children.
+    if (next.children !== this.props.children) this.setState({ adopted: undefined });
+  }
+  render(props, state) {
+    return h('pnext-hole', props.attrs, state.adopted !== undefined ? state.adopted : props.children);
+  }
+}
+`;
+}
+function lateIslandClaimSource() {
+  return `
+// The graft ($RC) swapped this hole's DOM wholesale, so re-adopting ALL of it is total: nothing in
+// the hole is still preact-owned. The re-render lands inside the parent island's tree, which is what
+// makes the new islands inherit its context.
+// Detaching an element costs it every piece of state the browser keeps outside the DOM - a lazy
+// image's deferred load observation, an iframe's document, playing media, focus - and re-inserting
+// it does not bring any of that back. moveBefore is the state-preserving move (Chrome 133+); it
+// needs both ends connected and refuses some moves outright, so a plain insert stays the fallback.
+function movePnextNode(parent, node) {
+  if (parent.moveBefore && parent.isConnected && node.isConnected) {
+    try {
+      parent.moveBefore(node, null);
+      return;
+    } catch (error) {}
+  }
+  parent.append(node);
+}
+
+// A subtree rebuilt from adopted vnodes is made of freshly created elements, and a graft can bring
+// in ones the browser had already deferred. Either way a lazy image can end up in the document with
+// no live intersection observation - no request ever fires, and it stays blank forever. Re-running
+// its source selection re-arms it WITHOUT giving up laziness; one already loading (currentSrc set)
+// or already loaded is left alone, so this never forces a fetch or duplicates one.
+// Drop the capture holder, moving its nodes into \`into\` first when the adoption cannot use them.
+function releaseHoleCapture(hole, into) {
+  const captured = hole.__pnextCaptured;
+  if (!captured) return;
+  hole.__pnextCaptured = undefined;
+  if (into) for (const node of [...captured.childNodes]) movePnextNode(into, node);
+  captured.remove();
+}
+
+function rekickLazyLoadables(root) {
+  for (const img of root.querySelectorAll('img[loading=lazy]')) {
+    if (img.complete || img.currentSrc) continue;
+    for (const name of ['src', 'srcset']) {
+      const value = img.getAttribute(name);
+      if (value === null) continue;
+      img.removeAttribute(name);
+      img.setAttribute(name, value);
+    }
+  }
+}
+
+async function adoptHoleSeam(hole) {
+  const pending = hole.__pnextAdopting;
+  if (pending) return pending;
+  const seam = hole.__pnextHole;
+  // No seam ever appeared: put the captured nodes back rather than losing them.
+  if (!seam) return releaseHoleCapture(hole, hole);
+  const adopting = (async () => {
+    const captured = hole.__pnextCaptured;
+    const children = await domChildren(captured ?? hole);
+    // Preact rebuilds the subtree from the adopted vnodes, so the server nodes they were read from
+    // would survive as unowned duplicates. Clearing and re-rendering within one task keeps the swap
+    // inside a single frame - preact's rerender is a microtask, so no paint sees the empty hole.
+    releaseHoleCapture(hole);
+    hole.replaceChildren();
+    seam.setState({ adopted: children ?? null }, () => rekickLazyLoadables(hole));
+  })();
+  hole.__pnextAdopting = adopting;
+  try {
+    await adopting;
+  } finally {
+    if (hole.__pnextAdopting === adopting) hole.__pnextAdopting = undefined;
+  }
+}
+
+// A nested host belongs to its parent island's DOM adoption pass, never to a mount of its own. Wait
+// out an adoption already in flight (its walk may still reach this host), and claim only what the
+// parent can no longer see - a host the graft materialized after the parent went live - through the
+// hole seam that owns the grafted DOM. A host under a parent that has not mounted yet stays put.
+async function claimNestedIslandRoot(root, parent) {
+  // The innermost hole whose seam is live owns this host. A nearer hole with no seam is raw grafted
+  // DOM inside an outer seam's region, so that outer one is the tree to re-adopt through.
+  let hole;
+  for (let node = root.parentElement; node && node !== parent; node = node.parentElement) {
+    if (node.localName !== 'pnext-hole') continue;
+    if (node.__pnextHole) { hole = node; break; }
+    hole ??= node;
+  }
+  // The parent is mid-adoption and has no seam here yet: its walk may already have snapshotted this
+  // hole's fallback, and its hydration then drops the DOM the graft just landed. Park the grafted
+  // nodes synchronously - ahead of that render - and adopt them from the holder once the tree is
+  // live. A walk that had NOT reached the hole yet simply adopts an empty one and gets the same
+  // content back through the seam. The holder is a hidden ELEMENT rather than a fragment: a
+  // disconnected parent is exactly what strips browser state, and moveBefore refuses one.
+  if (hole && !hole.__pnextHole && !hole.__pnextCaptured && parent.__pnextMounting) {
+    const holder = document.createElement('pnext-hole-capture');
+    holder.hidden = true;
+    document.body.append(holder);
+    hole.__pnextCaptured = holder;
+    for (const node of [...hole.childNodes]) movePnextNode(holder, node);
+  }
+  // A parent whose module failed still settles: the claim has to release its capture rather than
+  // leave the grafted nodes parked in a holder nobody will ever adopt from.
+  await parent.__pnextMounting?.catch(() => {});
+  if (!hole || (!hole.__pnextCaptured && !root.isConnected)) return;
+  return adoptHoleSeam(hole);
+}
+`;
+}
+function mountOnceSource() {
+  return `
+async function mountIslandOnce(root, mountTree) {
+  const pending = root.__pnextMounting;
+  if (pending) {
+    await pending;
+    // The other pass mounted this root; only a freshly stashed incoming
+    // placeholder (a soft-nav graft) still needs this pass to re-render.
+    if (root.__pnextLive && !root.__pnextIncoming) return;
+  }
+  const mounting = mountTree();
+  root.__pnextMounting = mounting;
+  try {
+    await mounting;
+  } finally {
+    if (root.__pnextMounting === mounting) root.__pnextMounting = undefined;
+  }
+}
+`;
+}
+function clientErrorsInstallPath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/client/errors/lazy.ts");
+}
+function clientErrorBoundaryPath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/client/errors/error-boundary.ts");
+}
+function softRefreshModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/client/errors/soft-refresh.ts");
+}
+function bareErrorBoundaryPath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/client/errors/bare-boundary.ts");
+}
+function boundaryImportSource(nextCompat, boundary, builtinNotFound) {
+  if (!nextCompat)
+    return "";
+  if (!boundary) {
+    return `import { BareErrorBoundary } from ${JSON.stringify(bareErrorBoundaryPath())};`;
+  }
+  return `import { ClientErrorBoundary } from ${JSON.stringify(clientErrorBoundaryPath())};
+import { softRefreshRoute } from ${JSON.stringify(softRefreshModulePath())};${builtinNotFound ? `
+${builtInNotFoundSource()}` : ""}`;
+}
+function errorUiModulePath() {
+  return path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/client", "../compat/lifecycle/error-ui.ts");
+}
+function builtInNotFoundSource() {
+  return `import { httpAccessFallbackUi as __pnextHttpAccessFallbackUi } from ${JSON.stringify(errorUiModulePath())};
+function __PNextBuiltInNotFound() {
+  return __pnextHttpAccessFallbackUi(404, 'This page could not be found.');
+}`;
+}
+function hasErrorBoundary(facts) {
+  return Boolean(facts.errorFile ?? facts.notFoundFile) || facts.controlFlow === true;
+}
+function routerImportSource({
+  nextCompat,
+  actions,
+  errorFile,
+  globalErrorFile,
+  notFoundFile,
+  router
+}) {
+  const base = router ? `import { installRouter, routerImportActive } from ${JSON.stringify(routerModulePath())};` : "";
+  if (!nextCompat)
+    return base;
+  const imports = [
+    `${base}
+import { installNavCompat } from ${JSON.stringify(navCompatModulePath())};
+import { installClientErrors } from ${JSON.stringify(clientErrorsInstallPath())};`
+  ];
+  if (actions) {
+    imports.push(`import { installActionRouter } from ${JSON.stringify(actionRouterModulePath())};
+import { isActionError } from ${JSON.stringify(actionClientModulePath())};`);
+  }
+  if (errorFile) {
+    if (actions) {
+      imports.push(`import { installActionErrorOverlay } from ${JSON.stringify(actionClientModulePath())};`);
+    }
+    imports.push(`import __PNextRouteErrorComponent from ${JSON.stringify(errorFile)};`);
+  }
+  if (globalErrorFile) {
+    imports.push(`import __PNextGlobalErrorComponent from ${JSON.stringify(globalErrorFile)};`);
+  }
+  if (notFoundFile) {
+    imports.push(`import __PNextRouteNotFoundComponent from ${JSON.stringify(notFoundFile)};`);
+  }
+  return imports.join(`
+`);
+}
+function syncPropsHelperSource() {
+  return `
+import { rebuildSyncProps as __pnextRebuildSyncProps } from ${JSON.stringify(serializeModulePath())};
+const __pnextSyncProps = () => (typeof window !== 'undefined' && window.__PNEXT_SYNC_PROPS__ ? __pnextRebuildSyncProps : undefined);
+`;
+}
+function propsParserSource(nextCompat) {
+  const revive = nextCompat ? "reviveSerializedErrorRefs" : "reviveSerializedRefs";
+  return `
+import { ${revive} as __pnextReviveSerializedRefs, hasPromiseProps as __pnextHasPromiseProps, revivePromiseMarkers as __pnextRevivePromiseMarkers } from ${JSON.stringify(serializeModulePath())};
+import { hasIslandStaticSlots as __pnextHasIslandSlots, reviveIslandStaticSlots as __pnextReviveIslandSlots } from ${JSON.stringify(staticSlotsModulePath())};
+// Element-valued props: the wire carries a \`$$pnext_slot\` id per element and the server rendered it
+// inside a matching \`pnext-static-slot\` host, adopted here exactly like element children. Islands
+// with no element props skip the walk on a substring test of the raw attribute.
+// \`h\` is threaded in rather than imported by the slot reviver: that would put preact in the static
+// graph of entries (visible-dynamic) that otherwise only lazy-import it.
+function islandProps(raw, root, toChildren, h) {
+  const props = parseIslandProps(raw);
+  if (!__pnextHasIslandSlots(raw)) return props;
+  return __pnextReviveIslandSlots(props, root, toChildren, h);
+}
+function parseIslandProps(raw) {
+  const props = JSON.parse(raw || '{}');${nextCompat ? `
+  const actions = typeof window !== 'undefined' ? window.__PNEXT_ACTIONS__ : undefined;` : ""}
+  // Cyclic props: the encoder wrote the self-reference as a \`$$pnext_ref\` path
+  // marker. Patch the original object back in AFTER action revival (which
+  // rebuilds plain objects, so resolving first would restore identity onto
+  // objects the revival then replaces).
+  const revived = __pnextReviveSerializedRefs(${nextCompat ? "actions ? actions.reviveProps(props) : props" : "props"});
+  // Promise props travel as markers, at the top level (a client slot page's params/searchParams) and
+  // nested in plain containers (a dehydrated react-query state's pending-query promise). Revive both
+  // into pre-fulfilled promises - see revivePromiseMarkers. The deep walk is gated on a substring
+  // test of the raw attribute, so an island with no promise props pays one indexOf.
+  return __pnextHasPromiseProps(raw || '') ? __pnextRevivePromiseMarkers(revived${nextCompat ? ", __pnextSyncProps()" : ""}) : revived;
+}
+`;
+}
+var MEASURED_HOST_TAGS = ["pnext-client", "pnext-dynamic", "pnext-static-children"];
+function hostMeasureSource() {
+  return `
+function pnextInstallHostMeasure() {
+  if (typeof customElements === 'undefined' || window.__PNEXT_HOST_MEASURE__) return;
+  window.__PNEXT_HOST_MEASURE__ = true;
+  const box = el =>
+    el.style.display === 'contents' || getComputedStyle(el).display === 'contents'
+      ? el.parentElement
+      : null;
+  class PnextHost extends HTMLElement {
+    getBoundingClientRect() {
+      const target = box(this);
+      return target ? target.getBoundingClientRect() : super.getBoundingClientRect();
+    }
+    getClientRects() {
+      const target = box(this);
+      return target ? target.getClientRects() : super.getClientRects();
+    }
+  }
+  for (const key of ['clientWidth', 'clientHeight', 'offsetWidth', 'offsetHeight', 'offsetTop', 'offsetLeft']) {
+    Object.defineProperty(PnextHost.prototype, key, {
+      configurable: true,
+      get() {
+        const target = box(this);
+        return target ? target[key] : 0;
+      },
+    });
+  }
+  for (const tag of ${JSON.stringify(MEASURED_HOST_TAGS)}) {
+    if (!customElements.get(tag)) customElements.define(tag, class extends PnextHost {});
+  }
+  // Observing the same element twice is a single native observation, so
+  // redirecting host -> parent dedupes on its own.
+  const observed = target => (target instanceof PnextHost ? (box(target) ?? target) : target);
+  const NativeResizeObserver = window.ResizeObserver;
+  if (NativeResizeObserver) {
+    window.ResizeObserver = class extends NativeResizeObserver {
+      observe(target, options) {
+        super.observe(observed(target), options);
+      }
+      unobserve(target) {
+        super.unobserve(observed(target));
+      }
+    };
+  }
+}
+pnextInstallHostMeasure();
+`;
+}
+function mountLifecycleSource(nextCompat) {
+  return `
+${nextCompat ? `// __NEXT_HYDRATED is the harness's interaction gate (test/lib/next-webdriver.ts
+// waits on it and clicks immediately after), so it must mean "the visible tree is interactive", not
+// "the island mounts were kicked off". preact's hydrate() attaches listeners during its synchronous
+// commit, so the mount promises settling IS commit-level readiness. The gate waits for every promise
+// that owns visible DOM and flips in a microtask so nothing extra is interposed under CPU load.
+// pnextGateDeadline is a deadlock guard only: a wedged dynamic import must degrade to a late gate,
+// never to a gate that never opens.
+const pnextGateDeadline = 10000;
+function pnextSettled(value) {
+  if (value === undefined) return undefined;
+  return Promise.resolve(value).then(pnextIgnore, pnextIgnore);
+}
+function pnextIgnore() {}
+function markRouteHydrated() {
+  window.__NEXT_HYDRATED = true;
+  window.__NEXT_HYDRATED_AT ??= performance.now();
+  if (typeof window.__NEXT_HYDRATED_CB === 'function') window.__NEXT_HYDRATED_CB();
+  window.dispatchEvent(new Event('pnext:hydrated'));
+}
+// A settled mount promise means the DOM is attached, NOT that useEffect ran - preact defers effects
+// to after-paint, so a layout publishing its handle from an effect is still unset when
+// __NEXT_HYDRATED flips. Drive preact's flush through options.requestAnimationFrame so "effects ran"
+// is an observable event the gate can await (plain rAF/macrotask ordering is not reliable in headless
+// Chromium).
+let pnextPendingEffectFlushes = 0;
+let pnextEffectFlushWaiters = [];
+const pnextEffectFlushRafTimeout = 100;
+function pnextDrainEffectFlush(flush) {
+  pnextPendingEffectFlushes--;
+  try {
+    flush();
+  } finally {
+    if (pnextPendingEffectFlushes <= 0) {
+      pnextPendingEffectFlushes = 0;
+      const waiters = pnextEffectFlushWaiters;
+      pnextEffectFlushWaiters = [];
+      for (const waiter of waiters) waiter();
+    }
+  }
+}
+__pnextPreactOptions.requestAnimationFrame = flush => {
+  pnextPendingEffectFlushes++;
+  let ran = false;
+  const run = () => {
+    if (ran) return;
+    ran = true;
+    pnextDrainEffectFlush(flush);
+  };
+  // preact's own afterNextFrame semantics: the frame, or a 100ms fallback for a
+  // document whose rAF never fires (a backgrounded page).
+  const timer = setTimeout(run, pnextEffectFlushRafTimeout);
+  if (typeof requestAnimationFrame === 'function') {
+    requestAnimationFrame(() => {
+      clearTimeout(timer);
+      run();
+    });
+  }
+};
+function pnextAfterEffectFlush(run) {
+  // Effects are queued during the mount's synchronous commit, so by the time
+  // the mount promise settles every pending flush is already registered above.
+  // Nothing pending means there is nothing left to wait for.
+  if (pnextPendingEffectFlushes === 0) {
+    run();
+    return;
+  }
+  pnextEffectFlushWaiters.push(run);
+}
+function pnextGate(mark, islandMounts, visibleMount) {
+  const waits = [pnextSettled(islandMounts), pnextSettled(visibleMount)].filter(Boolean);
+  if (waits.length === 0) {
+    mark();
+    return;
+  }
+  let done = false;
+  const once = () => {
+    if (done) return;
+    done = true;
+    mark();
+  };
+  const timer = setTimeout(once, pnextGateDeadline);
+  void Promise.all(waits).then(() => {
+    pnextAfterEffectFlush(() => {
+      clearTimeout(timer);
+      once();
+    });
+  });
+}
+` : ""}
+function keepsMountedRoot(root, keep) {
+  if (!keep) return false;
+  for (const kept of keep) {
+    if (root === kept) return true;
+    // The preserved client page's container is a marker-range proxy, not a
+    // Node \u2014 contains() would throw on it, and only identity can match it.
+    if (kept instanceof Node && root.contains && root.contains(kept)) return true;
+  }
+  return false;
+}
+`;
+}
+function routeLifecycleSource({ nextCompat, islands, page, shell, dev }) {
+  const gate = nextCompat ? `  pnextGate(markRouteHydrated, pnextIslandMounts, pnextVisibleMount);
+` : "";
+  const islandMounts = dev ? `pnextIslandScan.done.then(() => {
+      diagnoseSkippedIslands();
+      return pnextIslandScan.mounted;
+    })` : "pnextIslandScan.done.then(() => pnextIslandScan.mounted)";
+  const mountBody = [
+    islands ? `  if (islands.length > 0) {
+    pnextIslandScan = scanIslands();
+    pnextIslandMounts = ${islandMounts};
+  }` : "",
+    shell ? "  if (shell) pnextVisibleMount = hydrateClientShell();" : "",
+    page ? `  if (Page) {
+    if (islands.length > 0) pnextVisibleMount = hydratePageAfterIslands();
+    else hydratePage();
+  }` : ""
+  ].filter(Boolean).join(`
+`);
+  return `
+  function mountRoute() {
+${mountBody}
+    window.__PNEXT_ACTIVE_ENTRY__ = { unmount: unmountRoute };
+${gate}    return pnextIslandMounts;
+  }
+
+  // A postponed boundary can flush AFTER this entry module has evaluated: the shell's async module
+  // scripts race the server's tail, and a server under load loses that race - the initial mountRoute()
+  // then sees a document holding only the placeholder, mounts nothing, and the tree stays inert
+  // FOREVER, because promotion has no way back into the entry. The promotion script calls this hook
+  // once the real DOM is parsed in. Every step is guarded, so re-running them hydrates only what the
+  // first pass could not see.
+  function remountRoute() {
+${mountBody}
+${gate}    return pnextIslandMounts;
+  }
+  window.__PNEXT_MOUNT_ISLANDS__ = remountRoute;
+
+  function unmountRoute(keep) {
+    // Roots in \`keep\` are grafted into the next document by the router (shared
+    // layout preservation) \u2014 leave them and any mounted ancestor intact; an
+    // ancestor unmount would recursively tear down the preserved island.
+    for (const root of pnextMountedRoots) {
+      if (keepsMountedRoot(root, keep)) continue;
+      render(null, root);
+      root.__pnextLive = undefined;
+    }
+    // A preserved client page keeps its registration: its tree is still mounted
+    // and grafted into the new body, so hydratePage must see it as live instead
+    // of re-hydrating over it. Every other root is dropped \u2014 island roots kept
+    // for the bfcache are detached and owned by the cache from here on.
+    const page = window.__PNEXT_CLIENT_PAGE_ROOT__;
+    let keepsPage = false;
+    if (page && keep) for (const kept of keep) if (kept === page) keepsPage = true;
+    pnextMountedRoots.clear();
+    if (keepsPage) pnextMountedRoots.add(page);
+  }
+
+  return { mountRoute, remountRoute, unmountRoute };
+`;
+}
+function routerOnlyEntrySource(facts) {
+  const mark = facts.nextCompat ? `
+function markRouteHydrated() {
+  window.__NEXT_HYDRATED = true;
+  window.__NEXT_HYDRATED_AT ??= performance.now();
+  if (typeof window.__NEXT_HYDRATED_CB === 'function') window.__NEXT_HYDRATED_CB();
+  window.dispatchEvent(new Event('pnext:hydrated'));
+}
+` : "";
+  return `
+${routerImportSource(facts)}
+${mark}
+export function mountRoute() {
+  window.__PNEXT_ACTIVE_ENTRY__ = { unmount: unmountRoute };
+${facts.nextCompat ? `  markRouteHydrated();
+` : ""}}
+
+export function unmountRoute() {}
+
+${installRouterCall(facts.router)}${installCallsSource(facts)}
+if (${autoMountGuard(facts.router)}) mountRoute();
+if (window.__PNEXT_REGISTER_ENTRY__) window.__PNEXT_REGISTER_ENTRY__(import.meta.url, { mountRoute, unmountRoute });
+`;
+}
+function installRouterCall(router) {
+  return router ? `installRouter();
+` : "";
+}
+function autoMountGuard(router) {
+  return router ? "!routerImportActive()" : "!((window.__PNEXT_ROUTER_IMPORTS__ ?? 0) > 0)";
+}
+function installCallsSource({
+  nextCompat,
+  actions,
+  errorFile,
+  globalErrorFile,
+  notFoundFile
+}) {
+  if (!nextCompat)
+    return "";
+  const overlay = actions && errorFile ? `installActionErrorOverlay(__PNextRouteErrorComponent);
+` : "";
+  return `${actions ? `installActionRouter();
+` : ""}installNavCompat();
+${overlay}installClientErrors({ errorComponent: ${errorFile ? "__PNextRouteErrorComponent" : "undefined"}, globalErrorComponent: ${globalErrorFile ? "__PNextGlobalErrorComponent" : "undefined"}, notFoundComponent: ${notFoundFile ? "__PNextRouteNotFoundComponent" : "undefined"}, isActionError: ${actions ? "isActionError" : "undefined"} });`;
+}
+var CLIENT_RUNTIME_MODULE = "pnext-client-runtime";
+function clientRuntimeFacts(routes, nextCompat, suspense) {
+  const references = routes.flatMap(({ route }) => route.clientReferences);
+  return {
+    nextCompat,
+    suspense: nextCompat ? suspense ?? true : undefined,
+    islands: references.length > 0,
+    page: routes.some(({ route }) => route.client),
+    shell: routes.some((entry) => entry.shell),
+    deferredIslands: references.some((reference) => reference.dynamic?.ssr === false),
+    visibleIslands: references.some((reference) => reference.dynamic?.load === "visible")
+  };
+}
+function clientRuntimeSource(facts) {
+  const { nextCompat, deferredIslands, page, shell } = facts;
+  const suspense = nextCompat && facts.suspense !== false;
+  const revival = Boolean(facts.islands || shell);
+  return `
+import { ${revival ? "Component, " : ""}h, hydrate, render } from 'preact';
+${nextCompat ? "import { options as __pnextPreactOptions } from 'preact';" : ""}
+${deferredIslands ? "import { useEffect, useState } from 'preact/hooks';" : ""}
+${suspense ? "import { Suspense } from 'preact/compat';" : ""}
+${revival ? layoutSegmentHelperSource(nextCompat) : ""}
+${nextCompat && (revival || page) ? syncPropsHelperSource() : ""}
+${revival ? propsParserSource(nextCompat) : ""}
+${revival ? islandHelpersSource(facts) : ""}
+${islandCssHelperSource()}
+${revival ? hostMeasureSource() : ""}
+${mountLifecycleSource(nextCompat)}
+
+export function bootstrapRoute(config) {
+  const islands = config.islands ?? [];
+  const Page = config.Page;
+  const shell = config.shell;
+  const pnextMountedRoots = new Set();
+  let pnextIslandMounts;
+  let pnextIslandScan;
+  let pnextVisibleMount;
+${clientBoundaryHelperSource(nextCompat, suspense)}
+${mountSource()}
+${revival ? hydrateIslandsSource(facts) : ""}
+${shell ? hydrateClientShellSource(nextCompat) : ""}
+${page ? hydratePageSource(nextCompat) : ""}
+${routeLifecycleSource(facts)}
+}
+`;
+}
+function clientEntrySource(options) {
+  const {
+    pageFile,
+    clientReferences,
+    nextCompat,
+    errorFile,
+    notFoundFile,
+    clientRootLayout,
+    shellLayoutOrder
+  } = options;
+  const facts = {
+    nextCompat,
+    suspense: options.suspense,
+    actions: options.actions,
+    errorFile,
+    globalErrorFile: options.globalErrorFile,
+    notFoundFile,
+    controlFlow: options.controlFlow,
+    router: options.router || !pageFile && clientReferences.length === 0
+  };
+  if (!pageFile && clientReferences.length === 0) {
+    return routerOnlyEntrySource(facts);
+  }
+  if (!pageFile && clientReferences.length > 0 && clientReferences.every(isVisibleDynamicReference)) {
+    return visibleDynamicIslandEntrySource(clientReferences, facts, options.deferredDynamicHref);
+  }
+  const imports = clientReferences.map((reference, index) => {
+    if (reference.dynamic)
+      return null;
+    if (reference.sideEffect)
+      return `import ${JSON.stringify(reference.file)};`;
+    return reference.exportName === "default" ? `import Island${index} from ${JSON.stringify(reference.file)};` : `import { ${reference.exportName} as Island${index} } from ${JSON.stringify(reference.file)};`;
+  }).filter((item) => Boolean(item)).join(`
+`);
+  const islandManifest = clientReferences.map((reference, index) => reference.sideEffect ? null : reference.dynamic ? `{ id: ${JSON.stringify(reference.id)}, options: ${JSON.stringify(reference.dynamic)}, ${dynamicLoader(reference, options.deferredDynamicHref?.(reference))} }` : `{ id: ${JSON.stringify(reference.id)}, Component: Island${index} }`).filter((item) => item !== null).join(`,
+  `);
+  const islandNames = new Map(clientReferences.map((reference, index) => [reference, `Island${index}`]));
+  const shellReferences = shellClientReferences(clientReferences, errorFile, notFoundFile, shellLayoutOrder);
+  const shellNames = !pageFile && clientRootLayout && shellReferences.some((reference) => !reference.dynamic) ? shellReferences.map((reference) => reference.dynamic ? undefined : islandNames.get(reference)).filter((name) => Boolean(name)) : undefined;
+  const needsCss = clientReferences.some((reference) => referenceCssHref(reference));
+  return `
+import { bootstrapRoute${needsCss ? ", loadIslandCss" : ""} } from ${JSON.stringify(CLIENT_RUNTIME_MODULE)};
+${pageFile ? `import Page from ${JSON.stringify(pageFile)};` : ""}
+${imports}
+${routerImportSource(facts)}
+${boundaryImportSource(nextCompat, hasErrorBoundary(facts), !notFoundFile)}
+
+const { mountRoute, remountRoute, unmountRoute } = bootstrapRoute({
+  islands: [
+  ${islandManifest}
+  ],${pageFile ? `
+  Page,` : ""}${shellNames ? `
+  shell: [${shellNames.join(", ")}],` : ""}${boundaryConfigSource(facts)}
+});
+export { mountRoute, remountRoute, unmountRoute };
+
+${installRouterCall(facts.router)}${installCallsSource(facts)}
+if (${autoMountGuard(facts.router)}) void mountRoute();
+if (window.__PNEXT_REGISTER_ENTRY__) window.__PNEXT_REGISTER_ENTRY__(import.meta.url, { mountRoute, unmountRoute });
+`;
+}
+function boundaryConfigSource(facts) {
+  if (!facts.nextCompat)
+    return "";
+  const base = `
+  errorComponent: ${facts.errorFile ? "__PNextRouteErrorComponent" : "undefined"},
+  notFoundComponent: ${facts.notFoundFile ? "__PNextRouteNotFoundComponent" : "undefined"},`;
+  if (!hasErrorBoundary(facts))
+    return `${base}
+  errorBoundary: BareErrorBoundary,`;
+  return `${base}
+  errorBoundary: ClientErrorBoundary,
+  onBoundaryReset: softRefreshRoute,${facts.notFoundFile ? "" : `
+  builtInNotFound: __PNextBuiltInNotFound,`}`;
+}
+function shellClientReferences(clientReferences, errorFile, notFoundFile, shellLayoutOrder) {
+  const shell = clientReferences.filter((reference) => !reference.sideEffect && reference.file !== errorFile && reference.file !== notFoundFile);
+  if (!shellLayoutOrder?.length)
+    return shell;
+  const rank = new Map(shellLayoutOrder.map((file, index) => [file, index]));
+  return shell.map((reference, index) => ({ reference, index })).sort((a, b) => {
+    const aRank = rank.get(a.reference.file);
+    const bRank = rank.get(b.reference.file);
+    if (aRank !== undefined && bRank !== undefined)
+      return aRank - bRank;
+    if (aRank !== undefined)
+      return -1;
+    if (bRank !== undefined)
+      return 1;
+    return a.index - b.index;
+  }).map((entry) => entry.reference);
+}
+function isVisibleDynamicReference(reference) {
+  return reference.dynamic?.load === "visible";
+}
+function visibleDynamicIslandEntrySource(clientReferences, facts, deferredDynamicHref) {
+  const { nextCompat, errorFile, notFoundFile } = facts;
+  const boundary = hasErrorBoundary(facts);
+  const islandManifest = clientReferences.map((reference) => `{ id: ${JSON.stringify(reference.id)}, ${visibleDynamicLoader(reference, deferredDynamicHref?.(reference))} }`).join(`,
+  `);
+  const compatBoundary = !nextCompat ? "" : boundary ? `function pnextClientBoundary(h, vnode) {
+  return h(ClientErrorBoundary, { errorComponent: ${errorFile ? "__PNextRouteErrorComponent" : "undefined"}, notFoundComponent: ${notFoundFile ? "__PNextRouteNotFoundComponent" : "__PNextBuiltInNotFound"}, onReset: softRefreshRoute }, vnode);
+}
+` : `function pnextClientBoundary(h, vnode) {
+  return h(BareErrorBoundary, null, vnode);
+}
+`;
+  return `
+${nextCompat ? "import { options as __pnextPreactOptions } from 'preact';" : ""}
+${islandCssHelperSource()}
+${routerImportSource(facts)}
+${boundaryImportSource(nextCompat, boundary, boundary && !notFoundFile)}
+${layoutSegmentHelperSource(nextCompat)}
+${hostMeasureSource()}
+${mountLifecycleSource(nextCompat)}
+const islands = [
+  ${islandManifest}
+];
+
+const pnextMountedRoots = new Set();
+let pnextIslandMounts;
+let pnextRender;
+
+${nextCompat ? syncPropsHelperSource() : ""}
+${propsParserSource(nextCompat)}
+${compatBoundary}
+export function mountRoute() {
+  for (const island of islands) {
+    for (const root of document.querySelectorAll(\`[data-pnext-client="\${island.id}"]\`)) {
+      if (isNestedIslandRoot(root)) continue;
+      // A preserved root (router grafted its live DOM across the soft nav)
+      // still shows the previous route's children \u2014 remount it immediately
+      // instead of waiting for an intersection.
+      if (root.__pnextIncoming) {
+        void mountIsland(root, island);
+        continue;
+      }
+      observeVisibleIsland(root, island);
+    }
+  }
+  window.__PNEXT_ACTIVE_ENTRY__ = { unmount: unmountRoute };
+${nextCompat ? `  pnextGate(markRouteHydrated, pnextIslandMounts, undefined);
+` : ""}  return pnextIslandMounts;
+}
+
+export const remountRoute = mountRoute;
+window.__PNEXT_MOUNT_ISLANDS__ = remountRoute;
+
+export function unmountRoute(keep) {
+  // Roots in \`keep\` are grafted into the next document by the router (shared
+  // layout preservation) \u2014 leave them and any mounted ancestor intact; an
+  // ancestor unmount would recursively tear down the preserved island.
+  if (pnextRender) for (const root of pnextMountedRoots) {
+    if (keepsMountedRoot(root, keep)) continue;
+    pnextRender(null, root);
+    root.__pnextLive = undefined;
+  }
+  pnextMountedRoots.clear();
+}
+
+${installRouterCall(facts.router)}${installCallsSource(facts)}
+if (${autoMountGuard(facts.router)}) void mountRoute();
+if (window.__PNEXT_REGISTER_ENTRY__) window.__PNEXT_REGISTER_ENTRY__(import.meta.url, { mountRoute, unmountRoute });
+
+function observeVisibleIsland(root, island) {
+  if (typeof IntersectionObserver === 'undefined') {
+    void mountIsland(root, island);
+    return;
+  }
+
+  const target = visibleTarget(root);
+  const observer = new IntersectionObserver(entries => {
+    if (!entries.some(entry => entry.isIntersecting)) return;
+    observer.disconnect();
+    void mountIsland(root, island);
+  }, island.options);
+
+  observer.observe(target);
+}
+
+function visibleTarget(root) {
+  // IntersectionObserver never fires for a display:contents target: observe the nearest box.
+  let target = root;
+  while (target.parentElement && getComputedStyle(target).display === 'contents') target = target.parentElement;
+  return target;
+}
+
+${mountOnceSource()}
+${nextCompat ? `let islandBoundary;
+
+function mountIsland(root, island) {
+  return mountIslandOnce(root, () => mountIslandTree(root, island));
+}
+
+async function mountIslandTree(root, island) {
+  const [{ h, hydrate, render }${facts.suspense !== false ? ", { Suspense }" : ""}, Component] = await Promise.all([
+    import('preact'),${facts.suspense !== false ? `
+    import('preact/compat'),` : ""}
+    islandComponent(island),
+  ]);
+${facts.suspense !== false ? `  islandBoundary = Suspense;
+` : ""}  const rawProps = root.getAttribute('data-pnext-props') ?? '{}';
+  const source = preservedSource(root, render);
+  if (!source) return adoptPreserved(render, root);
+  const vnode = islandVNode(h, Component, await islandProps(rawProps, source, node => domChildren(h, node), h), await staticChildren(h, source, island.id), root);
+  const wrapped = ${facts.suspense !== false ? "h(Suspense, { fallback: null }, pnextClientBoundary(h, vnode))" : "pnextClientBoundary(h, vnode)"};
+  if (source !== root) adoptPreserved(render, root, wrapped);
+  else mount(hydrate, render, root, wrapped);
+}` : `function mountIsland(root, island) {
+  return mountIslandOnce(root, () => mountIslandTree(root, island));
+}
+
+async function mountIslandTree(root, island) {
+  const [{ h, hydrate, render }, Component] = await Promise.all([import('preact'), islandComponent(island)]);
+  const rawProps = root.getAttribute('data-pnext-props') ?? '{}';
+  const source = preservedSource(root, render);
+  if (!source) return adoptPreserved(render, root);
+  const vnode = islandVNode(h, Component, await islandProps(rawProps, source, node => domChildren(h, node), h), await staticChildren(h, source, island.id), root);
+  if (source !== root) adoptPreserved(render, root, vnode);
+  else mount(hydrate, render, root, vnode);
+}`}
+
+// Dev route entries each bundle their own copy of a shared island component, and Preact
+// diffs by component IDENTITY: mounting the destination entry's copy would remount every
+// preserved island on navigation (a splash gate re-splashes, a reel restarts). The first
+// loaded instance of an island id wins for the document's lifetime; a dev recompile
+// full-reloads the page, which resets the registry. Prod ships one entry, so this is a
+// no-op there.
+// NOTE: pinning a single component instance across dev route entries is NOT safe here:
+// each dev entry carries its own module graph, and a pinned provider's context object
+// would not match the consuming entry's copy (breaks e.g. QueryClientProvider). Module
+// graphs must be deduped at the bundler level instead.
+async function islandComponent(island) {
+  return island.Component ?? await island.load();
+}
+
+// A root preserved across a soft navigation carries the incoming placeholder
+// (fresh SSR children) stashed by the router; render children from it when this
+// preact instance owns the live tree. A foreign entry copy (dev bundles) can't
+// be diffed \u2014 restore the SSR children and mount fresh instead.
+function preservedSource(root, render) {
+  const incoming = root.__pnextIncoming;
+  root.__pnextIncoming = undefined;
+  if (!incoming) return root;
+  // A kept layout's island stashed as its own incoming has no new render: keep its tree.
+  if (root.__pnextLive === render) return incoming === root ? null : incoming;
+  root.replaceChildren(...incoming.childNodes);
+  root.__pnextLive = undefined;
+  root.__pnextMask = [incoming.getAttribute('data-pnext-id'), 0];
+  return root;
+}
+
+// Re-render the preserved root in place so component state survives while the
+// routed content under the island updates.
+function adoptPreserved(render, root, vnode) {
+  if (vnode) render(vnode, root);
+  pnextRender = render;
+  pnextMountedRoots.add(root);
+}
+
+function mount(hydrate, render, root, vnode) {
+  // See mountSource(): an SSR-failed placeholder has no server DOM to adopt.
+  const ssrFailed = root.getAttribute && root.getAttribute('data-pnext-ssr-failed') != null;
+  const apply = root.hasChildNodes() && !ssrFailed ? hydrate : render;
+  apply(vnode, root);
+  // Stamp the root with this entry's render so the router can preserve it
+  // across a soft navigation and the next entry can tell whether its own
+  // preact instance owns the live tree.
+  root.__pnextLive = render;
+  pnextRender = render;
+  pnextMountedRoots.add(root);
+}
+
+// Adopted DOM children win (element children); plain children travel inside
+// the serialized props instead, and an explicit undefined third argument would
+// clobber props.children in preact's createElement \u2014 so only pass it when set.
+function islandVNode(h, Component, props, adopted, root) {
+  const vnode = adopted !== undefined ? h(Component, props, adopted) : h(Component, props);
+  pnextIslandMask(vnode, root);
+  return vnode;
+}
+
+async function staticChildren(h, root, id) {
+  const node = root.querySelector(\`[${ISLAND_STATIC_CHILDREN_ATTRIBUTE}="\${id}"]\`);
+  if (!node) return undefined;
+  // A fallback <template> sidecar (children the component did not render on
+  // the server): materialize any island markers inside its inert content,
+  // adopt, then drop the sidecar so the mount starts from a clean host.
+  const template = node.localName === 'template';
+  const source = template ? node.content : node;
+  if (template && window.__PNEXT_MATERIALIZE_CLIENT_ISLANDS__) {
+    window.__PNEXT_MATERIALIZE_CLIENT_ISLANDS__(source);
+  }
+  const children = await domChildren(h, source);
+  if (template) node.remove();
+  return h('pnext-static-children', {
+    ${JSON.stringify(ISLAND_STATIC_CHILDREN_ATTRIBUTE)}: id,
+    style: { display: 'contents' },
+  }, children);
+}
+
+async function domChildren(h, node) {
+  const children = (await Promise.all(Array.from(node.childNodes, child => domNode(h, child))))
+    .filter(child => child !== null && child !== undefined && child !== false);
+  if (children.length === 0) return undefined;
+  return children.length === 1 ? children[0] : children;
+}
+
+async function domNode(h, node) {
+  if (node.nodeType === 3) return node.textContent;
+  if (node.nodeType !== 1) return null;
+
+  const element = node;
+  if (element.localName === ${JSON.stringify(ISLAND_BOUNDARY_ERROR_ELEMENT)}) return pnextBoundaryErrorVNode(h, element);
+  if (element.localName === 'pnext-client') {
+    const id = element.getAttribute('data-pnext-client');
+    const island = islands.find(candidate => candidate.id === id);
+    if (!island) return h(element.localName, domProps(element), await domChildren(h, element));
+    const Component = await islandComponent(island);
+    const rawProps = element.getAttribute('data-pnext-props') ?? '{}';
+    const props = await islandProps(rawProps, element, node => domChildren(h, node), h);
+    // Adopted DOM is diffed positionally, and SSR-state-only siblings (a splash overlay the
+    // server rendered that the live tree no longer shows) shift positions between renders.
+    // A nested island must match its previous incarnation by IDENTITY, or the shift remounts
+    // it and resets its state - Next never remounts layout components on navigation.
+    if (props.key === undefined) props.key = 'pnext-island:' + id;
+    const vnode = islandVNode(h, Component, props, await staticChildren(h, element, island.id), element);
+    return ${nextCompat ? "islandBoundary ? h(islandBoundary, { fallback: null }, pnextClientBoundary(h, vnode)) : pnextClientBoundary(h, vnode)" : "vnode"};
+  }
+
+  return h(element.localName, domProps(element), await domChildren(h, element));
+}
+
+function pnextBoundaryErrorVNode(h, element) {
+  const message = element.getAttribute(${JSON.stringify(ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE)}) ?? '';
+  const digest = element.getAttribute(${JSON.stringify(ISLAND_BOUNDARY_ERROR_DIGEST_ATTRIBUTE)});
+  return h(function PnextBoundaryError() {
+    const error = new Error(message);
+    if (digest) error.digest = digest;
+    throw error;
+  }, null);
+}
+
+function domProps(element) {
+  const props = {};
+  for (const attribute of element.attributes) props[attribute.name] = attribute.value;
+  return props;
+}
+
+// A nested root belongs to its parent island's DOM adoption pass, never to a
+// mount of its own. This entry carries no streamed-hole seam (see the shared
+// runtime): its whole point is a preact-free first paint, and a host grafted in
+// after a visible island mounted would be dead weight in every bundle.
+function isNestedIslandRoot(root) {
+  return root.parentElement?.closest('pnext-client') != null;
+}
+`;
+}
+function visibleDynamicLoader(reference, href) {
+  return `options: ${JSON.stringify(reference.dynamic ?? {})}, ${dynamicLoader(reference, href)}`;
+}
+function dynamicLoader(reference, href) {
+  const imported = reference.exportName === "default" ? "module.default" : `module.${reference.exportName}`;
+  const importExpression = `import(${JSON.stringify(href ?? reference.file)}).then(module => ${imported})`;
+  const cssHref = referenceCssHref(reference);
+  return cssHref ? `load: () => Promise.all([${importExpression}, loadIslandCss(${JSON.stringify(cssHref)})]).then(([module]) => module)` : `load: () => ${importExpression}`;
+}
+function referenceCssHref(reference) {
+  return reference.cssImports?.length ? `/assets/${reference.id}.css` : undefined;
+}
+function islandCssHelperSource() {
+  return `
+export function loadIslandCss(href) {
+  if (document.querySelector('link[href="' + href + '"]')) return Promise.resolve();
+  return new Promise(resolve => {
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = href;
+    link.onload = () => resolve();
+    link.onerror = () => resolve();
+    document.head.append(link);
+  });
+}
+`;
+}
+function mountSource() {
+  return `
+function mount(root, vnode) {
+  // An island whose SSR stringification threw was served as an empty
+  // pnext-client placeholder (data-pnext-ssr-failed) with no server DOM to adopt;
+  // render it fresh rather than hydrating against nothing.
+  const ssrFailed = root.getAttribute && root.getAttribute('data-pnext-ssr-failed') != null;
+  const apply = root.hasChildNodes() && !ssrFailed ? hydrate : render;
+  apply(vnode, root);
+  // Stamp the root with this entry's render so the router can preserve it
+  // across a soft navigation and the next entry can tell whether its own
+  // preact instance owns the live tree (dev bundles carry separate copies).
+  root.__pnextLive = render;
+  pnextMountedRoots.add(root);
+}
+`;
+}
+function hydratePageSource(nextCompat) {
+  return `
+async function hydratePageAfterIslands() {
+  await pnextIslandMounts;
+  const root = document.getElementById('pnext-page');
+  if (root?.closest('pnext-client')) return;
+  hydratePage();
+}
+
+function pageProps() {
+const rawProps = window.__PNEXT_PROPS__ ?? {};
+// Pre-fulfilled promises (status/value readable synchronously): use() must
+// not suspend during page hydration or preact appends fragment siblings
+// instead of reusing the server DOM.
+// Under compat.next.legacyRequestAPIs the server also gave these promises the resolved object's
+// own keys (withSyncProps), so Next-14 code reads \`params.creator\` without await; rebuild that
+// same surface here or the hydrated page loses every param the SSR render had.
+${nextCompat ? "const legacy = __pnextSyncProps();" : ""}
+const fulfilled = (kind, value) => {
+  const promise = Promise.resolve(value);
+  promise.status = 'fulfilled';
+  promise.value = value;
+  return ${nextCompat ? "legacy ? legacy(promise, kind, value) : promise" : "promise"};
+};
+return {
+  ...rawProps,
+  params: fulfilled('params', rawProps.params ?? {}),
+  searchParams: fulfilled(
+    'searchParams',
+    rawProps.searchParams ?? Object.fromEntries(new URLSearchParams(location.search)),
+  ),
+};
+}
+
+function hydratePage() {
+// SSR-error recovery: when the server errored and served the error-boundary
+// document, hydrating the real Page against that error HTML corrupts the tree.
+// The server stamps data-pnext-ssr-error on <html>; skip page hydration and let
+// the client error runtime (installClientErrors) own the tree instead.
+if (document.documentElement.hasAttribute('data-pnext-ssr-error')) return;
+// A refresh of this same route grafts the live page DOM back in (the router's
+// client-page preservation), so its tree is still mounted \u2014 re-hydrating over
+// it would blow away the state the graft exists to keep.
+const live = window.__PNEXT_CLIENT_PAGE_ROOT__;
+if (live && pnextMountedRoots.has(live)) return;
+const root = pageMountRoot();
+if (!root) return;
+// Published for the router: it needs the mount container (and, for a dissolved
+// page slot, its anchors) to preserve this page across a refresh.
+window.__PNEXT_CLIENT_PAGE_ROOT__ = root;
+mount(root, ${wrapInBoundary("h(Page, pageProps())", nextCompat)});
+}
+
+// Next renders a page's children directly into the layout with no wrapper element, so tests assert
+// structural selectors against the live DOM. The island bootstrap rebuilt div#pnext-page from the SSR
+// comment markers; a client page mounted here owns that wrapper exclusively, so dissolve it back into
+// comment anchors and hydrate against a virtual container whose children are the marker range.
+// Nested/segment contexts keep the real element: island adoption walks it and segment grafting
+// queries #pnext-page.
+function pageMountRoot() {
+  const root = document.getElementById('pnext-page');
+  if (!root || !root.parentNode) return root;
+  if (root.closest('pnext-client') || root.closest('pnext-layout[data-pnext-segment]')) return root;
+  const parent = root.parentNode;
+  let attrs = '';
+  for (const attribute of root.attributes) attrs += ' ' + attribute.name + '="' + attribute.value + '"';
+  // Same encoding the island materializers parse (entity-escaped attribute
+  // text, see renderer encodeIslandMarker) \u2014 a bfcache/entry snapshot of this
+  // dissolved marker must re-materialize into a real #pnext-page wrapper.
+  const encoded = attrs.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  const open = document.createComment('pnext-page:' + encoded);
+  const close = document.createComment('/pnext-page');
+  parent.insertBefore(open, root);
+  while (root.firstChild) parent.insertBefore(root.firstChild, root);
+  parent.replaceChild(close, root);
+  const container = pageMarkerContainer(open, close, parent);
+  // The router preserves this range across a refresh; it needs the anchors.
+  container.__pnextAnchors = [open, close];
+  return container;
+}
+
+// The minimal parent-DOM surface preact's diff touches on a render container
+// (namespaceURI/firstChild/childNodes/insertBefore), scoped to the nodes
+// between the two page anchors; child removal goes through each node's own
+// parentNode. contains/closest serve the entry's own keep/nesting checks.
+function pageMarkerContainer(open, close, parent) {
+  return {
+    nodeType: 1,
+    namespaceURI: parent.namespaceURI,
+    get firstChild() {
+      const node = open.nextSibling;
+      return node === close ? null : node;
+    },
+    get childNodes() {
+      const nodes = [];
+      for (let node = open.nextSibling; node && node !== close; node = node.nextSibling) nodes.push(node);
+      return nodes;
+    },
+    hasChildNodes() { return open.nextSibling !== close; },
+    insertBefore(node, reference) { return parent.insertBefore(node, reference ?? close); },
+    appendChild(node) { return parent.insertBefore(node, close); },
+    removeChild(node) { return parent.removeChild(node); },
+    contains(node) {
+      for (let current = open.nextSibling; current && current !== close; current = current.nextSibling) {
+        if (current === node || (current.contains && current.contains(node))) return true;
+      }
+      return false;
+    },
+    closest(selector) { return parent.closest ? parent.closest(selector) : null; },
+  };
+}
+`;
+}
+function wrapInBoundary(vnodeExpression, nextCompat) {
+  return nextCompat ? `pnextBoundary(${vnodeExpression})` : vnodeExpression;
+}
+function clientBoundaryHelperSource(nextCompat, suspense) {
+  if (!nextCompat)
+    return "";
+  const boundary = `h(config.errorBoundary, {
+      errorComponent: config.errorComponent,
+      notFoundComponent: config.notFoundComponent,
+      builtInNotFound: config.builtInNotFound,
+      onReset: config.onBoundaryReset,
+    }, vnode)`;
+  return `
+  function pnextBoundary(vnode) {
+    return ${suspense ? `h(Suspense, { fallback: null }, ${boundary})` : boundary};
+  }
+`;
+}
+function hydrateIslandsSource({
+  nextCompat,
+  visibleIslands,
+  deferredIslands,
+  dev
+}) {
+  const diagnostic = dev ? `
+function diagnoseSkippedIslands() {
+  for (const root of document.querySelectorAll('pnext-client[data-pnext-client]')) {
+    if (root.__pnextLive) continue;
+    const id = root.getAttribute('data-pnext-client');
+    const island = id ? islandById.get(id) : undefined;
+    const parent = nestedIslandParent(root);
+    // A visible island is deliberately inert until intersection. A nested
+    // island whose parent is still pending is likewise owned by that parent's
+    // adoption pass, one parked in a capture holder is mid-adoption, and one the
+    // claim pass adopted is no longer in the document. Everything else is a host
+    // this route can never hydrate.
+    if (island?.options?.load === 'visible') continue;
+    if (root.closest('pnext-hole-capture, [data-pnext-stream]')) continue;
+    if (parent && !parent.__pnextLive) continue;
+    const reason = island
+      ? 'was materialized after its parent island mounted, outside any streamed hole this route can re-adopt'
+      : 'has no entry in the client island manifest';
+    console.warn('pnext: client island ' + (id ?? '<missing id>') + ' ' + reason);
+  }
+}
+` : "";
+  return `
+const islandById = new Map(islands.map(island => [island.id, island]));
+${lateIslandClaimSource()}${diagnostic}
+
+// The mounted count is known as soon as the scan loop finishes, before any
+// island module resolves \u2014 so the client shell can decide whether it owns the
+// document without waiting behind island dynamic imports.
+function scanIslands() {
+  const pending = [];
+  let mounted = 0;${nextCompat ? `
+for (const island of islands) {
+  if (island.Component) window.__PNEXT_ACTIONS__?.registerClientReference(island.id, island.Component);
+}` : ""}
+for (const island of islands) {
+  for (const root of document.querySelectorAll(\`[data-pnext-client="\${island.id}"]\`)) {
+    // React hydrates a streamed boundary only once revealed; its promotion re-runs this scan.
+    if (root.closest('[data-pnext-stream]')) continue;
+    const parent = nestedIslandParent(root);
+    if (parent) {
+      pending.push(claimNestedIslandRoot(root, parent));
+      continue;
+    }
+    // Already mounted (e.g. a re-scan after a streamed Suspense hole materialized new islands):
+    // mount() stamps __pnextLive, so skipping these leaves the shell's live islands untouched. A root
+    // preserved across a soft navigation is ALSO live, but carries the incoming placeholder (fresh SSR
+    // props/children) the router stashed - it must re-render, not be skipped, or it keeps showing the
+    // previous document's props.
+    if (root.__pnextLive && !root.__pnextIncoming) continue;
+    mounted += 1;${visibleIslands ? `
+    // A preserved root (router grafted its live DOM across the soft nav) must
+    // re-render immediately \u2014 its DOM still shows the previous route's children.
+    if (island.load && island.options?.load === 'visible' && !root.__pnextIncoming) {
+      observeVisibleIsland(root, island);
+      continue;
+    }` : ""}
+    pending.push(mountIsland(root, island));
+  }
+}
+  return { mounted, done: Promise.all(pending) };
+}
+
+function mountIsland(root, island) {
+  return mountIslandOnce(root, () => mountIslandTree(root, island));
+}
+
+// Dev route entries each bundle their own copy of a shared island component; Preact diffs
+// by identity, so mounting another entry's copy would remount every preserved island on
+// navigation. First loaded instance per island id wins; a dev recompile full-reloads.
+// NOTE: pinning a single component instance across dev route entries is NOT safe here:
+// each dev entry carries its own module graph, and a pinned provider's context object
+// would not match the consuming entry's copy (breaks e.g. QueryClientProvider). Module
+// graphs must be deduped at the bundler level instead.
+async function islandComponent(island) {
+  return island.Component ?? await island.load();
+}
+
+async function mountIslandTree(root, island) {
+  const Component = await islandComponent(island);${nextCompat ? `
+  window.__PNEXT_ACTIONS__?.registerClientReference(island.id, Component);` : ""}
+  const rawProps = root.getAttribute('data-pnext-props') ?? '{}';
+  const incoming = root.__pnextIncoming;
+  root.__pnextIncoming = undefined;
+  // A streamed chunk promoted INSIDE this root's adopted children (the hard-loaded document
+  // finishes streaming long after hydration) replaced DOM this preact tree owns without
+  // telling it. Its vdom still names the fallback, so a diff would build the incoming
+  // children BESIDE the promoted ones. Rebuild from the incoming DOM instead.
+  const streamGrafted = root.__pnextStreamGrafted;
+  root.__pnextStreamGrafted = undefined;
+  if (incoming && root.__pnextLive === render && !streamGrafted) {
+    // Preserved across a soft navigation: re-render in place with the incoming
+    // document's props/children so component state survives while the routed
+    // content under the island updates.
+    // A kept layout's island (its own incoming) keeps its tree.
+    if (incoming !== root) {
+      const vnode = ${islandVNodeExpr("Component", "await islandProps(rawProps, incoming, domChildren, h)", "await staticChildren(incoming, island.id)", "root")};
+      render(${wrapInBoundary("vnode", nextCompat)}, root);
+    }
+    pnextMountedRoots.add(root);
+    return;
+  }
+  if (incoming) {
+    // Preserved root owned by a foreign entry copy (dev bundles): this preact
+    // instance can't diff its tree \u2014 restore the SSR children and mount fresh.
+    root.replaceChildren(...incoming.childNodes);
+    root.__pnextLive = undefined;
+    root.__pnextMask = [incoming.getAttribute('data-pnext-id'), 0];
+  }
+  const vnode = ${islandVNodeExpr("Component", "await islandProps(rawProps, root, domChildren, h)", "await staticChildren(root, island.id)", "root")};
+  mount(root, ${wrapInBoundary("vnode", nextCompat)});
+}
+
+${visibleIslands ? `function observeVisibleIsland(root, island) {
+  if (typeof IntersectionObserver === 'undefined') {
+    void mountIsland(root, island);
+    return;
+  }
+
+  const observer = new IntersectionObserver(entries => {
+    if (!entries.some(entry => entry.isIntersecting)) return;
+    observer.disconnect();
+    void mountIsland(root, island);
+  }, island.options);
+
+  observer.observe(visibleTarget(root));
+}
+` : ""}
+async function staticChildren(root, id) {
+  const node = root.querySelector(\`[${ISLAND_STATIC_CHILDREN_ATTRIBUTE}="\${id}"]\`);
+  if (!node) return undefined;
+  // A fallback <template> sidecar (children the component did not render on
+  // the server): materialize any island markers inside its inert content,
+  // adopt, then drop the sidecar so the mount starts from a clean host.
+  const template = node.localName === 'template';
+  const source = template ? node.content : node;
+  if (template && window.__PNEXT_MATERIALIZE_CLIENT_ISLANDS__) {
+    window.__PNEXT_MATERIALIZE_CLIENT_ISLANDS__(source);
+  }
+  const children = await domChildren(source);
+  if (Page) {
+    const pageRoot = source.querySelector?.('#pnext-page');
+    if (pageRoot?.parentNode) pageRoot.replaceWith(...pageRoot.childNodes);
+  }
+  if (template) node.remove();
+  return h('pnext-static-children', {
+    ${JSON.stringify(ISLAND_STATIC_CHILDREN_ATTRIBUTE)}: id,
+    style: { display: 'contents' },
+  }, children);
+}
+
+async function domChildren(node) {
+  const children = (await Promise.all(Array.from(node.childNodes, domNode)))
+    .filter(child => child !== null && child !== undefined && child !== false);
+  if (children.length === 0) return undefined;
+  return children.length === 1 ? children[0] : children;
+}
+
+async function domNode(node) {
+  if (node.nodeType === 3) return node.textContent;
+  if (node.nodeType !== 1) return null;
+
+  const element = node;
+  if (element.localName === ${JSON.stringify(ISLAND_BOUNDARY_ERROR_ELEMENT)}) return pnextBoundaryErrorVNode(element);
+  // The seam a late streamed graft re-adopts through (see holeSeamSource).
+  if (element.localName === 'pnext-hole') {
+    return h(PnextHole, { attrs: domProps(element) }, await domChildren(element));
+  }
+  if (element.localName === 'pnext-client') {
+    const id = element.getAttribute('data-pnext-client');
+    const island = id ? islandById.get(id) : undefined;
+    if (!island) return h(element.localName, domProps(element), await domChildren(element));
+    const rawProps = element.getAttribute('data-pnext-props') ?? '{}';
+    const children = await staticChildren(element, island.id);${deferredIslands ? `
+    if (!island.Component && island.options?.ssr === false) {
+      return h(DeferredIsland, { load: island.load, props: parseIslandProps(rawProps), children });
+    }` : ""}
+    const Component = await islandComponent(island);
+    return ${wrapInBoundary(islandVNodeExpr("Component", "await islandProps(rawProps, element, domChildren, h)", "children", "element"), nextCompat)};
+  }
+
+  if (Page && element.id === 'pnext-page') {
+    return ${wrapInBoundary("h(Page, pageProps())", nextCompat)};
+  }
+
+  return h(element.localName, domProps(element), await domChildren(element));
+}
+`;
+}
+function islandHelpersSource({ deferredIslands, visibleIslands }) {
+  return `
+function pnextBoundaryErrorVNode(element) {
+  const message = element.getAttribute(${JSON.stringify(ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE)}) ?? '';
+  const digest = element.getAttribute(${JSON.stringify(ISLAND_BOUNDARY_ERROR_DIGEST_ATTRIBUTE)});
+  return h(function PnextBoundaryError() {
+    const error = new Error(message);
+    if (digest) error.digest = digest;
+    throw error;
+  }, null);
+}
+
+function domProps(element) {
+  const props = {};
+  for (const attribute of element.attributes) props[attribute.name] = attribute.value;
+  return props;
+}
+
+// The island host that owns this root's DOM, if any. A nested root is never
+// mounted here: the parent adopts it, or claimNestedIslandRoot routes it through
+// the parent's hole seam.
+function nestedIslandParent(root) {
+  return root.parentElement?.closest('pnext-client');
+}
+${holeSeamSource()}${visibleIslands ? `
+function visibleTarget(root) {
+  // IntersectionObserver never fires for a display:contents target: observe the nearest box.
+  let target = root;
+  while (target.parentElement && getComputedStyle(target).display === 'contents') target = target.parentElement;
+  return target;
+}
+` : ""}${mountOnceSource()}${deferredIslands ? `
+function DeferredIsland({ load, props, children }) {
+  const [Component, setComponent] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    void load().then(loaded => {
+      if (!cancelled) setComponent(() => loaded);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [load]);
+  return Component ? h(Component, props, children) : null;
+}
+` : ""}`;
+}
+function hydrateClientShellSource(nextCompat) {
+  const shell = `shell.reduceRight(
+    (children, Component, index) => h(Component, index === 0 ? slotProps : null, children),
+    page,
+  )`;
+  return `
+// A client root layout is re-rendered whole here, but its parallel-route slot
+// props (nav/auth/\u2026) are server-rendered subtrees that never serialized. Adopt
+// each slot's preserved SSR DOM (marked with data-pnext-slot by the renderer)
+// as the named prop on the outermost shell component so the slots survive.
+async function collectRootSlotProps() {
+  const props = {};
+  for (const el of document.querySelectorAll('[data-pnext-slot]')) {
+    if (el.parentElement?.closest('[data-pnext-slot]')) continue;
+    const name = el.getAttribute('data-pnext-slot');
+    if (!name) continue;
+    props[name] = await domNode(el);
+  }
+  return props;
+}
+
+async function hydrateClientShell() {
+  if (pnextIslandScan && pnextIslandScan.mounted > 0) return;
+  // The streamed-chunk remount (remountRoute) re-runs every mount step; the
+  // shell owns document.body, so re-rendering a shell that already hydrated
+  // would blow away the live tree. mount() registers its root, and a soft
+  // navigation clears the set, so this only skips a shell that is still live.
+  if (pnextMountedRoots.has(document.body)) return;
+  const pageRoot = document.getElementById('pnext-page');
+  if (!pageRoot) return;
+  const page = await domNode(pageRoot);
+  const slotProps = await collectRootSlotProps();
+  mount(document.body, ${wrapInBoundary(shell, nextCompat)});
+}
+`;
+}
+
+// src/client/react-tier.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import path3 from "path";
+var LITE_REACT_NAMES = new Set([
+  "Component",
+  "Fragment",
+  "StrictMode",
+  "cache",
+  "cacheSignal",
+  "cloneElement",
+  "createContext",
+  "createElement",
+  "createRef",
+  "isValidElement",
+  "startTransition",
+  "useActionState",
+  "useCallback",
+  "useContext",
+  "useDebugValue",
+  "useDeferredValue",
+  "useEffect",
+  "useId",
+  "useImperativeHandle",
+  "useInsertionEffect",
+  "useLayoutEffect",
+  "useMemo",
+  "useOptimistic",
+  "useReducer",
+  "useRef",
+  "useState",
+  "useTransition",
+  "version",
+  "ViewTransition",
+  "addTransitionType"
+]);
+var SAFE_BARE_SPECIFIERS = new Set([
+  "next/link",
+  "next/navigation",
+  "preact",
+  "preact/hooks",
+  "preact/jsx-runtime",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime"
+]);
+var UNSAFE_TOKENS = /\bonChange\b|\bonDoubleClick\b|\bdefaultProps\b|\bgetSnapshotBeforeUpdate\b|\bcomponentWillReceiveProps\b|\bUNSAFE_\w+|\bref\s*=\s*["']|async\s+function\s+[A-Z]|(?:const|let|var)\s+[A-Z][\w$]*\s*=\s*async\b|export\s+default\s+async\b/;
+function unsafeDefaultValue(source) {
+  return source.includes("defaultValue") && source.includes("<select");
+}
+var STATIC_IMPORT = /(?:^|\n)\s*(?:import|export)\s+([^;'"]*?)\s*from\s*(['"])([^'"]+)\2/g;
+var BARE_IMPORT = /(?:^|\n)\s*import\s*(['"])([^'"]+)\1/g;
+var DYNAMIC_IMPORT = /\bimport\(\s*(['"])([^'"]+)\1/g;
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx|mjs|cjs)$/;
+function clientSuspenseFree(seeds) {
+  const queue = [];
+  const visited = new Set;
+  for (const seed of seeds) {
+    if (!seed || visited.has(seed))
+      continue;
+    visited.add(seed);
+    queue.push(seed);
+  }
+  while (queue.length > 0) {
+    const file = queue.pop();
+    if (!SOURCE_EXTENSION.test(file) || !existsSync2(file))
+      return false;
+    let source;
+    try {
+      source = readSourceSync(file);
+    } catch {
+      return false;
+    }
+    if (UNSAFE_TOKENS.test(source) || unsafeDefaultValue(source))
+      return false;
+    for (const [clause, specifier] of importsOf(source)) {
+      if (specifier === "react") {
+        if (!liteReactClause(clause))
+          return false;
+        continue;
+      }
+      if (SAFE_BARE_SPECIFIERS.has(specifier))
+        continue;
+      if (specifier.startsWith(".")) {
+        if (clause !== undefined && typeOnlyClause(clause))
+          continue;
+        const resolved = resolveRelative(path3.dirname(file), specifier);
+        if (resolved === ASSET)
+          continue;
+        if (!resolved)
+          return false;
+        if (!visited.has(resolved)) {
+          visited.add(resolved);
+          queue.push(resolved);
+        }
+        continue;
+      }
+      if (clause === undefined || !typeOnlyClause(clause))
+        return false;
+    }
+  }
+  return true;
+}
+function* importsOf(source) {
+  for (const match of source.matchAll(STATIC_IMPORT))
+    yield [match[1], match[3] ?? ""];
+  for (const match of source.matchAll(BARE_IMPORT))
+    yield [undefined, match[2] ?? ""];
+  for (const match of source.matchAll(DYNAMIC_IMPORT))
+    yield [undefined, match[2] ?? ""];
+}
+function typeOnlyClause(clause) {
+  return /^type\s/.test(clause.trim());
+}
+function liteReactClause(clause) {
+  if (clause === undefined)
+    return true;
+  const trimmed = clause.trim();
+  if (typeOnlyClause(trimmed))
+    return true;
+  const braceStart = trimmed.indexOf("{");
+  if (braceStart !== 0)
+    return false;
+  const braceEnd = trimmed.indexOf("}");
+  if (braceEnd === -1)
+    return false;
+  for (const entry of trimmed.slice(braceStart + 1, braceEnd).split(",")) {
+    const name = entry.trim();
+    if (!name || name.startsWith("type "))
+      continue;
+    const imported = (name.split(/\s+as\s+/)[0] ?? "").trim();
+    if (!LITE_REACT_NAMES.has(imported))
+      return false;
+  }
+  return true;
+}
+var ASSET = Symbol("pnext.compat-surface.asset");
+function resolveRelative(dir, specifier) {
+  let base = path3.resolve(dir, specifier);
+  const direct = fileAt(base);
+  if (direct)
+    return direct;
+  if (/\.(?:js|jsx|mjs|cjs)$/.test(base))
+    base = base.replace(/\.[^.]+$/, "");
+  for (const extension of SOURCE_EXTENSIONS) {
+    const candidate = fileAt(base + extension);
+    if (candidate)
+      return candidate;
+  }
+  for (const extension of SOURCE_EXTENSIONS) {
+    const candidate = fileAt(path3.join(base, `index${extension}`));
+    if (candidate)
+      return candidate;
+  }
+  return;
+}
+function fileAt(candidate) {
+  if (!existsSync2(candidate))
+    return;
+  try {
+    if (!statSync(candidate).isFile())
+      return;
+  } catch {
+    return;
+  }
+  return SOURCE_EXTENSION.test(candidate) ? candidate : ASSET;
+}
+
+// src/client/prebuilt.ts
+import { createHash as createHash2 } from "crypto";
+import { readFileSync, readdirSync, statSync as statSync2 } from "fs";
+import path4 from "path";
+import { build as build2 } from "esbuild";
+var PREBUILT_MODULE = "pnext-runtime.js";
+var frameworkSrc = path4.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/client", "..");
+var vendorSpecifiers = [
+  "preact",
+  "preact/hooks",
+  "preact/compat",
+  "preact/compat/client",
+  "preact/jsx-runtime",
+  "preact/jsx-dev-runtime"
+];
+var reactAliasSpecifier = /^react(?:-dom)?(?:\/|$)/;
+var isCompilerRuntime = (specifier) => specifier.endsWith("compiler-runtime");
+var identifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function mangledName(specifier, name) {
+  return `__p_${shortHash(specifier)}_${name}`;
+}
+function shortHash(value) {
+  return createHash2("sha1").update(value).digest("hex").slice(0, 8);
+}
+function seedSpecifiers(aliases) {
+  const react = aliases.filter((alias) => reactAliasSpecifier.test(alias) && !isCompilerRuntime(alias));
+  return [...new Set([...vendorSpecifiers, ...react])];
+}
+function prebuiltSpecifierFilter(config) {
+  const aliases = Object.keys(getImportAliasExtensions().aliases(config, "client"));
+  const bare = [...new Set([...aliases, ...vendorSpecifiers])];
+  return new RegExp(`^(?:${bare.map(escapeRegex).join("|")}|${escapeRegex(frameworkSrc)}/)`);
+}
+function isFrameworkSpecifier(specifier, filter) {
+  if (specifier === CLIENT_RUNTIME_MODULE)
+    return false;
+  if (isCompilerRuntime(specifier))
+    return false;
+  if (specifier.startsWith(frameworkSrc))
+    return true;
+  return filter.test(specifier) && !specifier.startsWith(".");
+}
+function prebuiltRuntimeKey(config, buildOptions, signature = "") {
+  const hash = createHash2("sha1");
+  hash.update(frameworkSourceHash());
+  hash.update("\x00");
+  hash.update(JSON.stringify(Object.keys(getImportAliasExtensions().aliases(config, "client"))));
+  hash.update("\x00");
+  hash.update(JSON.stringify([
+    buildOptions.define,
+    buildOptions.minify,
+    buildOptions.target,
+    buildOptions.pure
+  ]));
+  hash.update("\x00");
+  hash.update(signature);
+  return hash.digest("hex").slice(0, 16);
+}
+var cachedSourceHash;
+function frameworkSourceHash() {
+  if (cachedSourceHash)
+    return cachedSourceHash;
+  const hash = createHash2("sha1");
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const file = path4.join(dir, entry.name);
+      if (entry.isDirectory())
+        walk(file);
+      else if (/\.(?:tsx?|jsx?|mjs|cjs)$/.test(entry.name)) {
+        const stats = statSync2(file, { throwIfNoEntry: false });
+        if (stats)
+          hash.update(`${file}:${stats.size}:${stats.mtimeMs}
+`);
+      }
+    }
+  };
+  walk(frameworkSrc);
+  cachedSourceHash = hash.digest("hex").slice(0, 16);
+  return cachedSourceHash;
+}
+async function probeExports(specifiers, options) {
+  const found = new Map;
+  if (specifiers.length === 0)
+    return found;
+  const probeDir = path4.join(options.dir, ".probe");
+  await ensureDir(probeDir);
+  const entryPoints = [];
+  for (const specifier of specifiers) {
+    const file = path4.join(probeDir, `${shortHash(specifier)}.ts`);
+    await writeText(file, `export * from ${JSON.stringify(specifier)};
+`);
+    entryPoints.push({ in: file, out: shortHash(specifier) });
+  }
+  const result = await build2({
+    ...options.buildOptions,
+    entryPoints,
+    outdir: probeDir,
+    entryNames: "[name]",
+    splitting: true,
+    write: false,
+    metafile: true,
+    plugins: options.plugins()
+  });
+  for (const specifier of specifiers) {
+    const output = Object.entries(result.metafile.outputs).find(([name]) => path4.basename(name) === `${shortHash(specifier)}.js`);
+    found.set(specifier, (output?.[1].exports ?? []).filter((name) => identifier.test(name)));
+  }
+  return found;
+}
+async function probeSurface(specifiers, options) {
+  const probed = await probeExports(specifiers, options);
+  if (probed.size === 0)
+    return probed;
+  const candidate = new Map([...probed].map(([specifier, names]) => [specifier, new Set([...names, "default"])]));
+  const { text } = await buildAggregate(options, candidate, false);
+  return new Map([...candidate].map(([specifier, names]) => [
+    specifier,
+    [...names].filter((name) => text.includes(mangledName(specifier, name)))
+  ]));
+}
+async function buildAggregate(options, surface, write) {
+  const lines = [];
+  for (const specifier of [...surface.keys()].sort()) {
+    const names = [...surface.get(specifier)].filter((name) => identifier.test(name)).sort();
+    const spec = JSON.stringify(specifier);
+    if (names.length === 0)
+      lines.push(`import ${spec};`);
+    else {
+      const clause = names.map((name) => `${name} as ${mangledName(specifier, name)}`).join(", ");
+      lines.push(`export { ${clause} } from ${spec};`);
+    }
+  }
+  const aggregateDir = path4.join(options.dir, ".aggregate");
+  await ensureDir(aggregateDir);
+  const entry = path4.join(aggregateDir, "runtime.ts");
+  await writeText(entry, `${lines.join(`
+`)}
+`);
+  const result = await build2({
+    ...options.buildOptions,
+    entryPoints: [{ in: entry, out: PREBUILT_MODULE.replace(/\.js$/, "") }],
+    outdir: options.dir,
+    entryNames: "[name]",
+    splitting: true,
+    write,
+    metafile: true,
+    plugins: options.plugins()
+  });
+  const emitted = result.outputFiles?.find((file) => path4.basename(file.path) === PREBUILT_MODULE);
+  const text = emitted?.text ?? readFileSafe(path4.join(options.dir, PREBUILT_MODULE));
+  return { text, metafile: result.metafile };
+}
+function readFileSafe(file) {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function buildPrebuiltRuntime(options, exportsBySpecifier, surface) {
+  const { metafile } = await buildAggregate(options, surface, true);
+  return {
+    key: options.key,
+    dir: options.dir,
+    publicPath: options.publicPath,
+    assetPath: options.assetPath,
+    exports: exportsBySpecifier,
+    surface,
+    closure: aggregateClosure(metafile)
+  };
+}
+function aggregateClosure(metafile) {
+  const entry = Object.keys(metafile.outputs).find((name) => path4.basename(name) === PREBUILT_MODULE);
+  const statics = new Set;
+  const dynamics = new Set;
+  if (!entry)
+    return { static: [], dynamic: [] };
+  const seen = new Set([`${entry}:static`]);
+  const queue = [{ output: entry, dynamic: false }];
+  for (let head = 0;head < queue.length; head += 1) {
+    const current = queue[head];
+    for (const imported of metafile.outputs[current.output]?.imports ?? []) {
+      if (imported.kind !== "import-statement" && imported.kind !== "dynamic-import")
+        continue;
+      const dynamic = current.dynamic || imported.kind === "dynamic-import";
+      const visitKey = `${imported.path}:${dynamic ? "dynamic" : "static"}`;
+      if (seen.has(visitKey))
+        continue;
+      seen.add(visitKey);
+      queue.push({ output: imported.path, dynamic });
+      const relative = path4.relative(path4.dirname(entry), imported.path).split(path4.sep).join("/");
+      (dynamic ? dynamics : statics).add(relative);
+    }
+  }
+  for (const name of statics)
+    dynamics.delete(name);
+  return { static: [...statics], dynamic: [...dynamics] };
+}
+function prebuiltExternalPlugin(runtime, filter, unprobed, sourceOf) {
+  const namespace = "pnext-prebuilt";
+  const moduleUrl = prebuiltModuleUrl(runtime);
+  return {
+    name: "pnext-prebuilt-runtime",
+    setup(build3) {
+      build3.onResolve({ filter: new RegExp(`^${escapeRegex(moduleUrl)}$`) }, () => ({
+        path: moduleUrl,
+        external: true
+      }));
+      build3.onResolve({ filter }, (args) => {
+        if (args.namespace === namespace)
+          return;
+        if (!isFrameworkSpecifier(args.path, filter))
+          return;
+        if (!runtime.exports.has(args.path)) {
+          unprobed.add(args.path);
+          return;
+        }
+        if (args.kind === "dynamic-import" && !runtime.surface.has(args.path))
+          return;
+        return { path: `${args.path}\x00${args.importer}`, namespace };
+      });
+      build3.onLoad({ filter: /.*/, namespace }, (args) => {
+        const separator = args.path.lastIndexOf("\x00");
+        const specifier = args.path.slice(0, separator);
+        const importer = args.path.slice(separator + 1);
+        const available = runtime.exports.get(specifier) ?? [];
+        const demanded = demandedNames(importer, specifier, sourceOf(importer), available);
+        const clause = demanded.map((name) => `${mangledName(specifier, name)} as ${name}`).join(", ");
+        const contents = clause.length > 0 ? `export { ${clause} } from ${JSON.stringify(moduleUrl)};
+` : `import ${JSON.stringify(moduleUrl)};
+`;
+        return { contents, loader: "js", resolveDir: path4.dirname(specifier) };
+      });
+    }
+  };
+}
+function demandedNames(importer, specifier, source, available) {
+  if (source === undefined)
+    return available;
+  const sourceFile = /\.[cm]?[jt]sx?$/i.test(importer) ? importer : `${importer}.tsx`;
+  let edges;
+  try {
+    edges = scanFacts(sourceFile, source).imports;
+  } catch {
+    return available;
+  }
+  const names = new Set;
+  let named = false;
+  for (const edge of edges) {
+    if (edge.specifier !== specifier)
+      continue;
+    named = true;
+    if (edge.star || edge.exports.includes("*"))
+      return available;
+    for (const name of edge.exports)
+      names.add(name);
+  }
+  if (!named)
+    return available;
+  const offered = available.filter((name) => names.has(name));
+  for (const name of names)
+    if (!available.includes(name))
+      offered.push(name);
+  return offered;
+}
+function prebuiltModuleUrl(runtime) {
+  return `${runtime.publicPath}/${PREBUILT_MODULE}`;
+}
+function demandedFromOutputs(runtime, outDir) {
+  const moduleUrl = prebuiltModuleUrl(runtime);
+  const byMangled = new Map;
+  for (const [specifier, names] of runtime.exports) {
+    for (const name of names)
+      byMangled.set(mangledName(specifier, name), { specifier, name });
+  }
+  const demanded = new Map;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const file = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (file !== runtime.dir)
+          walk(file);
+        continue;
+      }
+      if (!entry.name.endsWith(".js"))
+        continue;
+      let source;
+      try {
+        source = readFileSync(file, "utf8");
+      } catch {
+        continue;
+      }
+      if (!source.includes(moduleUrl))
+        continue;
+      for (const edge of scanFacts(file, source).imports) {
+        if (edge.specifier !== moduleUrl)
+          continue;
+        for (const bound of edge.exports) {
+          const origin = byMangled.get(bound);
+          if (!origin)
+            continue;
+          const names = demanded.get(origin.specifier) ?? new Set;
+          demanded.set(origin.specifier, names);
+          names.add(origin.name);
+        }
+      }
+    }
+  };
+  walk(outDir);
+  return demanded;
+}
+function surfaceCovered(runtime, demanded) {
+  for (const [specifier, names] of demanded) {
+    const have = runtime.surface.get(specifier);
+    if (!have)
+      return false;
+    for (const name of names)
+      if (!have.has(name))
+        return false;
+  }
+  return true;
+}
+var manifestName = "pnext-runtime.json";
+var artifactLocks = new Map;
+function underLock(dir, run) {
+  const previous = artifactLocks.get(dir) ?? Promise.resolve();
+  const next = previous.then(run, run);
+  artifactLocks.set(dir, next.catch(() => {
+    return;
+  }));
+  return next;
+}
+function ensurePrebuiltRuntime(options) {
+  return underLock(options.dir, () => openPrebuiltRuntime(options));
+}
+async function openPrebuiltRuntime(options) {
+  const manifest = readManifest(options.dir);
+  if (manifest) {
+    return {
+      key: options.key,
+      dir: options.dir,
+      publicPath: options.publicPath,
+      assetPath: options.assetPath,
+      ...manifest
+    };
+  }
+  const exportsBySpecifier = await probeSurface(seedSpecifiers(options.aliases), options);
+  const runtime = await buildPrebuiltRuntime(options, exportsBySpecifier, new Map);
+  await writeManifest(runtime);
+  return runtime;
+}
+function settlePrebuiltRuntime(runtime, options, outDir, unprobed) {
+  return underLock(options.dir, () => growPrebuiltRuntime(runtime, options, outDir, unprobed));
+}
+async function growPrebuiltRuntime(runtime, options, outDir, unprobed) {
+  const current = readManifest(options.dir);
+  if (current)
+    runtime = { ...runtime, ...current };
+  const demanded = demandedFromOutputs(runtime, outDir);
+  if (unprobed.size === 0 && surfaceCovered(runtime, demanded))
+    return runtime;
+  const exportsBySpecifier = new Map(runtime.exports);
+  for (const [specifier, names] of await probeSurface([...unprobed], options)) {
+    exportsBySpecifier.set(specifier, names);
+  }
+  const surface = new Map(runtime.surface);
+  for (const [specifier, names] of demanded) {
+    const target = surface.get(specifier) ?? new Set;
+    surface.set(specifier, target);
+    for (const name of names)
+      target.add(name);
+  }
+  const grown = await buildPrebuiltRuntime(options, exportsBySpecifier, surface);
+  await writeManifest(grown);
+  return grown;
+}
+function readManifest(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync(path4.join(dir, manifestName), "utf8"));
+    if (!parsed.exports)
+      return;
+    return {
+      exports: new Map(Object.entries(parsed.exports)),
+      surface: new Map(Object.entries(parsed.surface).map(([spec, n]) => [spec, new Set(n)])),
+      closure: parsed.closure
+    };
+  } catch {
+    return;
+  }
+}
+async function writeManifest(runtime) {
+  const manifest = {
+    key: runtime.key,
+    exports: Object.fromEntries(runtime.exports),
+    surface: Object.fromEntries([...runtime.surface].map(([s, n]) => [s, [...n].sort()])),
+    closure: runtime.closure
+  };
+  await writeText(path4.join(runtime.dir, manifestName), JSON.stringify(manifest));
+}
+function prebuiltAssets(runtime) {
+  const join = (name) => `${runtime.assetPath}/${name}`;
+  return {
+    static: [join(PREBUILT_MODULE), ...runtime.closure.static.map(join)],
+    dynamic: runtime.closure.dynamic.map(join)
+  };
+}
+
+// src/client/react-compiler.ts
+import {
+  transform,
+  transformSync
+} from "oxc-transform";
+function compilerOptions(options) {
+  return {
+    jsx: "preserve",
+    sourcemap: false,
+    reactCompiler: {
+      panicThreshold: "critical_errors",
+      target: options.target
+    }
+  };
+}
+async function transformReactCompiler(source, file, options) {
+  return reactCompilerResult(await transform(file, source, compilerOptions(options)), source, file);
+}
+function reactCompilerResult(result, source, file) {
+  if (!result.code) {
+    const failures = result.errors.filter((error) => !error.message.startsWith("[ReactCompiler]"));
+    if (failures.length > 0) {
+      console.error(`React Compiler (oxc) failed for ${file}:
+${failures.map((error) => error.message).join(`
+`)}`);
+    }
+    return source;
+  }
+  return result.code;
+}
+function shouldReactCompile(source, file) {
+  if (/\.[cm]?[jt]sx$/.test(file))
+    return true;
+  return /\b(?:use[A-Z][\w$]*|createElement|memo|forwardRef)\b/.test(source);
+}
+
+// src/client/build.ts
+async function emitStaticClientChunks(config, outDir) {
+  const chunks = getBundlerExtensions().staticClientChunks(config);
+  if (chunks.length === 0)
+    return;
+  const chunksDir = path5.join(outDir, "chunks");
+  await ensureDir(chunksDir);
+  for (const chunk of chunks) {
+    await writeText(path5.join(chunksDir, chunk.name), chunk.contents);
+  }
+}
+var virtualEntryNamespace = "pnext-client-entry";
+function nextCompatEnabled(config) {
+  return getCompatModeExtensions().nextEnabled(config);
+}
+var conventionCache = new Map;
+function memoConvention(key, compute) {
+  if (conventionCache.has(key))
+    return conventionCache.get(key);
+  const value = compute();
+  conventionCache.set(key, value);
+  return value;
+}
+function appUsesActions(routes, hasServerActions) {
+  if (hasServerActions !== false)
+    return true;
+  return routes.some((route) => route.clientEntryReasons?.some((reason) => reason === "actions" || reason === "form"));
+}
+function routeUsesActions(route, appActions) {
+  if (!appActions)
+    return false;
+  return route.clientEntryReasons?.some((reason) => reason === "actions" || reason === "form") === true;
+}
+function routeThrowsClientControlFlow(route) {
+  return route.clientEntryReasons?.includes("control-flow") === true;
+}
+function routeErrorFile(config, route) {
+  return routeConventionFile(config, route, "error");
+}
+function routeNotFoundFile(config, route) {
+  return routeConventionFile(config, route, "not-found");
+}
+function routeConventionFile(config, route, name) {
+  if (!nextCompatEnabled(config))
+    return;
+  const appPath = path5.resolve(config.appPath);
+  const start = path5.dirname(path5.resolve(route.file));
+  const relative = path5.relative(appPath, start);
+  if (relative.startsWith("..") || path5.isAbsolute(relative))
+    return;
+  return memoConvention(`${name}\x00${start}`, () => {
+    let dir = start;
+    for (;; ) {
+      for (const ext of ["tsx", "ts", "jsx", "js"]) {
+        const candidate = path5.join(dir, `${name}.${ext}`);
+        if (existsSync3(candidate))
+          return candidate;
+      }
+      if (dir === appPath)
+        return;
+      const parent = path5.dirname(dir);
+      if (parent === dir)
+        return;
+      dir = parent;
+    }
+  });
+}
+function globalErrorFile(config) {
+  if (!nextCompatEnabled(config))
+    return;
+  const appPath = path5.resolve(config.appPath);
+  return memoConvention(`global-error\x00${appPath}`, () => {
+    for (const ext of ["tsx", "ts", "jsx", "js"]) {
+      const candidate = path5.join(appPath, `global-error.${ext}`);
+      if (existsSync3(candidate))
+        return candidate;
+    }
+    return;
+  });
+}
+function hasClientRootLayout(config, route) {
+  if (route.client)
+    return false;
+  const rootLayout = shellLayoutOrder(config, route)[0];
+  if (!rootLayout)
+    return false;
+  return route.clientReferences.some((reference) => reference.file === rootLayout);
+}
+function shellLayoutOrder(config, route) {
+  return memoConvention(`layouts\x00${config.appPath}\x00${route.file}`, () => findLayouts(config.appPath, route.file));
+}
+function prebuiltLocation(config, outDir, key, dev) {
+  if (dev) {
+    return {
+      dir: prebuiltRuntimeDir(config, key),
+      publicPath: `/__pnext/runtime/${key}`,
+      assetPath: `__pnext/runtime/${key}`
+    };
+  }
+  const served = nextCompatEnabled(config) ? `/_next/static/rt/${key}` : `/assets/rt/${key}`;
+  return {
+    dir: path5.join(outDir, "rt", key),
+    publicPath: withAssetPrefix(config, served),
+    assetPath: `assets/rt/${key}`
+  };
+}
+function prebuiltRuntimeDir(config, key) {
+  return path5.join(config.root, "node_modules", ".cache", "pnext", "client-runtime", key);
+}
+function prebuiltEnabled() {
+  return process.env.PNEXT_PREBUILT_RUNTIME === "1";
+}
+function surfaceSignature(config, route, actions) {
+  const nextCompat = nextCompatEnabled(config);
+  const facts = clientRuntimeFacts([
+    {
+      route,
+      shell: hasClientRootLayout(config, route)
+    }
+  ], nextCompat, !routeSuspenseFree(config, route));
+  return JSON.stringify([
+    nextCompat,
+    actions,
+    Boolean(routeErrorFile(config, route)),
+    Boolean(globalErrorFile(config)),
+    Boolean(routeNotFoundFile(config, route)),
+    routeThrowsClientControlFlow(route) === true,
+    Boolean(route.needsRouterEntry),
+    facts
+  ]);
+}
+async function preparePrebuilt(config, outDir, dev, sourceOf, signature = "", reactLite = false) {
+  if (!prebuiltEnabled())
+    return;
+  const buildOptions = baseClientBuildOptions(config, dev);
+  const key = prebuiltRuntimeKey(config, buildOptions, signature);
+  const { dir, publicPath, assetPath } = prebuiltLocation(config, outDir, key, dev);
+  const options = {
+    aliases: Object.keys(getImportAliasExtensions().aliases(config, "client")),
+    key,
+    dir,
+    publicPath,
+    assetPath,
+    buildOptions,
+    plugins: () => clientBuildPlugins(config, createClientSourcePipeline(config), [], reactLite)
+  };
+  const runtime = await ensurePrebuiltRuntime(options);
+  const unprobed = new Set;
+  return {
+    runtime,
+    plugin: prebuiltExternalPlugin(runtime, prebuiltSpecifierFilter(config), unprobed, sourceOf),
+    async settle() {
+      await settlePrebuiltRuntime(runtime, options, outDir, unprobed);
+    }
+  };
+}
+function deferredDynamicChunkHref(reference, routeId) {
+  const query = routeId ? `?r=${encodeURIComponent(routeId)}` : "";
+  return `/__pnext/client-dyn/${reference.id}.js${query}`;
+}
+var devClientPublicPath = "/__pnext/client";
+function deferredDynamicEntries(route) {
+  const entries = new Map;
+  for (const reference of route.clientReferences) {
+    if (reference.dynamic && !ssrClientReference(reference)) {
+      entries.set(reference.id, reference.file);
+    }
+  }
+  for (const [id, ref] of deferredDynamicRouteRefs.get(route.id) ?? [])
+    entries.set(id, ref.file);
+  return [...entries].map(([id, file]) => ({ id, file }));
+}
+var deferredDynamicRefs = new Map;
+var deferredDynamicRouteRefs = new Map;
+function registerDeferredDynamicRef(id, ref) {
+  deferredDynamicRefs.set(id, ref);
+  if (!ref.routeId)
+    return;
+  const refs = deferredDynamicRouteRefs.get(ref.routeId) ?? new Map;
+  deferredDynamicRouteRefs.set(ref.routeId, refs);
+  refs.set(id, ref);
+}
+function deferredDynamicRefById(id) {
+  return deferredDynamicRefs.get(id);
+}
+var DEFERRED_DYNAMIC_SIDECAR = "dyn-refs.json";
+function devDeferredDynamicHref(dev, routeId) {
+  if (!dev || !devDynamicSplitEnabled())
+    return;
+  return (reference) => reference.dynamic && !ssrClientReference(reference) ? deferredDynamicChunkHref(reference, routeId) : undefined;
+}
+function deferredDynamicExternalPlugin() {
+  return {
+    name: "pnext-dyn-split-external",
+    setup(build4) {
+      build4.onResolve({ filter: /^\/__pnext\/client-dyn\// }, (args) => ({
+        path: args.path,
+        external: true
+      }));
+    }
+  };
+}
+async function buildClientEntry({ config, route, outDir, dev }) {
+  conventionCache.clear();
+  await ensureDir(outDir);
+  const suspense = routeSuspenseFree(config, route) === false;
+  const source = clientEntrySource({
+    deferredDynamicHref: devDeferredDynamicHref(dev, route.id),
+    pageFile: route.client ? route.file : undefined,
+    clientReferences: route.clientReferences,
+    nextCompat: nextCompatEnabled(config),
+    suspense,
+    actions: true,
+    errorFile: routeErrorFile(config, route),
+    globalErrorFile: globalErrorFile(config),
+    notFoundFile: routeNotFoundFile(config, route),
+    controlFlow: routeThrowsClientControlFlow(route),
+    router: Boolean(route.needsRouterEntry),
+    clientRootLayout: hasClientRootLayout(config, route),
+    shellLayoutOrder: shellLayoutOrder(config, route)
+  });
+  const entryName = clientEntryName(route);
+  const outfile = path5.join(outDir, `${entryName}.js`);
+  const pipeline = createClientSourcePipeline(config, dev === true, route.id);
+  pipeline.warmRoutes([route]);
+  const runtimeFacts = {
+    ...clientRuntimeFacts([
+      {
+        route,
+        shell: hasClientRootLayout(config, route)
+      }
+    ], nextCompatEnabled(config), suspense),
+    dev: dev === true
+  };
+  const prebuilt = await clientProfile.timeAsync("prebuilt", () => preparePrebuilt(config, outDir, dev === true, (importer) => importer === CLIENT_RUNTIME_MODULE ? clientRuntimeSource(runtimeFacts) : pipeline.sourceOf(importer) ?? readTextSyncSafe(importer), surfaceSignature(config, route, true), !suspense));
+  const split = Boolean(devDeferredDynamicHref(dev));
+  const runEntryBuild = (dynEntries2) => build3({
+    ...baseClientBuildOptions(config, dev),
+    entryPoints: [
+      { in: virtualEntryPath(route.id), out: entryName },
+      ...dynEntries2.map((entry) => ({ in: entry.file, out: entry.id }))
+    ],
+    ...split ? { publicPath: devClientPublicPath } : {},
+    outdir: outDir,
+    metafile: true,
+    plugins: clientBuildPlugins(config, pipeline, [
+      ...prebuilt ? [prebuilt.plugin] : [],
+      virtualEntryPlugin([{ route, source }]),
+      ...split ? [deferredDynamicExternalPlugin()] : [],
+      clientRuntimePlugin(runtimeFacts)
+    ], !suspense)
+  });
+  let metafile;
+  let dynEntries = split ? deferredDynamicEntries(route) : [];
+  try {
+    const result = await profileClientBuild(route, dev, () => clientProfile.timeAsync("esbuild", () => runEntryBuild(dynEntries)));
+    metafile = result.metafile;
+  } catch (error) {
+    throw withClientImportTrace(error, config, route, source);
+  }
+  if (split) {
+    const discovered = deferredDynamicEntries(route);
+    if (discovered.length !== dynEntries.length) {
+      dynEntries = discovered;
+      metafile = (await clientProfile.timeAsync("esbuildDynEntries", () => runEntryBuild(dynEntries))).metafile;
+    }
+  }
+  await clientProfile.timeAsync("prebuiltSettle", () => prebuilt?.settle() ?? Promise.resolve());
+  if (metafile) {
+    metafile = await clientProfile.timeAsync("fold", () => foldInitialChunks({
+      outDir,
+      metafile,
+      buildOptions: baseClientBuildOptions(config, dev)
+    }));
+  }
+  await clientProfile.timeAsync("write", () => nameSharedClientChunks(outDir, metafile));
+  if (dev && devDynamicSplitEnabled() && pipeline.deferredRefs().size > 0) {
+    await writeText(path5.join(outDir, DEFERRED_DYNAMIC_SIDECAR), JSON.stringify(Object.fromEntries(pipeline.deferredRefs())));
+  }
+  clientProfile.report(`client entry ${route.id}`);
+  return outfile;
+}
+async function buildClientEntries({
+  config,
+  routes,
+  outDir,
+  verbose,
+  hasServerActions,
+  pipeline: warmed,
+  dev
+}) {
+  if (!warmed)
+    conventionCache.clear();
+  const actions = appUsesActions(routes, hasServerActions);
+  const entries = clientProfile.time("entrySources", () => routes.filter((route) => route.client || route.clientReferences.length > 0 || route.needsRouterEntry).map((route) => ({
+    route,
+    entryName: clientEntryName(route),
+    source: clientEntrySource({
+      deferredDynamicHref: devDeferredDynamicHref(dev, route.id),
+      pageFile: route.client ? route.file : undefined,
+      clientReferences: route.clientReferences,
+      nextCompat: nextCompatEnabled(config),
+      suspense: !routeSuspenseFree(config, route),
+      actions: routeUsesActions(route, actions),
+      errorFile: routeErrorFile(config, route),
+      globalErrorFile: globalErrorFile(config),
+      notFoundFile: routeNotFoundFile(config, route),
+      controlFlow: routeThrowsClientControlFlow(route),
+      router: Boolean(route.needsRouterEntry),
+      clientRootLayout: hasClientRootLayout(config, route),
+      shellLayoutOrder: shellLayoutOrder(config, route)
+    })
+  })));
+  if (entries.length === 0)
+    return;
+  const pipeline = warmed ?? createClientSourcePipeline(config, dev === true);
+  pipeline.warmRoutes(entries.map((entry) => entry.route));
+  await ensureDir(outDir);
+  const groups = surfaceGroups(config, entries, actions);
+  clientProfile.count("group#", groups.length);
+  const built = [];
+  for (const group of groups) {
+    built.push(await buildEntryGroup({ config, outDir, entries, group, pipeline, verbose, dev }));
+  }
+  let merged = { inputs: {}, outputs: {} };
+  for (const item of built) {
+    if (!item.metafile)
+      continue;
+    Object.assign(merged.inputs, item.metafile.inputs);
+    Object.assign(merged.outputs, item.metafile.outputs);
+  }
+  merged = await clientProfile.timeAsync("fold", () => foldInitialChunks({
+    outDir,
+    metafile: merged,
+    buildOptions: baseClientBuildOptions(config, dev)
+  }));
+  const renames = await clientProfile.timeAsync("write", () => nameSharedClientChunks(outDir, merged));
+  if (!dev) {
+    clientProfile.time("entryImports", () => {
+      for (const item of built) {
+        if (item.metafile) {
+          assignClientEntryImports(item.group.entries, merged, outDir, renames, item.prebuilt);
+        }
+      }
+    });
+  }
+  if (!dev) {
+    await clientProfile.timeAsync("fingerprint", () => fingerprintClientEntries(outDir, entries));
+  }
+  if (dev && devDynamicSplitEnabled() && pipeline.deferredRefs().size > 0) {
+    await writeText(path5.join(outDir, DEFERRED_DYNAMIC_SIDECAR), JSON.stringify(Object.fromEntries(pipeline.deferredRefs())));
+  }
+  clientProfile.report("client stage");
+}
+async function fingerprintClientEntries(outDir, entries) {
+  await Promise.all(entries.map(async (entry) => {
+    const from = path5.join(outDir, `${entry.entryName}.js`);
+    const bytes = await readFile(from).catch(() => {
+      return;
+    });
+    if (!bytes)
+      return;
+    const name = `pnext-client-${assetContentHash(bytes)}.js`;
+    entry.route.clientEntry = `assets/${name}`;
+    const to = path5.join(outDir, name);
+    if (to === from)
+      return;
+    const sourceMap = `${from}.map`;
+    if (existsSync3(sourceMap)) {
+      const source = bytes.toString("utf8").replaceAll(`${entry.entryName}.js.map`, `${name}.map`);
+      await writeFile(to, source);
+      await rm(from, { force: true });
+      await rename(sourceMap, `${to}.map`);
+      return;
+    }
+    await rename(from, to);
+  }));
+}
+function surfaceGroups(config, entries, actions) {
+  const facts = (members) => clientRuntimeFacts(members.map((entry) => ({
+    route: entry.route,
+    shell: hasClientRootLayout(config, entry.route)
+  })), nextCompatEnabled(config), !members.every((entry) => routeSuspenseFree(config, entry.route)));
+  if (!prebuiltEnabled() || process.env.PNEXT_PREBUILT_GROUPS === "0")
+    return [{ signature: "", facts: facts(entries), entries }];
+  const bySignature = new Map;
+  for (const entry of entries) {
+    const signature = surfaceSignature(config, entry.route, routeUsesActions(entry.route, actions));
+    const members = bySignature.get(signature) ?? [];
+    bySignature.set(signature, members);
+    members.push(entry);
+  }
+  return [...bySignature].map(([signature, members]) => ({
+    signature,
+    facts: facts(members),
+    entries: members
+  }));
+}
+async function buildEntryGroup({
+  config,
+  outDir,
+  entries,
+  group,
+  pipeline,
+  verbose,
+  dev
+}) {
+  const facts = dev ? { ...group.facts, dev: true } : group.facts;
+  const reactLite = facts.suspense === false;
+  const prebuilt = await clientProfile.timeAsync("prebuilt", () => preparePrebuilt(config, outDir, dev === true, (importer) => {
+    if (importer === CLIENT_RUNTIME_MODULE)
+      return clientRuntimeSource(facts);
+    const entry = entries.find((item) => item.route.id === importer);
+    return entry?.source ?? pipeline.sourceOf(importer) ?? readTextSyncSafe(importer);
+  }, group.signature, reactLite));
+  let metafile;
+  const split = Boolean(dev) && devDynamicSplitEnabled();
+  const groupDynEntries = () => {
+    const byId = new Map;
+    if (!split)
+      return [];
+    for (const entry of group.entries) {
+      for (const dynEntry of deferredDynamicEntries(entry.route))
+        byId.set(dynEntry.id, dynEntry);
+    }
+    return [...byId.values()];
+  };
+  let dynEntries = groupDynEntries();
+  const runGroupBuild = () => build3({
+    ...baseClientBuildOptions(config, dev),
+    entryPoints: [
+      ...group.entries.map((entry) => ({
+        in: virtualEntryPath(entry.route.id),
+        out: entry.entryName
+      })),
+      ...dynEntries.map((entry) => ({ in: entry.file, out: entry.id }))
+    ],
+    ...split ? { publicPath: devClientPublicPath } : {},
+    outdir: outDir,
+    metafile: true,
+    plugins: clientBuildPlugins(config, pipeline, [
+      ...prebuilt ? [prebuilt.plugin] : [],
+      virtualEntryPlugin(group.entries),
+      ...split ? [deferredDynamicExternalPlugin()] : [],
+      clientRuntimePlugin(facts)
+    ], reactLite)
+  });
+  try {
+    const result = await clientProfile.timeAsync("esbuild", () => runGroupBuild());
+    metafile = result.metafile;
+  } catch (error) {
+    if (!hasUnresolvedImportError(error))
+      throw error;
+    for (const { route } of group.entries) {
+      await buildClientEntry({ config, route, outDir, dev });
+    }
+    throw error;
+  }
+  await clientProfile.timeAsync("prebuiltSettle", () => prebuilt?.settle() ?? Promise.resolve());
+  if (verbose && metafile)
+    reportClientBundleSizes(group.entries, metafile, outDir);
+  return { group, metafile, prebuilt };
+}
+function routeSuspenseFree(config, route) {
+  if (!nextCompatEnabled(config))
+    return false;
+  return memoConvention(`suspenseFree:${route.id}`, () => {
+    const seeds = [];
+    if (route.client)
+      seeds.push(route.file);
+    for (const reference of route.clientReferences)
+      seeds.push(reference.file);
+    for (const file of [
+      routeErrorFile(config, route),
+      globalErrorFile(config),
+      routeNotFoundFile(config, route),
+      ...hasClientRootLayout(config, route) ? shellLayoutOrder(config, route) : []
+    ]) {
+      if (file)
+        seeds.push(file);
+    }
+    return clientSuspenseFree(seeds);
+  });
+}
+function routeClientSources(routes) {
+  const files = new Set;
+  for (const route of routes) {
+    if (route.client)
+      files.add(route.file);
+    for (const reference of route.clientReferences)
+      files.add(reference.file);
+  }
+  return files;
+}
+function assignClientEntryImports(entries, metafile, outDir, renames, prebuilt) {
+  const outputs = metafile.outputs;
+  const byBasename = new Map;
+  for (const item of Object.keys(outputs)) {
+    const basename = path5.basename(item);
+    if (!byBasename.has(basename))
+      byBasename.set(basename, item);
+  }
+  for (const { route, entryName } of entries) {
+    const entryOutput = byBasename.get(`${entryName}.js`);
+    if (!entryOutput)
+      continue;
+    const staticImports = new Set;
+    const dynamicImports = new Set;
+    const visited = new Set([`${entryOutput}:static`]);
+    const queue = [{ output: entryOutput, dynamic: false }];
+    for (let head = 0;head < queue.length; head += 1) {
+      const current = queue[head];
+      if (!current)
+        continue;
+      for (const imported of outputs[current.output]?.imports ?? []) {
+        if (imported.kind !== "import-statement" && imported.kind !== "dynamic-import")
+          continue;
+        const dynamic = current.dynamic || imported.kind === "dynamic-import";
+        const visitKey = `${imported.path}:${dynamic ? "dynamic" : "static"}`;
+        if (visited.has(visitKey))
+          continue;
+        visited.add(visitKey);
+        if (imported.external) {
+          if (!prebuilt || imported.path !== prebuiltModuleUrl(prebuilt.runtime))
+            continue;
+          const assets = prebuiltAssets(prebuilt.runtime);
+          for (const asset of assets.static)
+            (dynamic ? dynamicImports : staticImports).add(asset);
+          for (const asset of assets.dynamic)
+            dynamicImports.add(asset);
+          continue;
+        }
+        queue.push({ output: imported.path, dynamic });
+        const basename = path5.basename(imported.path);
+        const relative = path5.relative(outDir, path5.resolve(imported.path));
+        const publicRelative = path5.join("assets", path5.dirname(relative), renames.get(basename) ?? basename).split(path5.sep).join("/");
+        (dynamic ? dynamicImports : staticImports).add(publicRelative);
+      }
+    }
+    if (staticImports.size > 0)
+      route.clientEntryImports = [...staticImports];
+    for (const asset of staticImports)
+      dynamicImports.delete(asset);
+    if (dynamicImports.size > 0)
+      route.clientDynamicImports = [...dynamicImports];
+  }
+}
+function reportClientBundleSizes(entries, metafile, outDir) {
+  const log = createVerboseLogger(true, "client");
+  const outputs = metafile.outputs;
+  const rows = entries.map(({ route, entryName }) => {
+    const key = `${path5.relative(process.cwd(), path5.join(outDir, `${entryName}.js`))}`;
+    const output = outputs[key] ? key : Object.keys(outputs).find((item) => path5.basename(item) === `${entryName}.js`);
+    const bytes = output ? reachableOutputBytes(output, outputs) : 0;
+    return { route: route.route, bytes };
+  }).sort((a, b) => b.bytes - a.bytes);
+  for (const row of rows) {
+    log.log(`${row.route} ${dim(`\u2192 ${formatBytes(row.bytes)}`)}`);
+  }
+}
+function reachableOutputBytes(entry, outputs) {
+  const visited = new Set;
+  const queue = [entry];
+  let bytes = 0;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || visited.has(current))
+      continue;
+    visited.add(current);
+    const output = outputs[current];
+    if (!output)
+      continue;
+    bytes += output.bytes;
+    for (const imported of output.imports) {
+      if (imported.kind === "import-statement" || imported.kind === "dynamic-import") {
+        queue.push(imported.path);
+      }
+    }
+  }
+  return bytes;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  const units = ["KB", "MB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${units[unitIndex]}`;
+}
+function baseClientBuildOptions(config, dev = false) {
+  const extensions = getBundlerExtensions();
+  const pure = extensions.clientPureFunctions(config);
+  const inject = extensions.clientInjects();
+  return {
+    ...inject.length > 0 ? { inject } : {},
+    chunkNames: "chunks/[name]-[hash]",
+    bundle: true,
+    format: "esm",
+    splitting: true,
+    target: "es2022",
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    minify: !dev,
+    ...pure.length > 0 ? { pure } : {},
+    sourcemap: !dev && config.productionBrowserSourceMaps === true ? "linked" : false,
+    conditions: ["browser", "style"],
+    define: {
+      ...publicEnvDefines(),
+      ...extensions.clientDefines(),
+      "process.browser": "true",
+      ...deploymentIdDefine()
+    },
+    logOverride: { "suspicious-logical-operator": "silent" },
+    loader: {
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".otf": "file",
+      ".eot": "file"
+    }
+  };
+}
+function deploymentIdDefine() {
+  const deploymentId = process.env.NEXT_DEPLOYMENT_ID;
+  return deploymentId === undefined ? {} : { "process.env.NEXT_DEPLOYMENT_ID": JSON.stringify(deploymentId) };
+}
+function instrumentedPlugins(plugins) {
+  if (!clientProfile.enabled)
+    return plugins;
+  return plugins.map((plugin) => ({
+    name: plugin.name,
+    setup(build4) {
+      const wrap = (kind, register) => (options, callback) => register(options, async (args) => {
+        clientProfile.count(`${plugin.name}:${kind}#`);
+        const start = performance.now();
+        try {
+          return await callback(args);
+        } finally {
+          clientProfile.count(`${plugin.name}:${kind}ms`, performance.now() - start);
+        }
+      });
+      return plugin.setup({
+        ...build4,
+        onResolve: wrap("resolve", build4.onResolve.bind(build4)),
+        onLoad: wrap("load", build4.onLoad.bind(build4))
+      });
+    }
+  }));
+}
+function coalesceResolveHooks(plugins, name) {
+  if (process.env.PNEXT_CLIENT_COALESCE === "0")
+    return plugins;
+  return [
+    {
+      name,
+      async setup(build4) {
+        const registered = [];
+        let sealed = false;
+        const dispatch = async (args, skip) => {
+          for (const entry of registered) {
+            if (entry.plugin === skip)
+              continue;
+            if (entry.namespace !== undefined && entry.namespace !== args.namespace)
+              continue;
+            if (!entry.filter.test(args.path))
+              continue;
+            const result = await entry.callback(args);
+            if (result == null)
+              continue;
+            for (const message of [...result.errors ?? [], ...result.warnings ?? []]) {
+              message.pluginName ??= entry.plugin;
+            }
+            return result;
+          }
+          return;
+        };
+        for (const plugin of plugins) {
+          const proxy = {
+            ...build4,
+            onResolve(options, callback) {
+              if (sealed)
+                return build4.onResolve(options, callback);
+              registered.push({
+                plugin: plugin.name,
+                filter: new RegExp(options.filter.source, options.filter.flags.replace(/[gy]/g, "")),
+                namespace: options.namespace,
+                callback
+              });
+            },
+            resolve: (specifier, options = {}) => dispatch({
+              path: specifier,
+              importer: options.importer ?? "",
+              namespace: options.namespace ?? "",
+              resolveDir: options.resolveDir ?? "",
+              kind: options.kind ?? "import-statement",
+              pluginData: options.pluginData,
+              with: options.with ?? {}
+            }, plugin.name).then((result) => result && resolveHookSettled(result) ? resolvedFromHook(specifier, result) : build4.resolve(specifier, { ...options, pluginName: name }))
+          };
+          await plugin.setup(proxy);
+        }
+        sealed = true;
+        if (registered.length === 0)
+          return;
+        const filter = new RegExp(registered.map((entry) => `(?:${entry.filter.source})`).join("|"));
+        build4.onResolve({ filter }, (args) => dispatch(args));
+      }
+    }
+  ];
+}
+function resolvedFromHook(specifier, result) {
+  const resolved = result.path ?? (result.external ? specifier : "");
+  return {
+    errors: result.errors ?? [],
+    warnings: result.warnings ?? [],
+    path: resolved,
+    external: result.external ?? false,
+    sideEffects: result.sideEffects ?? true,
+    namespace: result.namespace ?? (result.path ? "file" : ""),
+    suffix: result.suffix ?? "",
+    pluginData: result.pluginData
+  };
+}
+function resolveHookSettled(result) {
+  return result.path !== undefined || result.external !== undefined || (result.errors?.length ?? 0) > 0 || (result.warnings?.length ?? 0) > 0;
+}
+function clientBuildPlugins(config, pipeline, extra = [], reactLite = false) {
+  return coalesceResolveHooks(instrumentedPlugins([
+    serverOnlyClientImportPlugin(),
+    ...extra,
+    ...getBundlerExtensions().clientEsbuildPlugins(config),
+    linkedPackageClientResolvePlugin(config),
+    clientStaticAssetPlugin(config),
+    pipeline.plugin(),
+    importAliasPlugin(config, reactLite),
+    cssModuleClientPlugin()
+  ]), "pnext-client-resolve-chain");
+}
+function importAliasPlugin(config, reactLite = false) {
+  const aliases = {
+    ...frameworkRuntimeAliasEntries(),
+    ...getImportAliasExtensions().aliases(config, "client")
+  };
+  if (reactLite && aliases.react) {
+    aliases.react = path5.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/client", "..", "compat", "react", "client-lite.ts");
+  }
+  const specifiers = Object.keys(aliases);
+  return {
+    name: "pnext-import-alias",
+    setup(build4) {
+      build4.onResolve({ filter: /^(?:react(?:-dom)?|next)(?:\/|$)/ }, (args) => {
+        if (aliases[args.path])
+          return;
+        const message = getImportAliasExtensions().missingImportError(config, args.path);
+        return message ? { errors: [{ text: message }] } : undefined;
+      });
+      if (specifiers.length === 0)
+        return;
+      build4.onResolve({ filter: new RegExp(`^(${specifiers.map(escapeRegex).join("|")})$`) }, async (args) => {
+        const target = aliases[args.path];
+        if (!target)
+          return;
+        if (path5.isAbsolute(target))
+          return { path: target };
+        return build4.resolve(target, {
+          kind: args.kind,
+          importer: args.importer,
+          namespace: args.namespace,
+          resolveDir: args.resolveDir
+        });
+      });
+    }
+  };
+}
+var frameworkAliasedSpecifier = /^(?:preact|react|react-dom|next)(?:\/|$)/;
+function linkedPackageClientResolvePlugin(config) {
+  const compatPreact = path5.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/client", "..", "compat", "react", "preact.ts");
+  const compatReactClient = path5.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/client", "..", "compat", "react", "client.ts");
+  return {
+    name: "pnext-linked-package-client-resolve",
+    setup(build4) {
+      build4.onResolve({ filter: /^\.\/preact$/ }, (args) => {
+        if (path5.resolve(args.importer) === compatReactClient)
+          return { path: compatPreact };
+        const hasRealSibling = [".ts", ".tsx", ".js", ".mjs", ".jsx"].some((ext) => existsSync3(path5.join(args.resolveDir, `preact${ext}`)));
+        if (hasRealSibling)
+          return;
+        return { path: compatPreact };
+      });
+      const linked = new Map;
+      build4.onResolve({ filter: /^[^./#][^:]*$/ }, (args) => {
+        if (frameworkAliasedSpecifier.test(args.path))
+          return;
+        const dir = args.resolveDir || config.root;
+        const key = `${dir}\x00${args.path}`;
+        let resolved = linked.get(key);
+        if (resolved === undefined && !linked.has(key)) {
+          resolved = resolveLinkedPackageSpecifier(config.root, path5.join(dir, "pnext-resolve.ts"), args.path, ["browser", "style", "import", "default"]);
+          linked.set(key, resolved);
+        }
+        return resolved ? { path: resolved } : undefined;
+      });
+    }
+  };
+}
+var staticImageAssetFilter = /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp)(?:$|[?#])/;
+function clientStaticAssetPlugin(config) {
+  return {
+    name: "pnext-client-static-assets",
+    setup(build4) {
+      build4.onResolve({ filter: staticImageAssetFilter }, (args) => {
+        if (getAssetExtensions().hasLoaderRuleFor(args.path)) {
+          return;
+        }
+        return {
+          path: resolveAssetPath(args.path, args.resolveDir),
+          namespace: "pnext-client-static-asset"
+        };
+      });
+      build4.onLoad({ filter: /.*/, namespace: "pnext-client-static-asset" }, async (args) => ({
+        contents: await staticImageModuleSource(config, args.path),
+        loader: "js"
+      }));
+    }
+  };
+}
+function resolveAssetPath(specifier, resolveDir) {
+  const { sourcePath, hash } = splitAssetHash(specifier);
+  const resolved = path5.isAbsolute(sourcePath) ? sourcePath : path5.resolve(resolveDir, sourcePath);
+  return `${resolved}${hash}`;
+}
+function splitAssetHash(specifier) {
+  const index = specifier.search(/[?#]/);
+  return index === -1 ? { sourcePath: specifier, hash: "" } : { sourcePath: specifier.slice(0, index), hash: specifier.slice(index) };
+}
+async function staticImageModuleSource(config, file) {
+  const { sourcePath } = splitAssetHash(file);
+  const bytes = new Uint8Array(await readFile(sourcePath));
+  const emitted = [];
+  const emit = (relative) => {
+    emitted.push(relative);
+    return `/${relative}`;
+  };
+  const compat = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit });
+  const source = compat ?? coreStaticAssetModule(sourcePath, bytes, emit);
+  for (const relative of emitted) {
+    const target = path5.join(config.outPath, "public", ...relative.split("/"));
+    await mkdir(path5.dirname(target), { recursive: true });
+    if (!existsSync3(target))
+      await copyFile(sourcePath, target);
+  }
+  return source;
+}
+function coreStaticAssetModule(sourcePath, bytes, emit) {
+  const ext = path5.extname(sourcePath).toLowerCase() || ".bin";
+  const hash = createHash3("sha256").update(bytes).digest("hex").slice(0, 8);
+  const base = path5.basename(sourcePath, path5.extname(sourcePath)).replace(/[^A-Za-z0-9_-]+/g, "-");
+  const relative = path5.posix.join("_next", "static", "media", `${base}.${hash}${ext}`);
+  const src = emit(relative);
+  return `const src = ${JSON.stringify(src)};
+export default src;
+export { src };
+`;
+}
+function createClientSourcePipeline(config, dev = false, routeId) {
+  const sourceRewrite = nextCompatEnabled(config);
+  const compiler = getCompatModeExtensions().reactCompilerOptions(config);
+  const asyncPre = hasClientSourceAsyncPreTransforms();
+  const roots = clientSourceRoots(config).map((root) => escapeRegex(root)).join("|");
+  const sep = escapeRegex(path5.sep);
+  const filter = new RegExp(`^(?:${roots})(?:${sep}${nonSegmentPattern("node_modules", sep)})*${sep}[^${sep}]*\\.(?:[cm]?[jt]sx?)$`);
+  const transpiled = sourceRewrite ? transpiledPackageFilter(roots) : undefined;
+  const prepared = new Map;
+  const deferredRefs = new Map;
+  const loaded = new Map;
+  function prepare(resolved) {
+    const existing = prepared.get(resolved);
+    if (existing)
+      return existing;
+    const pending = runPipeline(resolved);
+    prepared.set(resolved, pending);
+    return pending;
+  }
+  async function runPipeline(resolved) {
+    const inNodeModules = resolved.split(path5.sep).includes("node_modules");
+    if (inNodeModules && (!sourceRewrite || !isTranspiledPackageFile(resolved)))
+      return;
+    clientProfile.count("loadFiles");
+    const original = await clientProfile.timeAsync("read", () => readSourceText(resolved));
+    let contents = original;
+    if (asyncPre) {
+      contents = await applyClientSourceAsyncPreTransforms(contents, resolved, config.root);
+    }
+    contents = clientProfile.time("chain", () => applyClientSourceTransforms(contents, resolved, config.root));
+    contents = clientProfile.time("dynamic", () => rewriteLiteralDynamicCalls(contents, resolved));
+    if (dev && devDynamicSplitEnabled()) {
+      contents = rewriteDeferredDynamicImports(contents, resolved, (specifier) => resolveImport(rootFromFile(resolved), resolved, specifier, config.workspaceRoot), (target) => {
+        const id = clientReferenceId(target.file, target.exportName);
+        const ref = { ...target, routeId };
+        registerDeferredDynamicRef(id, ref);
+        deferredRefs.set(id, ref);
+        return deferredDynamicChunkHref({ id }, routeId);
+      });
+    }
+    if (compiler && !inNodeModules && shouldReactCompile(contents, resolved)) {
+      contents = await clientProfile.timeAsync("reactCompiler", () => reactCompiled(resolved, contents, compiler));
+    }
+    loaded.set(resolved, contents);
+    if (contents === original && !/\.m?js$/.test(resolved))
+      return;
+    return { contents, loader: clientSourceLoader(resolved) };
+  }
+  return {
+    sourceOf(file) {
+      return loaded.get(file);
+    },
+    deferredRefs() {
+      return deferredRefs;
+    },
+    warmRoutes(routes) {
+      this.warm(routeClientSources(routes));
+    },
+    warm(files) {
+      for (const file of files) {
+        const resolved = path5.resolve(file);
+        if (!filter.test(resolved) && !transpiled?.test(resolved))
+          continue;
+        prepare(resolved).catch(() => {
+          return;
+        });
+      }
+    },
+    plugin() {
+      return {
+        name: "pnext-client-source",
+        setup(build4) {
+          build4.onLoad({ filter, namespace: "file" }, (args) => prepare(path5.resolve(args.path)));
+          if (transpiled) {
+            build4.onLoad({ filter: transpiled, namespace: "file" }, (args) => prepare(path5.resolve(args.path)));
+          }
+        }
+      };
+    }
+  };
+}
+function startClientSources(config) {
+  conventionCache.clear();
+  return createClientSourcePipeline(config);
+}
+var reactCompiledCache = new Map;
+function reactCompiled(file, source, options) {
+  const hash = Bun.hash.wyhash(`${options.target}\x00${source}`);
+  const cached = reactCompiledCache.get(file);
+  if (cached?.hash === hash)
+    return cached.code;
+  const code = transformReactCompiler(source, file, options);
+  reactCompiledCache.set(file, { hash, code });
+  return code;
+}
+function clientSourceRoots(config) {
+  const roots = new Set;
+  for (const root of [config.root, config.workspaceRoot]) {
+    const resolved = path5.resolve(root);
+    roots.add(resolved);
+    try {
+      roots.add(realpathSync.native(resolved));
+    } catch {}
+  }
+  return [...roots];
+}
+function clientSourceLoader(file) {
+  if (file.endsWith(".tsx"))
+    return "tsx";
+  if (/\.[cm]?ts$/.test(file))
+    return "ts";
+  return file.endsWith(".cjs") ? "js" : "jsx";
+}
+function nonSegmentPattern(word, sep) {
+  const parts = [`${word}[^${sep}]+`];
+  for (let index = 0;index < word.length; index += 1) {
+    const prefix = word.slice(0, index);
+    parts.push(prefix, `${prefix}[^${sep}${word[index]}][^${sep}]*`);
+  }
+  return `(?:${parts.join("|")})`;
+}
+function transpiledPackageFilter(roots) {
+  const sep = escapeRegex(path5.sep);
+  const names = getExternalPackagePolicy().transpiled?.();
+  if (names?.length === 0)
+    return;
+  const packages = names ? `(?:${names.map((name) => escapeRegex(name).split("/").join(sep)).join("|")})${sep}` : "";
+  return new RegExp(`^(?:${roots}).*${sep}node_modules${sep}${packages}.*\\.(?:[cm]?[jt]sx?)$`);
+}
+function isTranspiledPackageFile(file) {
+  const parts = file.split(path5.sep);
+  const nodeModules = parts.lastIndexOf("node_modules");
+  if (nodeModules === -1)
+    return false;
+  const first = parts[nodeModules + 1];
+  if (!first)
+    return false;
+  const name = first.startsWith("@") ? `${first}/${parts[nodeModules + 2] ?? ""}` : first;
+  return getExternalPackagePolicy().transpile(name);
+}
+function virtualEntryPath(routeId) {
+  return `${virtualEntryNamespace}:${routeId}`;
+}
+function virtualEntryPlugin(entries) {
+  const sources = new Map(entries.map((entry) => [entry.route.id, entry.source]));
+  return {
+    name: "pnext-virtual-client-entry",
+    setup(build4) {
+      build4.onResolve({ filter: new RegExp(`^${escapeRegex(virtualEntryNamespace)}:`) }, (args) => ({
+        path: args.path.slice(virtualEntryNamespace.length + 1),
+        namespace: virtualEntryNamespace
+      }));
+      build4.onLoad({ filter: /.*/, namespace: virtualEntryNamespace }, (args) => {
+        const contents = sources.get(args.path);
+        if (contents === undefined)
+          return;
+        return { contents, loader: "ts", resolveDir: process.cwd() };
+      });
+    }
+  };
+}
+function clientRuntimePlugin(facts) {
+  return {
+    name: "pnext-client-runtime",
+    setup(build4) {
+      build4.onResolve({ filter: new RegExp(`^${escapeRegex(CLIENT_RUNTIME_MODULE)}$`) }, () => ({
+        path: CLIENT_RUNTIME_MODULE,
+        namespace: CLIENT_RUNTIME_MODULE
+      }));
+      build4.onLoad({ filter: /.*/, namespace: CLIENT_RUNTIME_MODULE }, () => ({
+        contents: clientRuntimeSource(facts),
+        loader: "ts",
+        resolveDir: process.cwd()
+      }));
+    }
+  };
+}
+async function profileClientBuild(route, dev, task) {
+  if (!traceEnabled("server"))
+    return task();
+  const start = performance.now();
+  try {
+    return await task();
+  } finally {
+    const mode = dev ? "dev" : "prod";
+    console.log(`dev-profile client build ${mode} ${route.route} in ${formatDuration(performance.now() - start)}`);
+  }
+}
+function serverOnlyClientImportPlugin() {
+  return {
+    name: "pnext-server-only-client-import",
+    setup(build4) {
+      build4.onResolve({ filter: /^(next|next\/headers|next\/font|next\/font\/google|next\/font\/local)$/ }, (args) => ({
+        errors: [
+          {
+            text: `${args.path} is server-only and cannot be imported from Client Components.`
+          }
+        ]
+      }));
+    }
+  };
+}
+var traceSourceExtensions = [".tsx", ".ts", ".jsx", ".js", ".mts", ".cts", ".module.css", ".css"];
+function withClientImportTrace(error, config, route, entrySource) {
+  const message = error instanceof Error ? error.message : String(error);
+  const trace = clientImportTrace(config, route, entrySource, error);
+  if (!trace)
+    return error;
+  const next = new Error(`${message}
+
+${trace}`);
+  if (error instanceof Error) {
+    next.name = error.name;
+    next.stack = error.stack ? `${error.stack}
+
+${trace}` : next.stack;
+    Object.assign(next, error);
+  }
+  return next;
+}
+function clientImportTrace(config, route, entrySource, error) {
+  const unresolved = unresolvedImportFromError(error);
+  if (!unresolved)
+    return;
+  const entryFile = `${route.id}.ts`;
+  const failedFile = unresolved.file ? resolveTraceFile(unresolved.file) : undefined;
+  const parents = new Map;
+  const visited = new Set;
+  const queue = [{ file: entryFile, source: entrySource }];
+  let unresolvedImporter;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || visited.has(current.file))
+      continue;
+    visited.add(current.file);
+    if (visited.size > 2000)
+      break;
+    for (const specifier of localImports(current.file, current.source)) {
+      const resolved = resolveTraceImport(config.root, current.file, specifier);
+      if (!resolved) {
+        if (specifier === unresolved.specifier && (!failedFile || sameFile(current.file, failedFile))) {
+          unresolvedImporter = current.file;
+          queue.length = 0;
+          break;
+        }
+        continue;
+      }
+      if (!parents.has(resolved))
+        parents.set(resolved, { file: current.file, specifier });
+      if (failedFile && sameFile(resolved, failedFile)) {
+        unresolvedImporter = resolved;
+        queue.length = 0;
+        break;
+      }
+      if (!visited.has(resolved) && !isAssetLike(resolved)) {
+        queue.push({ file: resolved, source: readTextSyncSafe(resolved) });
+      }
+    }
+  }
+  if (!unresolvedImporter)
+    return;
+  const trace = tracePath(entryFile, unresolvedImporter, parents);
+  if (trace.length === 0)
+    return;
+  return [
+    `pnext client import trace for route ${route.route}:`,
+    ...trace.map((file, index) => `${index === 0 ? "  " : "  -> "}${displayTraceFile(config, file)}`),
+    `  -> ${unresolved.specifier} (unresolved in browser client bundle)`
+  ].join(`
+`);
+}
+function hasUnresolvedImportError(error) {
+  const errors = error.errors;
+  if (Array.isArray(errors)) {
+    return errors.some((item) => item.text?.startsWith("Could not resolve "));
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Could not resolve ");
+}
+function unresolvedImportFromError(error) {
+  const buildError = error;
+  const diagnostic = buildError.errors?.find((item) => item.text?.startsWith("Could not resolve "));
+  const message = error instanceof Error ? error.message : String(error);
+  const text = diagnostic?.text ?? message;
+  const specifier = /Could not resolve "([^"]+)"/.exec(text)?.[1];
+  if (!specifier)
+    return;
+  return {
+    specifier,
+    file: diagnostic?.location?.file ?? errorFileFromMessage(message)
+  };
+}
+function errorFileFromMessage(message) {
+  const match = /\n\s+([^:\n]+):\d+:\d+:\s+ERROR:\s+Could not resolve /.exec(message);
+  return match?.[1];
+}
+function resolveTraceImport(root, fromFile, specifier) {
+  if (path5.isAbsolute(specifier))
+    return resolveTraceCandidate(specifier);
+  return resolveImport(root, fromFile, specifier);
+}
+function resolveTraceFile(file) {
+  return canonicalTraceFile(path5.isAbsolute(file) ? path5.resolve(file) : path5.resolve(process.cwd(), file));
+}
+function resolveTraceCandidate(base) {
+  const ext = path5.extname(base);
+  const candidates = ext ? [base] : [
+    ...traceSourceExtensions.map((extension) => `${base}${extension}`),
+    ...traceSourceExtensions.map((extension) => path5.join(base, `index${extension}`)),
+    base
+  ];
+  const resolved = candidates.find(isTraceFile);
+  return resolved ? canonicalTraceFile(resolved) : undefined;
+}
+function isTraceFile(file) {
+  try {
+    return statSync3(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function readTextSyncSafe(file) {
+  try {
+    return existsSync3(file) ? readFileSync2(file, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+function tracePath(entryFile, targetFile, parents) {
+  const pathItems = [targetFile];
+  let current = targetFile;
+  while (current !== entryFile) {
+    const parent = parents.get(current);
+    if (!parent)
+      return [];
+    current = parent.file;
+    pathItems.push(current);
+  }
+  return pathItems.reverse();
+}
+function sameFile(a, b) {
+  return canonicalTraceFile(a) === canonicalTraceFile(b);
+}
+function displayTraceFile(config, file) {
+  if (!path5.isAbsolute(file))
+    return `${file} (generated client entry)`;
+  const root = canonicalTraceFile(config.root);
+  const workspaceRoot = canonicalTraceFile(config.workspaceRoot);
+  const resolvedFile = canonicalTraceFile(file);
+  const rootRelative = path5.relative(root, resolvedFile);
+  if (!rootRelative.startsWith("..") && !path5.isAbsolute(rootRelative))
+    return rootRelative;
+  const workspaceRelative = path5.relative(workspaceRoot, resolvedFile);
+  if (!workspaceRelative.startsWith("..") && !path5.isAbsolute(workspaceRelative))
+    return workspaceRelative;
+  return resolvedFile;
+}
+function canonicalTraceFile(file) {
+  try {
+    return realpathSync.native(file);
+  } catch {
+    return path5.resolve(file);
+  }
+}
+function clientCacheStaticHash(route, nextCompat, config) {
+  conventionCache.clear();
+  const hash = createHash3("sha256");
+  hash.update(frameworkFingerprint());
+  hash.update("\x00");
+  hash.update(clientEntrySource({
+    deferredDynamicHref: devDeferredDynamicHref(true),
+    pageFile: route.client ? route.file : undefined,
+    clientReferences: route.clientReferences,
+    nextCompat,
+    errorFile: nextCompat && config ? routeErrorFile(config, route) : undefined,
+    globalErrorFile: nextCompat && config ? globalErrorFile(config) : undefined,
+    notFoundFile: nextCompat && config ? routeNotFoundFile(config, route) : undefined,
+    controlFlow: nextCompat ? routeThrowsClientControlFlow(route) : false,
+    router: Boolean(route.needsRouterEntry),
+    clientRootLayout: config ? hasClientRootLayout(config, route) : false,
+    shellLayoutOrder: config ? shellLayoutOrder(config, route) : []
+  }));
+  hash.update("\x00");
+  hash.update(route.id);
+  hash.update("\x00");
+  hash.update(route.client ? route.file : "");
+  hash.update(JSON.stringify(route.clientReferences));
+  return hash.digest("hex");
+}
+function clientCacheKeyFrom(staticHash, sources) {
+  const hash = createHash3("sha256").update(staticHash).update("\x00");
+  for (const source of sources) {
+    hash.update(source.file);
+    hash.update("\x00");
+    hash.update(source.hash);
+    hash.update("\x00");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function clientSourceHash(source) {
+  return Bun.hash(source).toString(36);
+}
+async function readClientCacheSource(file) {
+  const stats = await stat(file).catch(() => {
+    return;
+  });
+  return {
+    file,
+    mtimeMs: stats?.mtimeMs ?? 0,
+    size: stats?.size ?? 0,
+    hash: clientSourceHash(await readText(file))
+  };
+}
+async function clientCacheKeyParts(route, nextCompat, config, staticHash) {
+  const staticDigest = staticHash ?? clientCacheStaticHash(route, nextCompat, config);
+  const sources = await Promise.all((await clientSourceFiles(route, config?.workspaceRoot)).map((file) => readClientCacheSource(file)));
+  return { key: clientCacheKeyFrom(staticDigest, sources), staticHash: staticDigest, sources };
+}
+async function clientSourceFiles(route, workspaceRoot) {
+  const entryFiles = [
+    ...route.client ? [route.file] : [],
+    ...route.clientReferences.map((reference) => reference.file)
+  ];
+  const files = new Set;
+  await Promise.all(entryFiles.map((file) => collectClientSourceFile(file, files, workspaceRoot)));
+  return [...files].sort();
+}
+async function collectClientSourceFile(file, files, workspaceRoot) {
+  if (files.has(file) || !existsSync3(file))
+    return;
+  files.add(file);
+  if (isAssetLike(file))
+    return;
+  const source = rewriteLiteralDynamicCalls(await readText(file), file);
+  await Promise.all([...localImports(file, source)].map((specifier) => {
+    const resolved = resolveImport(rootFromFile(file), file, specifier, workspaceRoot);
+    return resolved ? collectClientSourceFile(resolved, files, workspaceRoot) : Promise.resolve();
+  }));
+}
+function localImports(file, source) {
+  const facts = scanFacts(file, source);
+  const imports = new Set;
+  for (const edge of facts.imports)
+    imports.add(edge.specifier);
+  for (const edge of facts.dynamicImports)
+    imports.add(edge.specifier);
+  return imports;
+}
+function isAssetLike(file) {
+  return /\.(css|svg|png|jpe?g|gif|webp|ico|woff2?)$/.test(file);
+}
+function rootFromFile(file) {
+  const parts = file.split(path5.sep);
+  const srcApp = parts.lastIndexOf("src");
+  if (srcApp !== -1 && parts[srcApp + 1] === "app")
+    return parts.slice(0, srcApp).join(path5.sep) || path5.sep;
+  const app = parts.lastIndexOf("app");
+  if (app !== -1)
+    return parts.slice(0, app).join(path5.sep) || path5.sep;
+  return path5.dirname(file);
+}
+async function nameSharedClientChunks(outDir, metafile) {
+  if (metafile && traceEnabled("client")) {
+    await writeText(path5.join(outDir, "metafile.json"), JSON.stringify(metafile));
+  }
+  const chunksDir = path5.join(outDir, "chunks");
+  const chunkFiles = await listFiles(chunksDir);
+  const files = chunkFiles.filter((file) => file.endsWith(".js"));
+  const labels = metafile ? chunkLabelsFromMetafile(metafile) : new Map;
+  const renames = new Map;
+  const mapRenames = new Map;
+  await Promise.all(chunkFiles.filter((file) => file.endsWith(".js.map")).map(async (file) => {
+    const basename = path5.basename(file);
+    const next = `chunk-map-${assetContentHash(await readFile(file))}.js.map`;
+    mapRenames.set(basename, next);
+    if (basename !== next)
+      await rename(file, path5.join(chunksDir, next));
+  }));
+  const sources = new Map(await Promise.all(files.map(async (file) => [file, replaceChunkNames(await readText(file), mapRenames)])));
+  const sourceByName = new Map([...sources].map(([file, source]) => [path5.basename(file), source]));
+  const names = [...sourceByName.keys()].sort();
+  const dependencies = new Map(names.map((name) => [
+    name,
+    new Set(names.filter((candidate) => sourceByName.get(name).includes(candidate)))
+  ]));
+  const groups = chunkDependencyGroups(names, dependencies);
+  const groupByName = new Map(groups.flatMap((group, index) => group.map((name) => [name, index])));
+  const pending = new Set(groups.map((_, index) => index));
+  const finalSources = new Map;
+  while (pending.size > 0) {
+    let progressed = false;
+    for (const groupIndex of pending) {
+      const group = groups[groupIndex];
+      const waitsFor = group.some((name) => [...dependencies.get(name) ?? []].some((dependency) => {
+        const dependencyGroup = groupByName.get(dependency);
+        return dependencyGroup !== groupIndex && pending.has(dependencyGroup);
+      }));
+      if (waitsFor)
+        continue;
+      const rewritten = new Map(group.map((name) => [name, replaceChunkNames(sourceByName.get(name), renames)]));
+      const cyclic = group.length > 1 || (dependencies.get(group[0])?.has(group[0]) ?? false);
+      if (cyclic) {
+        const placeholders = new Map(group.map((name, index) => [name, `__pnext_cycle_${index}.js`]));
+        const canonical = group.map((name) => replaceChunkNames(rewritten.get(name), placeholders)).join("\x00");
+        const groupHash = assetContentHash(canonical);
+        for (const [index, name] of group.entries()) {
+          renames.set(name, `${clientChunkLabel(name, labels)}-${groupHash}-${index}.js`);
+        }
+      } else {
+        const name = group[0];
+        renames.set(name, `${clientChunkLabel(name, labels)}-${assetContentHash(rewritten.get(name))}.js`);
+      }
+      for (const name of group) {
+        finalSources.set(name, replaceChunkNames(rewritten.get(name), renames));
+      }
+      pending.delete(groupIndex);
+      progressed = true;
+    }
+    if (!progressed)
+      throw new Error("Unable to order client chunk dependency groups");
+  }
+  if (renames.size === 0)
+    return renames;
+  await Promise.all([...renames].map(async ([from, to]) => {
+    const fromPath = path5.join(chunksDir, from);
+    const toPath = path5.join(chunksDir, to);
+    if (from === to || !existsSync3(fromPath))
+      return;
+    try {
+      await rename(fromPath, toPath);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    await writeText(toPath, finalSources.get(from));
+  }));
+  const outputs = (await listFiles(outDir)).filter((item) => item.endsWith(".js"));
+  await Promise.all(outputs.map(async (file) => {
+    const originalName = path5.basename(file);
+    const source = sources.get(file) ?? await readText(file);
+    const next = finalSources.get(originalName) ?? replaceChunkNames(source, renames);
+    if (next !== source)
+      await writeText(file, next);
+  }));
+  return renames;
+}
+function clientChunkLabel(file, labels) {
+  if (file.startsWith("chunk-"))
+    return labels.get(file) ?? "shared";
+  return path5.basename(file, ".js").replace(/-(?:[A-Z0-9]{8}|[0-9a-f]{16})$/, "");
+}
+function chunkLabelsFromMetafile(metafile) {
+  const labels = new Map;
+  for (const [outputPath, output] of Object.entries(metafile.outputs)) {
+    const basename = path5.basename(outputPath);
+    if (!basename.startsWith("chunk-") || !basename.endsWith(".js"))
+      continue;
+    const weights = new Map;
+    for (const [input, { bytesInOutput }] of Object.entries(output.inputs)) {
+      const label = chunkInputLabel(input);
+      if (!label)
+        continue;
+      weights.set(label, (weights.get(label) ?? 0) + bytesInOutput);
+    }
+    const top = [...weights.entries()].sort((a, b) => b[1] - a[1])[0];
+    if (top)
+      labels.set(basename, top[0]);
+  }
+  return labels;
+}
+function chunkInputLabel(input) {
+  const posix = input.split(path5.sep).join("/");
+  const packageIndex = posix.lastIndexOf("node_modules/");
+  if (packageIndex !== -1) {
+    const parts = posix.slice(packageIndex + "node_modules/".length).split("/");
+    const name = parts[0]?.startsWith("@") ? `${parts[0]}-${parts[1] ?? ""}` : parts[0];
+    return sanitizeChunkLabel(name ?? "");
+  }
+  return sanitizeChunkLabel(posix.split("/").at(-1)?.replace(/\.[^.]+$/, "") ?? "");
+}
+function sanitizeChunkLabel(label) {
+  const clean = label.replace(/^@/, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 40);
+  return clean || undefined;
+}
+function chunkDependencyGroups(names, dependencies) {
+  let nextIndex = 0;
+  const indices = new Map;
+  const lowLinks = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const groups = [];
+  const visit = (name) => {
+    const index = nextIndex++;
+    indices.set(name, index);
+    lowLinks.set(name, index);
+    stack.push(name);
+    onStack.add(name);
+    for (const dependency of dependencies.get(name) ?? []) {
+      if (!indices.has(dependency)) {
+        visit(dependency);
+        lowLinks.set(name, Math.min(lowLinks.get(name), lowLinks.get(dependency)));
+      } else if (onStack.has(dependency)) {
+        lowLinks.set(name, Math.min(lowLinks.get(name), indices.get(dependency)));
+      }
+    }
+    if (lowLinks.get(name) !== indices.get(name))
+      return;
+    const group = [];
+    for (;; ) {
+      const member = stack.pop();
+      onStack.delete(member);
+      group.push(member);
+      if (member === name)
+        break;
+    }
+    groups.push(group.sort());
+  };
+  for (const name of names)
+    if (!indices.has(name))
+      visit(name);
+  return groups;
+}
+function replaceChunkNames(source, renames) {
+  const pattern = new RegExp([...renames.keys()].map(escapeRegex).join("|"), "g");
+  return source.replace(pattern, (match) => renames.get(match) ?? match);
+}
+
+export { emitStaticClientChunks, prebuiltRuntimeDir, registerDeferredDynamicRef, deferredDynamicRefById, DEFERRED_DYNAMIC_SIDECAR, buildClientEntry, buildClientEntries, startClientSources, clientCacheStaticHash, clientSourceHash, clientCacheKeyParts };