@warlock.js/web 5.0.2 → 5.2.0

package/esm/server/page-file-change.mjs

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+
+//#region web/src/server/page-file-change.ts
+const PAGE_FILE_SUFFIX = ".page.tsx";
+function isFile(file) {
+	try {
+		return fs.statSync(file).isFile();
+	} catch {
+		return false;
+	}
+}
+function normalizePath(appRoot, file) {
+	return path.resolve(appRoot, file.replace(/[\\/]+/g, path.sep));
+}
+function pathKey(file) {
+	const normalized = file.replace(/\\/g, "/");
+	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isPageFilePath(file, appSrcRoot) {
+	if (!file.endsWith(".page.tsx")) return false;
+	const relative = path.relative(appSrcRoot, file);
+	return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative) && relative.split(path.sep)[0] === "web";
+}
+/**
+* Layouts contribute to every descendant page's derived route identity, but
+* never own a route themselves. Keep this predicate aligned with
+* `page-registry-plugin.ts` so a layout lifecycle event re-derives the whole
+* page table rather than being discarded as an ordinary Vite update.
+*/
+function isPageLayoutFilePath(file, appSrcRoot) {
+	const relative = path.relative(appSrcRoot, file);
+	const base = path.basename(file);
+	return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative) && relative.split(path.sep)[0] === "web" && (base === "layout.ts" || base === "layout.tsx" || /\.layout\.tsx?$/.test(base));
+}
+/** Error boundaries participate in reload tracking but never in router ownership. */
+function isErrorPageFilePath(file) {
+	return path.basename(file) === "error.page.tsx";
+}
+function classifyPageFileChanges(changedFiles, options) {
+	const pageRoot = path.resolve(options.appRoot, options.appSrcRoot);
+	const installed = new Set(options.installedPageFiles.map((file) => pathKey(normalizePath(options.appRoot, file))));
+	const classified = {
+		added: [],
+		removed: [],
+		inspectionNeeded: []
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const fileExists = options.fileExists ?? isFile;
+	for (const changedFile of changedFiles) {
+		const file = normalizePath(options.appRoot, changedFile);
+		const key = pathKey(file);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (isPageLayoutFilePath(file, pageRoot)) {
+			(fileExists(file) ? classified.added : classified.removed).push(file);
+			continue;
+		}
+		if (!isPageFilePath(file, pageRoot)) continue;
+		const isInstalled = installed.has(key);
+		const isErrorPage = isErrorPageFilePath(file);
+		if (!fileExists(file)) {
+			if (isInstalled || isErrorPage) classified.removed.push(file);
+			continue;
+		}
+		if (isInstalled || isErrorPage) classified.inspectionNeeded.push(file);
+		else classified.added.push(file);
+	}
+	return classified;
+}
+function hasPageFileChanges(changes) {
+	return changes.added.length > 0 || changes.removed.length > 0 || changes.inspectionNeeded.length > 0;
+}
+
+//#endregion
+export { classifyPageFileChanges, hasPageFileChanges, isErrorPageFilePath };
+//# sourceMappingURL=page-file-change.mjs.map

package/esm/server/page-file-change.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-file-change.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/page-file-change.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\n\nexport const PAGE_FILE_SUFFIX = \".page.tsx\";\n\nexport type PageFileChanges = {\n  added: string[];\n  removed: string[];\n  inspectionNeeded: string[];\n};\n\nexport type PageFileChangeOptions = {\n  appRoot: string;\n  appSrcRoot: string;\n  installedPageFiles: readonly string[];\n  fileExists?: (file: string) => boolean;\n};\n\nfunction isFile(file: string): boolean {\n  try {\n    return fs.statSync(file).isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction normalizePath(appRoot: string, file: string): string {\n  return path.resolve(appRoot, file.replace(/[\\\\/]+/g, path.sep));\n}\n\nfunction pathKey(file: string): string {\n  const normalized = file.replace(/\\\\/g, \"/\");\n\n  return process.platform === \"win32\" ? normalized.toLowerCase() : normalized;\n}\n\nexport function isPageFilePath(file: string, appSrcRoot: string): boolean {\n  if (!file.endsWith(PAGE_FILE_SUFFIX)) {\n    return false;\n  }\n\n  const relative = path.relative(appSrcRoot, file);\n\n  return (\n    relative !== \"\" &&\n    !relative.startsWith(`..${path.sep}`) &&\n    relative !== \"..\" &&\n    !path.isAbsolute(relative) &&\n    relative.split(path.sep)[0] === \"web\"\n  );\n}\n\n/**\n * Layouts contribute to every descendant page's derived route identity, but\n * never own a route themselves. Keep this predicate aligned with\n * `page-registry-plugin.ts` so a layout lifecycle event re-derives the whole\n * page table rather than being discarded as an ordinary Vite update.\n */\nexport function isPageLayoutFilePath(file: string, appSrcRoot: string): boolean {\n  const relative = path.relative(appSrcRoot, file);\n  const base = path.basename(file);\n\n  return (\n    relative !== \"\" &&\n    !relative.startsWith(`..${path.sep}`) &&\n    relative !== \"..\" &&\n    !path.isAbsolute(relative) &&\n    relative.split(path.sep)[0] === \"web\" &&\n    (base === \"layout.ts\" || base === \"layout.tsx\" || /\\.layout\\.tsx?$/.test(base))\n  );\n}\n\n/** Error boundaries participate in reload tracking but never in router ownership. */\nexport function isErrorPageFilePath(file: string): boolean {\n  return path.basename(file) === \"error.page.tsx\";\n}\n\nexport function classifyPageFileChanges(\n  changedFiles: readonly string[],\n  options: PageFileChangeOptions,\n): PageFileChanges {\n  const pageRoot = path.resolve(options.appRoot, options.appSrcRoot);\n  const installed = new Set(\n    options.installedPageFiles.map((file) => pathKey(normalizePath(options.appRoot, file))),\n  );\n  const classified: PageFileChanges = { added: [], removed: [], inspectionNeeded: [] };\n  const seen = new Set<string>();\n  const fileExists = options.fileExists ?? isFile;\n\n  for (const changedFile of changedFiles) {\n    const file = normalizePath(options.appRoot, changedFile);\n    const key = pathKey(file);\n\n    if (seen.has(key)) {\n      continue;\n    }\n\n    seen.add(key);\n\n    // A layout has no individual router owner. Its addition, removal, or\n    // in-place edit can change every descendant page's prefix/layout chain, so\n    // force the existing full page-table derivation transaction. `added` is\n    // deliberately the transaction's \"replacement required\" bucket here;\n    // it does not claim the layout itself owns a newly-added route.\n    if (isPageLayoutFilePath(file, pageRoot)) {\n      (fileExists(file) ? classified.added : classified.removed).push(file);\n      continue;\n    }\n\n    if (!isPageFilePath(file, pageRoot)) {\n      continue;\n    }\n\n    const isInstalled = installed.has(key);\n    const isErrorPage = isErrorPageFilePath(file);\n    if (!fileExists(file)) {\n      if (isInstalled || isErrorPage) {\n        classified.removed.push(file);\n      }\n      continue;\n    }\n\n    if (isInstalled || isErrorPage) {\n      classified.inspectionNeeded.push(file);\n    } else {\n      classified.added.push(file);\n    }\n  }\n\n  return classified;\n}\n\nexport function hasPageFileChanges(changes: PageFileChanges): boolean {\n  return (\n    changes.added.length > 0 ||\n    changes.removed.length > 0 ||\n    changes.inspectionNeeded.length > 0\n  );\n}\n"],"mappings":";;;;AAGA,MAAa,mBAAmB;AAehC,SAAS,OAAO,MAAuB;CACrC,IAAI;EACF,OAAO,GAAG,SAAS,IAAI,EAAE,OAAO;CAClC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,cAAc,SAAiB,MAAsB;CAC5D,OAAO,KAAK,QAAQ,SAAS,KAAK,QAAQ,WAAW,KAAK,GAAG,CAAC;AAChE;AAEA,SAAS,QAAQ,MAAsB;CACrC,MAAM,aAAa,KAAK,QAAQ,OAAO,GAAG;CAE1C,OAAO,QAAQ,aAAa,UAAU,WAAW,YAAY,IAAI;AACnE;AAEA,SAAgB,eAAe,MAAc,YAA6B;CACxE,IAAI,CAAC,KAAK,oBAAyB,GACjC,OAAO;CAGT,MAAM,WAAW,KAAK,SAAS,YAAY,IAAI;CAE/C,OACE,aAAa,MACb,CAAC,SAAS,WAAW,KAAK,KAAK,KAAK,KACpC,aAAa,QACb,CAAC,KAAK,WAAW,QAAQ,KACzB,SAAS,MAAM,KAAK,GAAG,EAAE,OAAO;AAEpC;;;;;;;AAQA,SAAgB,qBAAqB,MAAc,YAA6B;CAC9E,MAAM,WAAW,KAAK,SAAS,YAAY,IAAI;CAC/C,MAAM,OAAO,KAAK,SAAS,IAAI;CAE/B,OACE,aAAa,MACb,CAAC,SAAS,WAAW,KAAK,KAAK,KAAK,KACpC,aAAa,QACb,CAAC,KAAK,WAAW,QAAQ,KACzB,SAAS,MAAM,KAAK,GAAG,EAAE,OAAO,UAC/B,SAAS,eAAe,SAAS,gBAAgB,kBAAkB,KAAK,IAAI;AAEjF;;AAGA,SAAgB,oBAAoB,MAAuB;CACzD,OAAO,KAAK,SAAS,IAAI,MAAM;AACjC;AAEA,SAAgB,wBACd,cACA,SACiB;CACjB,MAAM,WAAW,KAAK,QAAQ,QAAQ,SAAS,QAAQ,UAAU;CACjE,MAAM,YAAY,IAAI,IACpB,QAAQ,mBAAmB,KAAK,SAAS,QAAQ,cAAc,QAAQ,SAAS,IAAI,CAAC,CAAC,CACxF;CACA,MAAM,aAA8B;EAAE,OAAO,CAAC;EAAG,SAAS,CAAC;EAAG,kBAAkB,CAAC;CAAE;CACnF,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,aAAa,QAAQ,cAAc;CAEzC,KAAK,MAAM,eAAe,cAAc;EACtC,MAAM,OAAO,cAAc,QAAQ,SAAS,WAAW;EACvD,MAAM,MAAM,QAAQ,IAAI;EAExB,IAAI,KAAK,IAAI,GAAG,GACd;EAGF,KAAK,IAAI,GAAG;EAOZ,IAAI,qBAAqB,MAAM,QAAQ,GAAG;GACxC,CAAC,WAAW,IAAI,IAAI,WAAW,QAAQ,WAAW,SAAS,KAAK,IAAI;GACpE;EACF;EAEA,IAAI,CAAC,eAAe,MAAM,QAAQ,GAChC;EAGF,MAAM,cAAc,UAAU,IAAI,GAAG;EACrC,MAAM,cAAc,oBAAoB,IAAI;EAC5C,IAAI,CAAC,WAAW,IAAI,GAAG;GACrB,IAAI,eAAe,aACjB,WAAW,QAAQ,KAAK,IAAI;GAE9B;EACF;EAEA,IAAI,eAAe,aACjB,WAAW,iBAAiB,KAAK,IAAI;OAErC,WAAW,MAAM,KAAK,IAAI;CAE9B;CAEA,OAAO;AACT;AAEA,SAAgB,mBAAmB,SAAmC;CACpE,OACE,QAAQ,MAAM,SAAS,KACvB,QAAQ,QAAQ,SAAS,KACzB,QAAQ,iBAAiB,SAAS;AAEtC"}

package/esm/server/page-manifest.d.mts

@@ -1,4 +1,4 @@
-//#region ../web/src/server/page-manifest.d.ts
+//#region web/src/server/page-manifest.d.ts
 /**
  * The build→runtime handoff table for production pages.
  *
@@ -14,18 +14,20 @@
  * `@warlock.js/web`.
  *
  * Entries carry MODULES + FILESYSTEM FACTS ONLY — never route paths. A page's
- * route is read off its module (`route` export) at boot and composed with its
- * layout `prefix`, exactly as `install-page-routes.ts:123-129,213-221` does in
- * dev, so explicit-wins semantics live in one place for both modes.
+ * route is read off its module (`route` export) at boot and, when present,
+ * composed with its layout `prefix`; when absent, the path is instead derived
+ * from the page's own `sourceFile` and its layouts' prefixes, exactly as
+ * `install-page-routes.ts:377-382` does in dev and `discover-pages.ts:925-935`
+ * does at build — so explicit-wins semantics live in one place for all three.
  */
 type PageManifestLayoutEntry = {
-  /** The imported layout module namespace object (default export = component, optional `prefix`). */module: Record<string, unknown>; /** App-root-relative POSIX source path, e.g. "src/app/main/web/layout.tsx". */
+  /** The imported layout module namespace object (default export = component, optional `prefix`). */module: Record<string, unknown>; /** App-root-relative POSIX source path, e.g. "src/web/layout.tsx". */
   sourceFile: string;
 };
 type PageManifestPageEntry = {
   /** The imported page module namespace object (default export = component, optional `route`). */module: Record<string, unknown>;
   /**
-   * App-root-relative POSIX source path, e.g. "src/app/main/web/home.page.tsx"
+   * App-root-relative POSIX source path, e.g. "src/web/home.page.tsx"
    * — feeds FS-derived route/name fallback. The anchor is the APP ROOT, not the
    * repo root; the two differ the moment the app does not sit at the repo root.
    * Consumers compare these ids VERBATIM — the barrel that wrote them is the
@@ -35,6 +37,11 @@ type PageManifestPageEntry = {
   sourceFile: string; /** Layout chain, outermost first. */
   layouts: readonly PageManifestLayoutEntry[];
 };
+/** The optional application error boundary, kept outside the routable page table. */
+type PageManifestErrorPageEntry = {
+  module: Record<string, unknown>;
+  sourceFile: string;
+};
 type PageManifest = {
   /**
    * Where the client bundle was written, as an APP-ROOT-RELATIVE POSIX path
@@ -50,11 +57,18 @@ type PageManifest = {
    * `WarlockConfig not loaded` during connector boot, taking the whole server
    * down before it could listen.
    *
-   * OPTIONAL for the same reason `app` is: a zero-page build skips the client
-   * bundle entirely, so there is no directory to name. Present whenever
-   * `pages` is non-empty.
+   * OPTIONAL only when the build has neither pages nor public files. A
+   * zero-page build skips the hydration bundle, but still names this directory
+   * when it copied app-owned `public/` files below it. Present whenever
+   * `pages` or `publicFiles` is non-empty.
    */
   clientDir?: string;
+  /**
+   * App-public file paths copied below `<clientDir>/public`, relative and
+   * POSIX. Production registers these exact URLs; it never mounts the client
+   * root and therefore never exposes `.vite/manifest.json`.
+   */
+  publicFiles?: readonly string[];
   /**
    * The application root component every page renders inside.
    *
@@ -69,7 +83,8 @@ type PageManifest = {
   app?: {
     module: Record<string, unknown>;
     sourceFile: string;
-  };
+  }; /** An application-owned error boundary. It has no route name or path. */
+  errorPage?: PageManifestErrorPageEntry;
   /**
    * The page table. EMPTY IS A REAL STATE, not a missing one: an empty array
    * means "this bundle was built with web, and it has no pages", which is what

package/esm/server/page-manifest.mjs

@@ -1,4 +1,4 @@
-//#region ../web/src/server/page-manifest.ts
+//#region web/src/server/page-manifest.ts
 let providedManifest;
 /**
 * Called exactly once by the generated production/pages.ts barrel.

package/esm/server/page-manifest.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"page-manifest.mjs","names":[],"sources":["../../../../../../../web/src/server/page-manifest.ts"],"sourcesContent":["/**\n * The build→runtime handoff table for production pages.\n *\n * The generated `<productionDir>/pages.ts` barrel — written by\n * `web/src/build/generate-pages-barrel.ts` — statically imports every page,\n * layout and the app root, then calls {@link providePageManifest} exactly\n * once. The connector reads it back at boot with {@link consumePageManifest}.\n *\n * DEPENDENCY-FREE ON PURPOSE: this module is re-exported from web's root\n * barrel (`web/src/index.ts`) so the generated barrel — which lives in the\n * consuming app's production dir — can reach it by package specifier. Adding\n * an import here would add that import to every app that loads\n * `@warlock.js/web`.\n *\n * Entries carry MODULES + FILESYSTEM FACTS ONLY — never route paths. A page's\n * route is read off its module (`route` export) at boot and composed with its\n * layout `prefix`, exactly as `install-page-routes.ts:123-129,213-221` does in\n * dev, so explicit-wins semantics live in one place for both modes.\n */\n\nexport type PageManifestLayoutEntry = {\n  /** The imported layout module namespace object (default export = component, optional `prefix`). */\n  module: Record<string, unknown>;\n  /** App-root-relative POSIX source path, e.g. \"src/app/main/web/layout.tsx\". */\n  sourceFile: string;\n};\n\nexport type PageManifestPageEntry = {\n  /** The imported page module namespace object (default export = component, optional `route`). */\n  module: Record<string, unknown>;\n  /**\n   * App-root-relative POSIX source path, e.g. \"src/app/main/web/home.page.tsx\"\n   * — feeds FS-derived route/name fallback. The anchor is the APP ROOT, not the\n   * repo root; the two differ the moment the app does not sit at the repo root.\n   * Consumers compare these ids VERBATIM — the barrel that wrote them is the\n   * authority on their form, and re-resolving or normalising one on the way in\n   * turns a lookup miss into a silent mis-match.\n   */\n  sourceFile: string;\n  /** Layout chain, outermost first. */\n  layouts: readonly PageManifestLayoutEntry[];\n};\n\nexport type PageManifest = {\n  /**\n   * Where the client bundle was written, as an APP-ROOT-RELATIVE POSIX path\n   * (`\"dist/client\"`). Resolved against the process cwd at boot, the same\n   * anchor `sourceFile` uses.\n   *\n   * BAKED AT BUILD TIME because the runtime has no other way to learn it. The\n   * directory is `<build.outdir>/client`, and `build.outdir` is configurable —\n   * but it lives in `warlock.config.ts`, a BUILD-TIME file that is never\n   * shipped and cannot be loaded by the plain `node dist/app.js` process\n   * `warlock start` spawns. Reading it at runtime through\n   * `resolveBuildConfig()` is what used to throw\n   * `WarlockConfig not loaded` during connector boot, taking the whole server\n   * down before it could listen.\n   *\n   * OPTIONAL for the same reason `app` is: a zero-page build skips the client\n   * bundle entirely, so there is no directory to name. Present whenever\n   * `pages` is non-empty.\n   */\n  clientDir?: string;\n  /**\n   * The application root component every page renders inside.\n   *\n   * OPTIONAL because it is only meaningful when pages exist: a build that\n   * discovered zero pages provides `{ pages: [] }` and has no root to wrap\n   * anything in. The build enforces the other direction — pages without an\n   * app root fail generation — so `app` absent means `pages` is empty. Callers\n   * must still branch on `pages.length` before reading `app`: the invariant is\n   * the generator's, and a consumer that assumes it without checking turns a\n   * malformed manifest into a crash deep in rendering instead of a named error.\n   */\n  app?: { module: Record<string, unknown>; sourceFile: string };\n  /**\n   * The page table. EMPTY IS A REAL STATE, not a missing one: an empty array\n   * means \"this bundle was built with web, and it has no pages\", which is what\n   * separates it from {@link consumePageManifest} returning `undefined`.\n   */\n  pages: readonly PageManifestPageEntry[];\n};\n\nlet providedManifest: PageManifest | undefined;\n\n/**\n * Called exactly once by the generated production/pages.ts barrel.\n *\n * A second call throws: two barrels in one process means either a stale\n * generated file survived into the bundle or the build ran twice, and the\n * second table silently replacing the first is precisely the drift this\n * contract exists to make impossible.\n */\nexport function providePageManifest(manifest: PageManifest): void {\n  if (providedManifest !== undefined) {\n    throw new Error(\n      \"providePageManifest: a page manifest was already provided \" +\n        \"(web/src/server/page-manifest.ts). The generated production/pages.ts barrel \" +\n        \"must run exactly once per process.\",\n    );\n  }\n\n  providedManifest = manifest;\n}\n\n/**\n * Connector-side read (WebConnector.boot, prod mode).\n *\n * `undefined` = no barrel ran → the app was not built with web. A manifest\n * whose `pages` is empty is the OTHER answer — built with web, no pages — and\n * the two are deliberately distinguishable here rather than collapsed into one\n * falsy result. The registry itself never throws on absence — absence is a\n * fact, not an error; the connector branches on MODE (prod: boot error; dev:\n * normal) so `undefined` never means two things at one call site.\n */\nexport function consumePageManifest(): PageManifest | undefined {\n  return providedManifest;\n}\n"],"mappings":";AAmFA,IAAI;;;;;;;;;AAUJ,SAAgB,oBAAoB,UAA8B;CAChE,IAAI,qBAAqB,QACvB,MAAM,IAAI,MACR,0KAGF;CAGF,mBAAmB;AACrB;;;;;;;;;;;AAYA,SAAgB,sBAAgD;CAC9D,OAAO;AACT"}
+{"version":3,"file":"page-manifest.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/page-manifest.ts"],"sourcesContent":["/**\n * The build→runtime handoff table for production pages.\n *\n * The generated `<productionDir>/pages.ts` barrel — written by\n * `web/src/build/generate-pages-barrel.ts` — statically imports every page,\n * layout and the app root, then calls {@link providePageManifest} exactly\n * once. The connector reads it back at boot with {@link consumePageManifest}.\n *\n * DEPENDENCY-FREE ON PURPOSE: this module is re-exported from web's root\n * barrel (`web/src/index.ts`) so the generated barrel — which lives in the\n * consuming app's production dir — can reach it by package specifier. Adding\n * an import here would add that import to every app that loads\n * `@warlock.js/web`.\n *\n * Entries carry MODULES + FILESYSTEM FACTS ONLY — never route paths. A page's\n * route is read off its module (`route` export) at boot and, when present,\n * composed with its layout `prefix`; when absent, the path is instead derived\n * from the page's own `sourceFile` and its layouts' prefixes, exactly as\n * `install-page-routes.ts:377-382` does in dev and `discover-pages.ts:925-935`\n * does at build — so explicit-wins semantics live in one place for all three.\n */\n\nexport type PageManifestLayoutEntry = {\n  /** The imported layout module namespace object (default export = component, optional `prefix`). */\n  module: Record<string, unknown>;\n  /** App-root-relative POSIX source path, e.g. \"src/web/layout.tsx\". */\n  sourceFile: string;\n};\n\nexport type PageManifestPageEntry = {\n  /** The imported page module namespace object (default export = component, optional `route`). */\n  module: Record<string, unknown>;\n  /**\n   * App-root-relative POSIX source path, e.g. \"src/web/home.page.tsx\"\n   * — feeds FS-derived route/name fallback. The anchor is the APP ROOT, not the\n   * repo root; the two differ the moment the app does not sit at the repo root.\n   * Consumers compare these ids VERBATIM — the barrel that wrote them is the\n   * authority on their form, and re-resolving or normalising one on the way in\n   * turns a lookup miss into a silent mis-match.\n   */\n  sourceFile: string;\n  /** Layout chain, outermost first. */\n  layouts: readonly PageManifestLayoutEntry[];\n};\n\n/** The optional application error boundary, kept outside the routable page table. */\nexport type PageManifestErrorPageEntry = {\n  module: Record<string, unknown>;\n  sourceFile: string;\n};\n\nexport type PageManifest = {\n  /**\n   * Where the client bundle was written, as an APP-ROOT-RELATIVE POSIX path\n   * (`\"dist/client\"`). Resolved against the process cwd at boot, the same\n   * anchor `sourceFile` uses.\n   *\n   * BAKED AT BUILD TIME because the runtime has no other way to learn it. The\n   * directory is `<build.outdir>/client`, and `build.outdir` is configurable —\n   * but it lives in `warlock.config.ts`, a BUILD-TIME file that is never\n   * shipped and cannot be loaded by the plain `node dist/app.js` process\n   * `warlock start` spawns. Reading it at runtime through\n   * `resolveBuildConfig()` is what used to throw\n   * `WarlockConfig not loaded` during connector boot, taking the whole server\n   * down before it could listen.\n   *\n   * OPTIONAL only when the build has neither pages nor public files. A\n   * zero-page build skips the hydration bundle, but still names this directory\n   * when it copied app-owned `public/` files below it. Present whenever\n   * `pages` or `publicFiles` is non-empty.\n   */\n  clientDir?: string;\n  /**\n   * App-public file paths copied below `<clientDir>/public`, relative and\n   * POSIX. Production registers these exact URLs; it never mounts the client\n   * root and therefore never exposes `.vite/manifest.json`.\n   */\n  publicFiles?: readonly string[];\n  /**\n   * The application root component every page renders inside.\n   *\n   * OPTIONAL because it is only meaningful when pages exist: a build that\n   * discovered zero pages provides `{ pages: [] }` and has no root to wrap\n   * anything in. The build enforces the other direction — pages without an\n   * app root fail generation — so `app` absent means `pages` is empty. Callers\n   * must still branch on `pages.length` before reading `app`: the invariant is\n   * the generator's, and a consumer that assumes it without checking turns a\n   * malformed manifest into a crash deep in rendering instead of a named error.\n   */\n  app?: { module: Record<string, unknown>; sourceFile: string };\n  /** An application-owned error boundary. It has no route name or path. */\n  errorPage?: PageManifestErrorPageEntry;\n  /**\n   * The page table. EMPTY IS A REAL STATE, not a missing one: an empty array\n   * means \"this bundle was built with web, and it has no pages\", which is what\n   * separates it from {@link consumePageManifest} returning `undefined`.\n   */\n  pages: readonly PageManifestPageEntry[];\n};\n\nlet providedManifest: PageManifest | undefined;\n\n/**\n * Called exactly once by the generated production/pages.ts barrel.\n *\n * A second call throws: two barrels in one process means either a stale\n * generated file survived into the bundle or the build ran twice, and the\n * second table silently replacing the first is precisely the drift this\n * contract exists to make impossible.\n */\nexport function providePageManifest(manifest: PageManifest): void {\n  if (providedManifest !== undefined) {\n    throw new Error(\n      \"providePageManifest: a page manifest was already provided \" +\n        \"(web/src/server/page-manifest.ts). The generated production/pages.ts barrel \" +\n        \"must run exactly once per process.\",\n    );\n  }\n\n  providedManifest = manifest;\n}\n\n/**\n * Connector-side read (WebConnector.boot, prod mode).\n *\n * `undefined` = no barrel ran → the app was not built with web. A manifest\n * whose `pages` is empty is the OTHER answer — built with web, no pages — and\n * the two are deliberately distinguishable here rather than collapsed into one\n * falsy result. The registry itself never throws on absence — absence is a\n * fact, not an error; the connector branches on MODE (prod: boot error; dev:\n * normal) so `undefined` never means two things at one call site.\n */\nexport function consumePageManifest(): PageManifest | undefined {\n  return providedManifest;\n}\n"],"mappings":";AAoGA,IAAI;;;;;;;;;AAUJ,SAAgB,oBAAoB,UAA8B;CAChE,IAAI,qBAAqB,QACvB,MAAM,IAAI,MACR,0KAGF;CAGF,mBAAmB;AACrB;;;;;;;;;;;AAYA,SAAgB,sBAAgD;CAC9D,OAAO;AACT"}

package/esm/server/page-render-bundle.mjs

@@ -0,0 +1,38 @@
+//#region web/src/server/page-render-bundle.ts
+/**
+* The internal, non-serializable marker `renderPageFailure` (render-page.ts)
+* sets on its bundle AND on the document payload it hands to
+* `DocumentContext` — never on anything `finishRender` produces.
+*
+* `renderPageFailure` runs when a module-load or registration throw happens
+* BEFORE any page/layout/app triple exists — there is no trustworthy server
+* composition for the browser to hydrate against, unlike a normal app-owned
+* `error.page.tsx` reached through `finishRender`, which renders inside a
+* real triple and stays hydratable. Marking both the bundle (read by
+* `create-page-route-handler.ts`'s catch path to skip the hydration module)
+* and the payload (read by `<Scripts/>` to skip `__WARLOCK_DATA__`) lets both
+* call sites agree from the SAME flag instead of two independent guesses.
+*
+* A `Symbol`, non-enumerable, and never part of any exported type: nothing
+* that serializes or spreads these objects (`JSON.stringify`, `{ ...x }`) can
+* observe or carry it forward — only `isNonHydrating` reads it, and only
+* `markNonHydrating` writes it.
+*/
+const NON_HYDRATING = Symbol("warlock.web/non-hydrating");
+/** Set only by `renderPageFailure` — see the module doc above. */
+function markNonHydrating(target) {
+	Object.defineProperty(target, NON_HYDRATING, {
+		value: true,
+		enumerable: false,
+		configurable: true
+	});
+	return target;
+}
+/** Read by `create-page-route-handler.ts` and `<Scripts/>` — see the module doc above. */
+function isNonHydrating(target) {
+	return target !== void 0 && target[NON_HYDRATING] === true;
+}
+
+//#endregion
+export { isNonHydrating, markNonHydrating };
+//# sourceMappingURL=page-render-bundle.mjs.map

package/esm/server/page-render-bundle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-render-bundle.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/page-render-bundle.ts"],"sourcesContent":["/**\n * The internal, non-serializable marker `renderPageFailure` (render-page.ts)\n * sets on its bundle AND on the document payload it hands to\n * `DocumentContext` — never on anything `finishRender` produces.\n *\n * `renderPageFailure` runs when a module-load or registration throw happens\n * BEFORE any page/layout/app triple exists — there is no trustworthy server\n * composition for the browser to hydrate against, unlike a normal app-owned\n * `error.page.tsx` reached through `finishRender`, which renders inside a\n * real triple and stays hydratable. Marking both the bundle (read by\n * `create-page-route-handler.ts`'s catch path to skip the hydration module)\n * and the payload (read by `<Scripts/>` to skip `__WARLOCK_DATA__`) lets both\n * call sites agree from the SAME flag instead of two independent guesses.\n *\n * A `Symbol`, non-enumerable, and never part of any exported type: nothing\n * that serializes or spreads these objects (`JSON.stringify`, `{ ...x }`) can\n * observe or carry it forward — only `isNonHydrating` reads it, and only\n * `markNonHydrating` writes it.\n */\nconst NON_HYDRATING = Symbol(\"warlock.web/non-hydrating\");\n\ntype MarkedNonHydrating = {\n  readonly [NON_HYDRATING]?: true;\n};\n\n/** Set only by `renderPageFailure` — see the module doc above. */\nexport function markNonHydrating<T extends object>(target: T): T {\n  Object.defineProperty(target, NON_HYDRATING, {\n    value: true,\n    enumerable: false,\n    configurable: true,\n  });\n\n  return target;\n}\n\n/** Read by `create-page-route-handler.ts` and `<Scripts/>` — see the module doc above. */\nexport function isNonHydrating(target: object | undefined): boolean {\n  return target !== undefined && (target as MarkedNonHydrating)[NON_HYDRATING] === true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,MAAM,gBAAgB,OAAO,2BAA2B;;AAOxD,SAAgB,iBAAmC,QAAc;CAC/D,OAAO,eAAe,QAAQ,eAAe;EAC3C,OAAO;EACP,YAAY;EACZ,cAAc;CAChB,CAAC;CAED,OAAO;AACT;;AAGA,SAAgB,eAAe,QAAqC;CAClE,OAAO,WAAW,UAAc,OAA8B,mBAAmB;AACnF"}

package/esm/server/page-route-reload.mjs

@@ -0,0 +1,54 @@
+import { isNotFoundPageFile } from "./not-found-page.mjs";
+import { resolvePageRouteIdentity } from "./install-page-routes.mjs";
+import { isErrorPageFilePath } from "./page-file-change.mjs";
+import path from "node:path";
+
+//#region web/src/server/page-route-reload.ts
+function pathKey(file) {
+	const normalized = path.resolve(file).replace(/\\/g, "/");
+	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+/**
+* Every real page file currently represented in the route table. This includes
+* a custom `404.page.tsx`, which is intentionally absent from the public page
+* table because it has no linkable URL of its own.
+*/
+function registeredPageFiles(routes, appSrcRoot) {
+	const sourceRoot = path.dirname(appSrcRoot);
+	return [...new Set(routes.filter((route) => route.isPage && route.sourceFile && !route.sourceFile.startsWith("\0")).map((route) => path.resolve(sourceRoot, route.sourceFile)))];
+}
+/** Exact route-source owners replaced by a live page-table transaction. */
+function pageRouteSourceFiles(routes) {
+	return [...new Set(routes.filter((route) => route.isPage && route.sourceFile).map((route) => route.sourceFile))];
+}
+/**
+* Inspect only in-place page edits. Vite's SSR graph is invalidated explicitly
+* before evaluation because core's file watcher and Vite's watcher have no
+* ordering contract. Component-only edits compare equal and stay in Fast
+* Refresh; route/name changes request an atomic table replacement.
+*/
+async function pageRoutesNeedReplacement(changes, options) {
+	let replace = changes.added.length > 0 || changes.removed.length > 0;
+	const installedByFile = new Map(options.installedPages.map((page) => [pathKey(page.file), page]));
+	for (const file of changes.inspectionNeeded) {
+		if (isErrorPageFilePath(file)) return true;
+		options.vite.environments.ssr.moduleGraph.onFileChange(file);
+		const pageModule = await options.vite.ssrLoadModule(file);
+		if (isNotFoundPageFile(file)) {
+			if (pageModule.route !== void 0) replace = true;
+			continue;
+		}
+		const installed = installedByFile.get(pathKey(file));
+		if (installed === void 0) {
+			replace = true;
+			continue;
+		}
+		const next = resolvePageRouteIdentity(pageModule.route, file, options.appSrcRoot);
+		if (next.declaredPath !== installed.declaredPath || next.name !== installed.name) replace = true;
+	}
+	return replace;
+}
+
+//#endregion
+export { pageRouteSourceFiles, pageRoutesNeedReplacement, registeredPageFiles };
+//# sourceMappingURL=page-route-reload.mjs.map

package/esm/server/page-route-reload.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-route-reload.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/page-route-reload.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { Router } from \"@warlock.js/core\";\nimport type { ViteDevServer } from \"vite\";\nimport type { InstalledPageRoute, PageModuleShape } from \"./install-page-routes\";\nimport { resolvePageRouteIdentity } from \"./install-page-routes\";\nimport { isNotFoundPageFile } from \"./not-found-page\";\nimport type { PageFileChanges } from \"./page-file-change\";\nimport { isErrorPageFilePath } from \"./page-file-change\";\n\nfunction pathKey(file: string): string {\n  const normalized = path.resolve(file).replace(/\\\\/g, \"/\");\n\n  return process.platform === \"win32\" ? normalized.toLowerCase() : normalized;\n}\n\n/**\n * Every real page file currently represented in the route table. This includes\n * a custom `404.page.tsx`, which is intentionally absent from the public page\n * table because it has no linkable URL of its own.\n */\nexport function registeredPageFiles(\n  routes: ReturnType<Router[\"list\"]>,\n  appSrcRoot: string,\n): string[] {\n  const sourceRoot = path.dirname(appSrcRoot);\n\n  return [\n    ...new Set(\n      routes\n        .filter((route) => route.isPage && route.sourceFile && !route.sourceFile.startsWith(\"\\0\"))\n        .map((route) => path.resolve(sourceRoot, route.sourceFile)),\n    ),\n  ];\n}\n\n/** Exact route-source owners replaced by a live page-table transaction. */\nexport function pageRouteSourceFiles(routes: ReturnType<Router[\"list\"]>): string[] {\n  return [\n    ...new Set(\n      routes\n        .filter((route) => route.isPage && route.sourceFile)\n        .map((route) => route.sourceFile),\n    ),\n  ];\n}\n\n/**\n * Inspect only in-place page edits. Vite's SSR graph is invalidated explicitly\n * before evaluation because core's file watcher and Vite's watcher have no\n * ordering contract. Component-only edits compare equal and stay in Fast\n * Refresh; route/name changes request an atomic table replacement.\n */\nexport async function pageRoutesNeedReplacement(\n  changes: PageFileChanges,\n  options: {\n    vite: ViteDevServer;\n    appSrcRoot: string;\n    installedPages: readonly InstalledPageRoute[];\n  },\n): Promise<boolean> {\n  let replace = changes.added.length > 0 || changes.removed.length > 0;\n\n  const installedByFile = new Map(\n    options.installedPages.map((page) => [pathKey(page.file), page] as const),\n  );\n\n  for (const file of changes.inspectionNeeded) {\n    // An error boundary has no installed router route to compare against. Its\n    // namespace is projected into every client composition, so any edit must\n    // replace the generated table; do not load it here just to inspect it.\n    if (isErrorPageFilePath(file)) return true;\n\n    options.vite.environments.ssr.moduleGraph.onFileChange(file);\n    const pageModule = (await options.vite.ssrLoadModule(file)) as PageModuleShape;\n\n    // A valid 404 page has no route identity. Its component body remains Vite\n    // HMR territory; adding an illegal route export must still enter the\n    // transaction so the installer can reject it without touching live routes.\n    if (isNotFoundPageFile(file)) {\n      if (pageModule.route !== undefined) replace = true;\n      continue;\n    }\n\n    const installed = installedByFile.get(pathKey(file));\n    if (installed === undefined) {\n      replace = true;\n      continue;\n    }\n\n    const next = resolvePageRouteIdentity(pageModule.route, file, options.appSrcRoot);\n    if (next.declaredPath !== installed.declaredPath || next.name !== installed.name) {\n      replace = true;\n    }\n  }\n\n  return replace;\n}\n"],"mappings":";;;;;;AASA,SAAS,QAAQ,MAAsB;CACrC,MAAM,aAAa,KAAK,QAAQ,IAAI,EAAE,QAAQ,OAAO,GAAG;CAExD,OAAO,QAAQ,aAAa,UAAU,WAAW,YAAY,IAAI;AACnE;;;;;;AAOA,SAAgB,oBACd,QACA,YACU;CACV,MAAM,aAAa,KAAK,QAAQ,UAAU;CAE1C,OAAO,CACL,GAAG,IAAI,IACL,OACG,QAAQ,UAAU,MAAM,UAAU,MAAM,cAAc,CAAC,MAAM,WAAW,WAAW,IAAI,CAAC,EACxF,KAAK,UAAU,KAAK,QAAQ,YAAY,MAAM,UAAU,CAAC,CAC9D,CACF;AACF;;AAGA,SAAgB,qBAAqB,QAA8C;CACjF,OAAO,CACL,GAAG,IAAI,IACL,OACG,QAAQ,UAAU,MAAM,UAAU,MAAM,UAAU,EAClD,KAAK,UAAU,MAAM,UAAU,CACpC,CACF;AACF;;;;;;;AAQA,eAAsB,0BACpB,SACA,SAKkB;CAClB,IAAI,UAAU,QAAQ,MAAM,SAAS,KAAK,QAAQ,QAAQ,SAAS;CAEnE,MAAM,kBAAkB,IAAI,IAC1B,QAAQ,eAAe,KAAK,SAAS,CAAC,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAU,CAC1E;CAEA,KAAK,MAAM,QAAQ,QAAQ,kBAAkB;EAI3C,IAAI,oBAAoB,IAAI,GAAG,OAAO;EAEtC,QAAQ,KAAK,aAAa,IAAI,YAAY,aAAa,IAAI;EAC3D,MAAM,aAAc,MAAM,QAAQ,KAAK,cAAc,IAAI;EAKzD,IAAI,mBAAmB,IAAI,GAAG;GAC5B,IAAI,WAAW,UAAU,QAAW,UAAU;GAC9C;EACF;EAEA,MAAM,YAAY,gBAAgB,IAAI,QAAQ,IAAI,CAAC;EACnD,IAAI,cAAc,QAAW;GAC3B,UAAU;GACV;EACF;EAEA,MAAM,OAAO,yBAAyB,WAAW,OAAO,MAAM,QAAQ,UAAU;EAChF,IAAI,KAAK,iBAAiB,UAAU,gBAAgB,KAAK,SAAS,UAAU,MAC1E,UAAU;CAEd;CAEA,OAAO;AACT"}

package/esm/server/register-production-public-files.mjs

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+
+//#region web/src/server/register-production-public-files.ts
+var InvalidProductionPublicFileError = class extends Error {
+	constructor(publicFile) {
+		super(`Cannot register production public file ${JSON.stringify(publicFile)}: the build manifest must contain a non-empty relative POSIX path with no traversal segments.`);
+		this.name = "InvalidProductionPublicFileError";
+	}
+};
+var MissingProductionPublicFileError = class extends Error {
+	constructor(publicFile, absoluteFile) {
+		super(`Cannot register production public file ${JSON.stringify(publicFile)}: the successful build manifest recorded it, but ${JSON.stringify(absoluteFile)} is missing or not a file. Run \`warlock build\` again to replace the incomplete artifact.`);
+		this.name = "MissingProductionPublicFileError";
+	}
+};
+function assertRelativePublicFile(publicFile) {
+	const segments = publicFile.split("/");
+	if (publicFile.length === 0 || publicFile.startsWith("/") || publicFile.includes("\\") || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) throw new InvalidProductionPublicFileError(publicFile);
+	return segments;
+}
+/** Register the exact app-public files recorded by the successful build. */
+function registerProductionPublicFiles(router, clientDir, publicFiles) {
+	const publicRoot = path.join(clientDir, "public");
+	for (const publicFile of publicFiles) {
+		const absoluteFile = path.join(publicRoot, ...assertRelativePublicFile(publicFile));
+		let stat;
+		try {
+			stat = fs.statSync(absoluteFile);
+		} catch {
+			throw new MissingProductionPublicFileError(publicFile, absoluteFile);
+		}
+		if (!stat.isFile()) throw new MissingProductionPublicFileError(publicFile, absoluteFile);
+		router.file(`/${publicFile}`, absoluteFile);
+	}
+}
+
+//#endregion
+export { registerProductionPublicFiles };
+//# sourceMappingURL=register-production-public-files.mjs.map

package/esm/server/register-production-public-files.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-production-public-files.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/register-production-public-files.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport type { Router } from \"@warlock.js/core\";\n\nexport class InvalidProductionPublicFileError extends Error {\n  public constructor(publicFile: string) {\n    super(\n      `Cannot register production public file ${JSON.stringify(publicFile)}: ` +\n        \"the build manifest must contain a non-empty relative POSIX path with no \" +\n        \"traversal segments.\",\n    );\n    this.name = \"InvalidProductionPublicFileError\";\n  }\n}\n\nexport class MissingProductionPublicFileError extends Error {\n  public constructor(publicFile: string, absoluteFile: string) {\n    super(\n      `Cannot register production public file ${JSON.stringify(publicFile)}: ` +\n        \"the successful build manifest recorded it, but \" +\n        `${JSON.stringify(absoluteFile)} is missing or not a file. ` +\n        \"Run `warlock build` again to replace the incomplete artifact.\",\n    );\n    this.name = \"MissingProductionPublicFileError\";\n  }\n}\n\nfunction assertRelativePublicFile(publicFile: string): string[] {\n  const segments = publicFile.split(\"/\");\n\n  if (\n    publicFile.length === 0 ||\n    publicFile.startsWith(\"/\") ||\n    publicFile.includes(\"\\\\\") ||\n    segments.some((segment) => segment.length === 0 || segment === \".\" || segment === \"..\")\n  ) {\n    throw new InvalidProductionPublicFileError(publicFile);\n  }\n\n  return segments;\n}\n\n/** Register the exact app-public files recorded by the successful build. */\nexport function registerProductionPublicFiles(\n  router: Router,\n  clientDir: string,\n  publicFiles: readonly string[],\n): void {\n  const publicRoot = path.join(clientDir, \"public\");\n\n  for (const publicFile of publicFiles) {\n    const absoluteFile = path.join(publicRoot, ...assertRelativePublicFile(publicFile));\n\n    let stat: fs.Stats;\n\n    try {\n      stat = fs.statSync(absoluteFile);\n    } catch {\n      throw new MissingProductionPublicFileError(publicFile, absoluteFile);\n    }\n\n    if (!stat.isFile()) {\n      throw new MissingProductionPublicFileError(publicFile, absoluteFile);\n    }\n\n    router.file(`/${publicFile}`, absoluteFile);\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,mCAAb,cAAsD,MAAM;CAC1D,AAAO,YAAY,YAAoB;EACrC,MACE,0CAA0C,KAAK,UAAU,UAAU,EAAE,8FAGvE;EACA,KAAK,OAAO;CACd;AACF;AAEA,IAAa,mCAAb,cAAsD,MAAM;CAC1D,AAAO,YAAY,YAAoB,cAAsB;EAC3D,MACE,0CAA0C,KAAK,UAAU,UAAU,EAAE,mDAEhE,KAAK,UAAU,YAAY,EAAE,2FAEpC;EACA,KAAK,OAAO;CACd;AACF;AAEA,SAAS,yBAAyB,YAA8B;CAC9D,MAAM,WAAW,WAAW,MAAM,GAAG;CAErC,IACE,WAAW,WAAW,KACtB,WAAW,WAAW,GAAG,KACzB,WAAW,SAAS,IAAI,KACxB,SAAS,MAAM,YAAY,QAAQ,WAAW,KAAK,YAAY,OAAO,YAAY,IAAI,GAEtF,MAAM,IAAI,iCAAiC,UAAU;CAGvD,OAAO;AACT;;AAGA,SAAgB,8BACd,QACA,WACA,aACM;CACN,MAAM,aAAa,KAAK,KAAK,WAAW,QAAQ;CAEhD,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,eAAe,KAAK,KAAK,YAAY,GAAG,yBAAyB,UAAU,CAAC;EAElF,IAAI;EAEJ,IAAI;GACF,OAAO,GAAG,SAAS,YAAY;EACjC,QAAQ;GACN,MAAM,IAAI,iCAAiC,YAAY,YAAY;EACrE;EAEA,IAAI,CAAC,KAAK,OAAO,GACf,MAAM,IAAI,iCAAiC,YAAY,YAAY;EAGrE,OAAO,KAAK,IAAI,cAAc,YAAY;CAC5C;AACF"}

package/esm/server/render-page.d.mts

@@ -1,11 +1,14 @@
 import { PAYLOAD_SCRIPT_ID, escapePayload } from "../components/document-context.mjs";
-import { BufferedCookie } from "./buffered-response.mjs";
+import { BufferedCookie } from "./settle-page-response.mjs";
 import { ExecutePageRequestOptions, PageDataBundle, PageRouteEntry } from "./execute-page-request.types.mjs";
-//#region ../web/src/server/render-page.d.ts
+import { ErrorPageModuleLoader } from "./error-page.mjs";
+import { Request, Response } from "@warlock.js/core";
+
+//#region web/src/server/render-page.d.ts
 /**
  * Pipeline stages 9–10: RENDER the page tree from the
  * data bundle stages 1–8 produced, then return finalized { html, status,
- * headers, cookies }. Stage 10 happens at the CALL SITE in two halves —
+ * headers }. Stage 10 happens at the CALL SITE in two halves —
  * 10a the caller applies status + headers (the single live-response write,
  * after render, before anything flushes), 10b it flushes
  * the document. Nothing in this module writes the live response. It never
@@ -39,7 +42,8 @@ type RenderPageOptions = {
    */
   as?: unknown; /** Per-call overrides of the connected registry (tests, mostly). */
   routes?: readonly PageRouteEntry[];
-  createHttp?: ExecutePageRequestOptions["createHttp"];
+  createHttp?: ExecutePageRequestOptions["createHttp"]; /** Loaded only after the ordinary boundary chain has been exhausted. */
+  loadErrorPage?: ErrorPageModuleLoader;
 };
 /**
  * `renderPageRequest` takes the URL itself, so `params`/`query` (the
@@ -50,14 +54,7 @@ type RenderPageRequestOptions = Omit<RenderPageOptions, "params" | "query">;
 type RenderedPage = {
   /** The full document ("" when the pipeline short-circuited before render). */html: string;
   status: number; /** Committed response headers, lowercased key → value. */
-  headers: Record<string, string>;
-  /**
-   * Committed cookies in commit order, attribute-faithful: each entry carries
-   * the loader's raw value (pre-serialization) AND its options
-   * (`httpOnly`/`secure`/`sameSite`/`path`/`expires`/…). Never flattened to a
-   * name→value map — a map cannot express the attributes, and a Set-Cookie
-   * built without them is a security defect, not a convenience.
-   */
+  headers: Record<string, string>; /** Committed response cookies, in commit order — stage 7's `bundle.commit.cookies`. */
   cookies: BufferedCookie[];
   /**
    * The PAGE loader's data — `data.product.name` reads as the dx story
@@ -72,7 +69,7 @@ type RenderedPage = {
    */
   bundle: PageDataBundle | undefined;
 };
-declare function renderPage(routeName: string, options?: RenderPageOptions): Promise<RenderedPage>;
+declare function renderPage(routeName: string, options?: RenderPageOptions): Promise<RenderedPage | Response>;
 /**
  * The URL-based sibling of `renderPage` — the production render surface: a
  * real HTTP server has a URL, not a route name. The url goes STRAIGHT to
@@ -83,7 +80,7 @@ declare function renderPage(routeName: string, options?: RenderPageOptions): Pro
  * URL matching no route is a legitimate 404, and a server must ANSWER it —
  * `{ html: "", status: 404 }` with an undefined `bundle` (see RenderedPage).
  */
-declare function renderPageRequest(url: string, options?: RenderPageRequestOptions): Promise<RenderedPage>;
+declare function renderPageRequest(url: string, options?: RenderPageRequestOptions): Promise<RenderedPage | Response>;
 //#endregion
 export { PageRoutesRegistry, RenderPageOptions, RenderPageRequestOptions, RenderedPage, connectPageRoutes, renderPage, renderPageRequest };
 //# sourceMappingURL=render-page.d.mts.map