@warlock.js/web 5.1.0 → 5.2.0

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

package/esm/server/render-page.mjs

@@ -1,11 +1,26 @@
 import { DocumentContext, PAYLOAD_SCRIPT_ID, escapePayload } from "../components/document-context.mjs";
+import { markNonHydrating } from "./page-render-bundle.mjs";
+import { registerModules } from "../runtime/register-modules.mjs";
 import DefaultApp from "../components/default-app.mjs";
 import { buildHydrationPayload } from "./build-hydration-payload.mjs";
+import { ERROR_PAGE_METADATA } from "./resolve-page-metadata.mjs";
+import { hydrationErrorPageProps, resolveErrorPageMetadata } from "./error-page.mjs";
 import { buildErrorRecord, designateBoundary } from "./settle-page-response.mjs";
 import { executePageRequest } from "./execute-page-request.mjs";
 import { createElement } from "react";
+import { Response } from "@warlock.js/core";
 
-//#region ../web/src/server/render-page.ts
+//#region web/src/server/render-page.ts
+/** Reads the stage 7 commit into the lowercased header map `RenderedPage` carries. */
+function committedHeaders(bundle) {
+	const headers = {};
+	for (const header of bundle.commit?.headers ?? []) headers[header.key.toLowerCase()] = header.value;
+	return headers;
+}
+/** Reads the stage 7 commit into the cookie list `RenderedPage` carries. */
+function committedCookies(bundle) {
+	return bundle.commit?.cookies ?? [];
+}
 let pageRoutesRegistry;
 /**
 * Boot-time wiring so `renderPage(name, options)` can resolve a route NAME
@@ -46,6 +61,11 @@ function buildUrl(entry, params, query) {
 function FrameworkRootBoundary() {
 	return createElement("main", { role: "alert" }, "Something went wrong.");
 }
+function errorPageElement(module, props) {
+	const ErrorPage = module.default;
+	if (!ErrorPage) throw new Error("The application error.page.tsx module has no default export.");
+	return createElement(ErrorPage, props);
+}
 const DATA_KEYS = {
 	app: "appData",
 	layout: "layoutData",
@@ -63,7 +83,7 @@ const DATA_KEYS = {
 * with no DOM.
 */
 function buildPageElement(triple, bundle) {
-	return wrapRootward(triple, bundle, "page", buildLeaf(triple.page, bundle, "page"));
+	return wrapRootward(triple, bundle, "page", buildLeaf(triple.page, bundle));
 }
 /**
 * The error path renders the DESIGNATED boundary in place of the level it
@@ -81,12 +101,13 @@ function buildBoundaryElement(triple, bundle, record) {
 	const wrapped = wrapRootward(triple, bundle, boundary.boundaryLevel, element);
 	return boundary.boundaryLevel === "app" ? createElement(DefaultApp, { children: wrapped }) : wrapped;
 }
-function buildLeaf(module, bundle, level) {
+function buildLeaf(module, bundle) {
 	const Component = module.default;
 	if (!Component) return null;
 	return createElement(Component, {
-		data: bundle[DATA_KEYS[level]],
-		shared: bundle.shared
+		data: bundle.pageData,
+		shared: bundle.shared,
+		params: bundle.route.params
 	});
 }
 function wrapRootward(triple, bundle, from, leaf) {
@@ -131,20 +152,12 @@ function capturingCreateHttp(registry, as) {
 		createHttp(match) {
 			state.match = match;
 			state.captured = registry.createHttp(match);
-			if (as !== void 0) state.captured.request.user = as;
+			if (as != null) state.captured.request.user = as;
 			return state.captured;
 		}
 	};
 }
-/**
-* Structural read of the two core `Request` fields the slots need. Neither
-* `nonce` nor `locale` is declared on `PipelineRequest`/`WebRequest` (the
-* loader-facing facade only declares `validated`/`input`/`user`,
-* context.ts:30-68) — a narrow typed intersection at the one call site that
-* needs it, the same pattern `execute-page-request.ts` uses for its own
-* `(response as PipelineResponse & { statusCode?: number })` read
-* (execute-page-request.ts:517).
-*/
+/** Reads document slots directly from core's Request. */
 function documentSlotsFrom(captured) {
 	const request = captured?.request;
 	return {
@@ -152,13 +165,12 @@ function documentSlotsFrom(captured) {
 		lang: request?.locale
 	};
 }
-async function finishRender(triple, bundle, documentSlots) {
-	const headers = {};
-	for (const header of bundle.commit?.headers ?? []) headers[header.key.toLowerCase()] = header.value;
-	const cookies = bundle.commit?.cookies ?? [];
+async function finishRender(triple, bundle, documentSlots, response, loadErrorPage) {
+	const headers = committedHeaders(bundle);
+	const cookies = committedCookies(bundle);
 	if (bundle.shortCircuit) return {
 		html: "",
-		status: bundle.shortCircuit.stage === "validation" ? bundle.shortCircuit.status : bundle.shortCircuit.stage === "loaders" ? bundle.shortCircuit.statusCode : bundle.shortCircuit.statusCode ?? 200,
+		status: bundle.shortCircuit.stage === "validation" ? bundle.shortCircuit.status : bundle.shortCircuit.statusCode ?? 200,
 		headers,
 		cookies,
 		data: bundle.pageData,
@@ -166,7 +178,7 @@ async function finishRender(triple, bundle, documentSlots) {
 	};
 	if (headers["cache-control"] === void 0) headers["cache-control"] = "private";
 	const { renderToString } = await import("react-dom/server");
-	const documentValue = {
+	let documentValue = {
 		metadata: bundle.metadata,
 		payload: buildHydrationPayload(bundle),
 		nonce: documentSlots.nonce,
@@ -177,20 +189,58 @@ async function finishRender(triple, bundle, documentSlots) {
 		children: element
 	}));
 	let currentError = bundle.error;
-	let renderTimeThrow = false;
 	let body;
+	const renderFrameworkRoot = () => renderWithContext(createElement(DefaultApp, { children: createElement(FrameworkRootBoundary, {}) }));
+	const renderFrameworkAfterErrorPageFailure = () => {
+		bundle.errorPage = void 0;
+		bundle.metadata = ERROR_PAGE_METADATA;
+		documentValue = {
+			...documentValue,
+			metadata: bundle.metadata,
+			payload: buildHydrationPayload(bundle)
+		};
+		return renderFrameworkRoot();
+	};
+	const renderErrorPage = async (thrown, serializableError = thrown) => {
+		if (!loadErrorPage) return void 0;
+		const props = {
+			error: thrown,
+			status: 500
+		};
+		const module = await loadErrorPage();
+		registerModules([module]);
+		bundle.errorPage = hydrationErrorPageProps(props, serializableError);
+		bundle.metadata = resolveErrorPageMetadata(module, props);
+		documentValue = {
+			...documentValue,
+			metadata: bundle.metadata,
+			payload: buildHydrationPayload(bundle)
+		};
+		return renderWithContext(wrapRootward(triple, bundle, "page", errorPageElement(module, props)));
+	};
 	for (;;) try {
+		if (currentError?.boundary.boundaryLevel === "app" && !triple.app.ErrorBoundary) {
+			try {
+				body = await renderErrorPage(currentError.originalError ?? currentError.error, currentError.error) ?? renderFrameworkRoot();
+			} catch {
+				body = renderFrameworkAfterErrorPageFailure();
+			}
+			break;
+		}
 		body = renderWithContext(currentError ? buildBoundaryElement(triple, bundle, currentError) : buildPageElement(triple, bundle));
 		break;
 	} catch (thrown) {
-		renderTimeThrow = true;
 		if (currentError?.boundary.boundaryLevel === "app") {
-			body = renderWithContext(createElement(DefaultApp, { children: createElement(FrameworkRootBoundary, {}) }));
+			try {
+				body = await renderErrorPage(thrown) ?? renderFrameworkRoot();
+			} catch {
+				body = renderFrameworkAfterErrorPageFailure();
+			}
 			break;
 		}
 		currentError = buildErrorRecord(thrown, designateBoundary(currentError?.boundary.boundaryLevel === "layout" ? "app" : currentError ? "layout" : "page", triple));
 	}
-	const status = renderTimeThrow ? currentError.boundary.boundaryLevel === "app" ? 500 : bundle.commit?.statusCode ?? 200 : bundle.error ? bundle.commit?.statusCode ?? 500 : bundle.commit?.statusCode ?? 200;
+	const status = currentError ? 500 : bundle.commit?.statusCode ?? 200;
 	return {
 		html: emitDocument(body),
 		status,
@@ -200,6 +250,82 @@ async function finishRender(triple, bundle, documentSlots) {
 		bundle
 	};
 }
+/**
+* Render failures that happen before the page pipeline has a triple (notably a
+* module-load or registration throw). This deliberately owns one terminal
+* attempt: an error-page failure falls straight to FrameworkRootBoundary.
+*
+* There is no triple yet, so there is no trustworthy server composition for
+* the browser to hydrate against — every response this function produces is
+* marked `markNonHydrating` (page-render-bundle.ts), on both the bundle and
+* the document payload, whether or not it managed to render the app's own
+* `error.page.tsx`. A normal app error page reached through `finishRender`
+* renders inside a real triple and stays hydratable; this path never does.
+*/
+async function renderPageFailure(options) {
+	const { request, response, name, path, thrown, loadErrorPage } = options;
+	const bundle = markNonHydrating({ route: {
+		name,
+		path,
+		params: {},
+		query: {}
+	} });
+	const headers = { "cache-control": "private" };
+	const { renderToString } = await import("react-dom/server");
+	const slots = documentSlotsFrom({
+		request,
+		response
+	});
+	const frameworkPayload = markNonHydrating(buildHydrationPayload(bundle));
+	let value = {
+		metadata: void 0,
+		payload: frameworkPayload,
+		nonce: slots.nonce,
+		lang: slots.lang
+	};
+	const renderWithContext = (element) => renderToString(createElement(DocumentContext.Provider, {
+		value,
+		children: element
+	}));
+	let body;
+	try {
+		if (!loadErrorPage) throw new Error("No application error page is configured.");
+		const props = {
+			error: thrown,
+			status: 500
+		};
+		const module = await loadErrorPage();
+		registerModules([module]);
+		const errorPage = hydrationErrorPageProps(props);
+		bundle.errorPage = errorPage;
+		value = {
+			...value,
+			metadata: resolveErrorPageMetadata(module, props),
+			payload: markNonHydrating({
+				...frameworkPayload,
+				errorPage
+			})
+		};
+		body = renderWithContext(createElement(DefaultApp, { children: errorPageElement(module, props) }));
+	} catch {
+		bundle.errorPage = void 0;
+		bundle.metadata = ERROR_PAGE_METADATA;
+		value = {
+			...value,
+			metadata: bundle.metadata,
+			payload: markNonHydrating(buildHydrationPayload(bundle))
+		};
+		body = renderWithContext(createElement(DefaultApp, { children: createElement(FrameworkRootBoundary, {}) }));
+	}
+	return {
+		html: emitDocument(body),
+		status: 500,
+		headers,
+		cookies: [],
+		data: void 0,
+		bundle
+	};
+}
 async function renderPage(routeName, options = {}) {
 	const registry = requireRegistry(options);
 	const entry = registry.routes.find((candidate) => candidate.name === routeName);
@@ -213,7 +339,7 @@ async function renderPage(routeName, options = {}) {
 		url,
 		routes: registry.routes,
 		createHttp,
-		finish: (bundle) => finishRender(entry.triple, bundle, documentSlotsFrom(state.captured))
+		finish: (bundle) => finishRender(entry.triple, bundle, documentSlotsFrom(state.captured), state.captured.response, options.loadErrorPage)
 	});
 	if (!rendered) throw new Error(`renderPage("${routeName}"): the built URL "${url}" did not match stage 1 (web/src/server/render-page.ts). The name resolved but the matcher disagreed — that is a manifest bug, not a caller bug.`);
 	return rendered;
@@ -235,7 +361,7 @@ async function renderPageRequest(url, options = {}) {
 		url,
 		routes: registry.routes,
 		createHttp,
-		finish: (bundle) => finishRender(state.match.entry.triple, bundle, documentSlotsFrom(state.captured))
+		finish: (bundle) => finishRender(state.match.entry.triple, bundle, documentSlotsFrom(state.captured), state.captured.response, options.loadErrorPage)
 	});
 	if (!rendered) return {
 		html: "",
@@ -249,5 +375,5 @@ async function renderPageRequest(url, options = {}) {
 }
 
 //#endregion
-export { connectPageRoutes, renderPage, renderPageRequest };
+export { connectPageRoutes, renderPage, renderPageFailure, renderPageRequest };
 //# sourceMappingURL=render-page.mjs.map