@warlock.js/web 5.1.0 → 5.2.0

package/esm/context.d.mts

@@ -1,107 +1,11 @@
 import { SharedContext } from "./index.mjs";
+import { HttpContext, Request } from "@warlock.js/core";
 
-//#region ../web/src/context.d.ts
-/**
- * The brand behind loader short-circuits.
- *
- * Core's `Response#notFound()` / `#redirect()` return an unbranded
- * `Response`/`this` (core/src/http/response.ts:862-866, 1028-1034). The page
- * contract needs those returns to NOT union into `PageProps["data"]`
- * (v5/app/src/app/products/web/product-details.page.tsx:45-57), so web brands
- * them on ITS OWN response surface — the one a loader's context carries —
- * without touching core. `LoaderData` excludes exactly this brand.
- */
-declare const loaderShortCircuit: unique symbol;
-interface LoaderShortCircuit {
-  readonly [loaderShortCircuit]: true;
-}
-/**
- * The request as a loader sees it. Structural and deliberately minimal for M1:
- * exactly the members the v5/app loaders exercise, typed by the page's own
- * `validation` and `route` generics.
- *
- * TODO(Stream A.6 — core ctx migration): once core ships
- * `HttpContext { request, response }` and the declared `request.user` /
- * `request.locals` / `request.nonce`, this narrows to a refinement of core's `Request`
- * instead of a standalone structural type.
- */
-interface WebRequest<TValidated = Record<string, never>, TParams extends string = string> {
-  /**
-   * The validated inputs, typed off the page's `validation.schema` with
-   * `Infer.Output` semantics — `.default()` fields stay required
-   * (v5/app/src/app/auth/schema/login.schema.ts:29-38). The key-list parameter
-   * is optional and selects a subset, mirroring core
-   * (core/src/http/request.ts:610).
-   */
-  validated(inputs?: readonly (keyof TValidated | (string & {}))[]): TValidated;
-  /**
-   * Typed FROM THE ROUTE: `TParams` is derived from the route path literal, so
-   * `request.input("id")` types against `path: "/:id"` and a key that is not a
-   * route parameter is a compile error
-   * (v5/app/src/web/__type-tests__/route-params.type-test.ts).
-   */
-  input(key: TParams, defaultValue?: unknown): string;
-  /**
-   * The authenticated user, when middleware resolved one.
-   *
-   * `any`, deliberately, and recorded as a deviation in the M1 report: the
-   * reference app hands `request.user` to services typed against the APP's own
-   * model (`navService.forUser(user: User)`,
-   * v5/app/src/web/layouts/dashboard.layout.tsx:35) and reads `.id` with no
-   * null-check (settings.page.tsx:65). No type this package can declare is
-   * assignable to an app-owned model class; the real declaration has to come
-   * from core's own `Request.user` and lands with Stream A.6.
-   *
-   * Optional, matching core (`Request.user?`, core/src/http/request.ts:94) —
-   * a required member here would reject core's real `Request` at the seam.
-   * `any` absorbs the `undefined`, so loader-side `request.user.id` reads
-   * keep compiling (the recorded M1 deviation stands).
-   */
-  user?: any;
-}
-/**
- * The response as a loader sees it. A loader may mutate the response during
- * render (headers, status) and may SHORT-CIRCUIT it — the short-circuiting
- * methods return the branded type that never reaches `PageProps["data"]`.
- *
- * TODO(Stream A.6): same story as `WebRequest` — becomes a refinement of
- * core's `Response` once the ctx object lands in core.
- */
-interface WebResponse {
-  /** Buffered, committed in tree order after every loader settles. */
-  header(key: string, value: string): WebResponse;
-  /** The not-found page's loader's real output is the status (not-found.page.tsx:25). */
-  setStatusCode(statusCode: number): WebResponse;
-  /** A short-circuit, not a value — never unions into `data`. */
-  redirect(url: string, statusCode?: number): LoaderShortCircuit;
-  /** 301 flavour of the same short-circuit. */
-  permanentRedirect(url: string): LoaderShortCircuit;
-  /** A 404 is an ANSWER, not an incident (product-details.page.tsx:45-57). */
-  notFound(body?: unknown): LoaderShortCircuit;
-}
-/**
- * The one context object every handler receives.
- *
- * TODO(Stream A.6): core is to OWN `HttpContext { request, response }` and the
- * re-parameterised `Middleware<TContext extends HttpContext>`. Core today has
- * no `HttpContext` and its `Middleware` is positional `(request, response)`
- * (core/src/router/types.ts:17), so importing the type from
- * `@warlock.js/core` cannot resolve to the v5 shape yet — this structural
- * declaration stands in until core declares it.
- */
-interface HttpContext {
-  request: WebRequest;
-  response: WebResponse;
-}
-/**
- * The web layer's context: `HttpContext` plus the per-request payload. The
- * keys are framework-owned and the list is closed — `request`, `response`,
- * `shared`. App data goes on `request.locals` (private) or `shared` (public),
- * never onto the context itself.
- */
-interface PageContext extends HttpContext {
+//#region web/src/context.d.ts
+type HttpContext$1<TRequest extends Request = Request> = HttpContext<TRequest>;
+type PageContext<TRequest extends Request = Request> = HttpContext<TRequest> & {
   shared: SharedContext;
-}
+};
 //#endregion
-export { LoaderShortCircuit, PageContext, WebRequest, WebResponse };
+export { HttpContext$1 as HttpContext, PageContext };
 //# sourceMappingURL=context.d.mts.map

package/esm/hydration/index.mjs

@@ -5,7 +5,7 @@ import { NavigationRoot } from "../client/navigation/navigation-root.mjs";
 import { createElement } from "react";
 import { pages } from "virtual:warlock/pages";
 
-//#region ../web/src/hydration/index.ts
+//#region web/src/hydration/index.ts
 /**
 * The client entry: registry in, hydration out. No page names, no app paths.
 *

package/esm/hydration/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../web/src/hydration/index.ts"],"sourcesContent":["/**\n * The client entry: registry in, hydration out. No page names, no app paths.\n *\n * The page graph arrives from the Vite virtual module the build plugin serves,\n * so this file works for ANY page in ANY app. The previous version imported one\n * page and one layout by relative path into the monorepo's reference app, which\n * both hydrated every URL as the home page and made `@warlock.js/web`\n * uninstallable anywhere outside this checkout. Neither a page name nor an app\n * path appears here now, and nothing about the composition lives here either -\n * that is `buildHydratedTree`, which takes the registry as an argument and is\n * therefore testable without a bundler.\n */\nimport { createElement } from \"react\";\nimport { pages } from \"virtual:warlock/pages\";\nimport { buildHydratedTree } from \"../client/build-hydrated-tree\";\nimport { hydratePage } from \"../client/hydrate-page\";\nimport { NavigationRoot } from \"../client/navigation/navigation-root\";\nimport { publishRouteTable } from \"../routing/route-table\";\n\n/*\n  BEFORE the mount, not after: `<Link>` resolves its URL through the route table\n  during render, and the first render is the hydration render. Publishing\n  afterwards would make every anchor in the initial tree throw.\n\n  The registry entries already carry `name` and `path` - the same pair the\n  server registered its routes from, out of the same discovery result - so the\n  browser's table cannot drift from the server's without the two being built\n  from different page graphs, which hydration already refuses.\n*/\npublishRouteTable(pages, \"hydration client entry\");\n\n/*\n  The hydrated tree is wrapped in `NavigationRoot` so the page can be REPLACED\n  later without a document load. The first render is still exactly the tree the\n  server produced - `NavigationRoot` renders `initialTree` verbatim and adds no\n  markup of its own - so hydration still matches the server byte for byte, and\n  the wrapper only starts to matter on the first navigation.\n\n  NO MRR HISTORY BRIDGE IS INSTALLED HERE YET, and that is a pending decision\n  rather than an oversight. This runtime drives `window.history` itself and is\n  complete without MRR. Handing history to `@mongez/react-router` as well means\n  `@warlock.js/web` importing it, which puts MRR in the bundle of EVERY app that\n  uses this package - a packaging choice (dependency vs. peer vs. app-level\n  opt-in) with consequences for apps that never navigate through MRR. The bridge\n  itself is written and documented in\n  `conversations/2026-08-24-production-ssr-session.md`; it lands the moment that\n  choice is made.\n*/\nhydratePage(async (payload) => {\n  const tree = await buildHydratedTree(pages, payload);\n\n  return createElement(NavigationRoot, {\n    pages,\n    initialPayload: payload,\n    initialTree: tree,\n    buildTree: buildHydratedTree,\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,kBAAkB,OAAO,wBAAwB;AAmBjD,YAAY,OAAO,YAAY;CAG7B,OAAO,cAAc,gBAAgB;EACnC;EACA,gBAAgB;EAChB,aAAa,MALI,kBAAkB,OAAO,OAAO;EAMjD,WAAW;CACb,CAAC;AACH,CAAC"}
+{"version":3,"file":"index.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/hydration/index.ts"],"sourcesContent":["/**\n * The client entry: registry in, hydration out. No page names, no app paths.\n *\n * The page graph arrives from the Vite virtual module the build plugin serves,\n * so this file works for ANY page in ANY app. The previous version imported one\n * page and one layout by relative path into the monorepo's reference app, which\n * both hydrated every URL as the home page and made `@warlock.js/web`\n * uninstallable anywhere outside this checkout. Neither a page name nor an app\n * path appears here now, and nothing about the composition lives here either -\n * that is `buildHydratedTree`, which takes the registry as an argument and is\n * therefore testable without a bundler.\n */\nimport { createElement } from \"react\";\nimport { pages } from \"virtual:warlock/pages\";\nimport { buildHydratedTree } from \"../client/build-hydrated-tree\";\nimport { hydratePage } from \"../client/hydrate-page\";\nimport { NavigationRoot } from \"../client/navigation/navigation-root\";\nimport { publishRouteTable } from \"../routing/route-table\";\n\n/*\n  BEFORE the mount, not after: `<Link>` resolves its URL through the route table\n  during render, and the first render is the hydration render. Publishing\n  afterwards would make every anchor in the initial tree throw.\n\n  The registry entries already carry `name` and `path` - the same pair the\n  server registered its routes from, out of the same discovery result - so the\n  browser's table cannot drift from the server's without the two being built\n  from different page graphs, which hydration already refuses.\n*/\npublishRouteTable(pages, \"hydration client entry\");\n\n/*\n  The hydrated tree is wrapped in `NavigationRoot` so the page can be REPLACED\n  later without a document load. The first render is still exactly the tree the\n  server produced - `NavigationRoot` renders `initialTree` verbatim and adds no\n  markup of its own - so hydration still matches the server byte for byte, and\n  the wrapper only starts to matter on the first navigation.\n\n  NO MRR HISTORY BRIDGE IS INSTALLED HERE YET, and that is a pending decision\n  rather than an oversight. This runtime drives `window.history` itself and is\n  complete without MRR. Handing history to `@mongez/react-router` as well means\n  `@warlock.js/web` importing it, which puts MRR in the bundle of EVERY app that\n  uses this package - a packaging choice (dependency vs. peer vs. app-level\n  opt-in) with consequences for apps that never navigate through MRR. The bridge\n  itself is written and documented in\n  `conversations/2026-08-24-production-ssr-session.md`; it lands the moment that\n  choice is made.\n*/\nhydratePage(async (payload) => {\n  const tree = await buildHydratedTree(pages, payload);\n\n  return createElement(NavigationRoot, {\n    pages,\n    initialPayload: payload,\n    initialTree: tree,\n    buildTree: buildHydratedTree,\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,kBAAkB,OAAO,wBAAwB;AAmBjD,YAAY,OAAO,YAAY;CAG7B,OAAO,cAAc,gBAAgB;EACnC;EACA,gBAAgB;EAChB,aAAa,MALI,kBAAkB,OAAO,OAAO;EAMjD,WAAW;CACb,CAAC;AACH,CAAC"}

package/esm/hydration-payload.d.mts

@@ -1 +1 @@
-export { };
+import { ErrorPageProps, SerializedErrorPageProps, SerializedPageError } from "./components/document-context.mjs";

package/esm/hydration-payload.mjs

@@ -1,6 +1,6 @@
 import { PAYLOAD_SCRIPT_ID } from "./components/document-context.mjs";
 
-//#region ../web/src/hydration-payload.ts
+//#region web/src/hydration-payload.ts
 /**
 * Exported so a payload-shape assertion can be written against the contract
 * itself. A spec that hardcodes its own copy of this list silently becomes a
@@ -22,11 +22,11 @@ function malformedPayload() {
 /**
 * The keys that are allowed to be ABSENT but not allowed to be wrong.
 *
-* `metadata` and `params` are optional because the server is right not to
+* `metadata`, `params` and `errorPage` are optional because the server is right
 * always produce them — a page with no `metadata` export resolves none, and a
-* payload written by a build that predates these keys carries neither. Failing
-* a whole page over an absent accessor would turn a cosmetic gap into a blank
-* screen, so absence is accepted and the readers default it.
+* older payload carries none of these additions. Failing a whole page over an
+* absent accessor would turn a compatible payload into a blank screen, so
+* absence is accepted.
 *
 * Present-but-not-an-object is a different claim entirely: it means something
 * produced a payload with these names meaning something else, and every reader
@@ -34,10 +34,36 @@ function malformedPayload() {
 * rule the required keys live by, so it throws. Arrays included — `typeof []`
 * is `"object"`, and an array of params is not params.
 */
-const OPTIONAL_OBJECT_PAYLOAD_KEYS = ["metadata", "params"];
+const OPTIONAL_OBJECT_PAYLOAD_KEYS = [
+	"metadata",
+	"params",
+	"errorPage"
+];
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function hasExactStringKeys(value, required, optional = []) {
+	const allowed = new Set([...required, ...optional]);
+	const keys = Reflect.ownKeys(value);
+	return required.every((key) => Object.prototype.hasOwnProperty.call(value, key)) && keys.every((key) => typeof key === "string" && allowed.has(key));
+}
+/**
+* Validate the explicit serialization boundary, not an `Error` instance.
+* `JSON.stringify(new Error("boom"))` is normally `{}` because its useful
+* fields are non-enumerable; accepting that would hydrate an error page with a
+* different contract from the one the server rendered.
+*/
+function requireErrorPagePayload(value) {
+	if (!isPlainObject(value)) malformedPayload();
+	const errorPage = value;
+	if (!hasExactStringKeys(errorPage, ["error", "status"])) malformedPayload();
+	if (!isPlainObject(errorPage.error)) malformedPayload();
+	const error = errorPage.error;
+	if (!hasExactStringKeys(error, ["name", "message"], ["stack"])) malformedPayload();
+	if (typeof error.name !== "string" || typeof error.message !== "string") malformedPayload();
+	if (error.stack !== void 0 && typeof error.stack !== "string") malformedPayload();
+	if (typeof errorPage.status !== "number" || !Number.isInteger(errorPage.status) || errorPage.status < 500 || errorPage.status > 599) malformedPayload();
+}
 function requireHydrationPayload(value) {
 	if (!isPlainObject(value)) malformedPayload();
 	for (const key of REQUIRED_PAYLOAD_KEYS) if (!Object.prototype.hasOwnProperty.call(value, key)) malformedPayload();
@@ -45,15 +71,18 @@ function requireHydrationPayload(value) {
 		const optional = value[key];
 		if (optional !== void 0 && !isPlainObject(optional)) malformedPayload();
 	}
+	const errorPage = value.errorPage;
+	if (errorPage !== void 0) requireErrorPagePayload(errorPage);
 	return value;
 }
 /**
 * Read the fixed payload script without changing the server-rendered root.
 *
 * Extra fields are ignored. The gate owns the FIVE required keys — absent or
-* malformed, both throw — plus a shape check on the two optional ones
+* malformed, both throw — plus a shape check on the three optional ones
 * ({@link OPTIONAL_OBJECT_PAYLOAD_KEYS}); it deliberately does not require
-* those to be present.
+* those to be present. `errorPage`, when present, is additionally validated as
+* one atomic `{ error, status }` selection with a serialized error and a 5xx.
 */
 function readHydrationPayload(documentNode) {
 	const element = documentNode.getElementById(PAYLOAD_SCRIPT_ID);

package/esm/hydration-payload.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"hydration-payload.mjs","names":[],"sources":["../../../../../../web/src/hydration-payload.ts"],"sourcesContent":["import {\n  PAYLOAD_SCRIPT_ID,\n  type HydrationDocumentPayloadSource,\n} from \"./components/document-context\";\n\nexport type { HydrationDocumentPayloadSource } from \"./components/document-context\";\n\n/**\n * Exported so a payload-shape assertion can be written against the contract\n * itself. A spec that hardcodes its own copy of this list silently becomes a\n * claim about a PAST revision — that is exactly how the rev. 3 keys landed with\n * two specs still asserting the rev. 2 shape.\n */\nexport const REQUIRED_PAYLOAD_KEYS = [\n  \"appData\",\n  \"layoutData\",\n  \"pageData\",\n  \"shared\",\n  \"name\",\n] as const;\n\nconst ABSENT_PAYLOAD_MESSAGE =\n  `Warlock hydration payload is absent: #${PAYLOAD_SCRIPT_ID}, owned by ` +\n  \"web/src/components/document-context.ts, was not found.\";\nconst MALFORMED_PAYLOAD_MESSAGE =\n  `Warlock hydration payload was found at #${PAYLOAD_SCRIPT_ID} but could not be read.`;\n\nfunction malformedPayload(): never {\n  throw new Error(MALFORMED_PAYLOAD_MESSAGE);\n}\n\n/**\n * The keys that are allowed to be ABSENT but not allowed to be wrong.\n *\n * `metadata` and `params` are optional because the server is right not to\n * always produce them — a page with no `metadata` export resolves none, and a\n * payload written by a build that predates these keys carries neither. Failing\n * a whole page over an absent accessor would turn a cosmetic gap into a blank\n * screen, so absence is accepted and the readers default it.\n *\n * Present-but-not-an-object is a different claim entirely: it means something\n * produced a payload with these names meaning something else, and every reader\n * downstream would then be indexing a string. That is MALFORMED under the same\n * rule the required keys live by, so it throws. Arrays included — `typeof []`\n * is `\"object\"`, and an array of params is not params.\n */\nexport const OPTIONAL_OBJECT_PAYLOAD_KEYS = [\"metadata\", \"params\"] as const;\n\nfunction isPlainObject(value: unknown): boolean {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction requireHydrationPayload(value: unknown): HydrationDocumentPayloadSource {\n  if (!isPlainObject(value)) malformedPayload();\n\n  for (const key of REQUIRED_PAYLOAD_KEYS) {\n    if (!Object.prototype.hasOwnProperty.call(value, key)) malformedPayload();\n  }\n\n  for (const key of OPTIONAL_OBJECT_PAYLOAD_KEYS) {\n    const optional = (value as Record<string, unknown>)[key];\n\n    if (optional !== undefined && !isPlainObject(optional)) malformedPayload();\n  }\n\n  return value as HydrationDocumentPayloadSource;\n}\n\n/**\n * Read the fixed payload script without changing the server-rendered root.\n *\n * Extra fields are ignored. The gate owns the FIVE required keys — absent or\n * malformed, both throw — plus a shape check on the two optional ones\n * ({@link OPTIONAL_OBJECT_PAYLOAD_KEYS}); it deliberately does not require\n * those to be present.\n */\nexport function readHydrationPayload(documentNode: Document): HydrationDocumentPayloadSource {\n  const element = documentNode.getElementById(PAYLOAD_SCRIPT_ID);\n\n  if (element === null) throw new Error(ABSENT_PAYLOAD_MESSAGE);\n\n  let parsed: unknown;\n\n  try {\n    parsed = JSON.parse(element.textContent ?? \"\");\n  } catch {\n    malformedPayload();\n  }\n\n  return requireHydrationPayload(parsed);\n}\n"],"mappings":";;;;;;;;;AAaA,MAAa,wBAAwB;CACnC;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,yBACJ,yCAAyC,kBAAkB;AAE7D,MAAM,4BACJ,2CAA2C,kBAAkB;AAE/D,SAAS,mBAA0B;CACjC,MAAM,IAAI,MAAM,yBAAyB;AAC3C;;;;;;;;;;;;;;;;AAiBA,MAAa,+BAA+B,CAAC,YAAY,QAAQ;AAEjE,SAAS,cAAc,OAAyB;CAC9C,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,wBAAwB,OAAgD;CAC/E,IAAI,CAAC,cAAc,KAAK,GAAG,iBAAiB;CAE5C,KAAK,MAAM,OAAO,uBAChB,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,GAAG,GAAG,iBAAiB;CAG1E,KAAK,MAAM,OAAO,8BAA8B;EAC9C,MAAM,WAAY,MAAkC;EAEpD,IAAI,aAAa,UAAa,CAAC,cAAc,QAAQ,GAAG,iBAAiB;CAC3E;CAEA,OAAO;AACT;;;;;;;;;AAUA,SAAgB,qBAAqB,cAAwD;CAC3F,MAAM,UAAU,aAAa,eAAe,iBAAiB;CAE7D,IAAI,YAAY,MAAM,MAAM,IAAI,MAAM,sBAAsB;CAE5D,IAAI;CAEJ,IAAI;EACF,SAAS,KAAK,MAAM,QAAQ,eAAe,EAAE;CAC/C,QAAQ;EACN,iBAAiB;CACnB;CAEA,OAAO,wBAAwB,MAAM;AACvC"}
+{"version":3,"file":"hydration-payload.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/hydration-payload.ts"],"sourcesContent":["import {\n  PAYLOAD_SCRIPT_ID,\n  type HydrationDocumentPayloadSource,\n} from \"./components/document-context\";\n\nexport type { HydrationDocumentPayloadSource } from \"./components/document-context\";\nexport type {\n  ErrorPageProps,\n  SerializedErrorPageProps,\n  SerializedPageError,\n} from \"./components/document-context\";\n\n/**\n * Exported so a payload-shape assertion can be written against the contract\n * itself. A spec that hardcodes its own copy of this list silently becomes a\n * claim about a PAST revision — that is exactly how the rev. 3 keys landed with\n * two specs still asserting the rev. 2 shape.\n */\nexport const REQUIRED_PAYLOAD_KEYS = [\n  \"appData\",\n  \"layoutData\",\n  \"pageData\",\n  \"shared\",\n  \"name\",\n] as const;\n\nconst ABSENT_PAYLOAD_MESSAGE =\n  `Warlock hydration payload is absent: #${PAYLOAD_SCRIPT_ID}, owned by ` +\n  \"web/src/components/document-context.ts, was not found.\";\nconst MALFORMED_PAYLOAD_MESSAGE =\n  `Warlock hydration payload was found at #${PAYLOAD_SCRIPT_ID} but could not be read.`;\n\nfunction malformedPayload(): never {\n  throw new Error(MALFORMED_PAYLOAD_MESSAGE);\n}\n\n/**\n * The keys that are allowed to be ABSENT but not allowed to be wrong.\n *\n * `metadata`, `params` and `errorPage` are optional because the server is right\n * always produce them — a page with no `metadata` export resolves none, and a\n * older payload carries none of these additions. Failing a whole page over an\n * absent accessor would turn a compatible payload into a blank screen, so\n * absence is accepted.\n *\n * Present-but-not-an-object is a different claim entirely: it means something\n * produced a payload with these names meaning something else, and every reader\n * downstream would then be indexing a string. That is MALFORMED under the same\n * rule the required keys live by, so it throws. Arrays included — `typeof []`\n * is `\"object\"`, and an array of params is not params.\n */\nexport const OPTIONAL_OBJECT_PAYLOAD_KEYS = [\"metadata\", \"params\", \"errorPage\"] as const;\n\nfunction isPlainObject(value: unknown): boolean {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction hasExactStringKeys(\n  value: Record<PropertyKey, unknown>,\n  required: readonly string[],\n  optional: readonly string[] = [],\n): boolean {\n  const allowed = new Set([...required, ...optional]);\n  const keys = Reflect.ownKeys(value);\n\n  return (\n    required.every((key) => Object.prototype.hasOwnProperty.call(value, key)) &&\n    keys.every((key) => typeof key === \"string\" && allowed.has(key))\n  );\n}\n\n/**\n * Validate the explicit serialization boundary, not an `Error` instance.\n * `JSON.stringify(new Error(\"boom\"))` is normally `{}` because its useful\n * fields are non-enumerable; accepting that would hydrate an error page with a\n * different contract from the one the server rendered.\n */\nfunction requireErrorPagePayload(value: unknown): void {\n  if (!isPlainObject(value)) malformedPayload();\n\n  const errorPage = value as Record<PropertyKey, unknown>;\n\n  if (!hasExactStringKeys(errorPage, [\"error\", \"status\"])) malformedPayload();\n  if (!isPlainObject(errorPage.error)) malformedPayload();\n\n  const error = errorPage.error as Record<PropertyKey, unknown>;\n\n  if (!hasExactStringKeys(error, [\"name\", \"message\"], [\"stack\"])) malformedPayload();\n  if (typeof error.name !== \"string\" || typeof error.message !== \"string\") {\n    malformedPayload();\n  }\n  if (error.stack !== undefined && typeof error.stack !== \"string\") malformedPayload();\n\n  if (\n    typeof errorPage.status !== \"number\" ||\n    !Number.isInteger(errorPage.status) ||\n    errorPage.status < 500 ||\n    errorPage.status > 599\n  ) {\n    malformedPayload();\n  }\n}\n\nfunction requireHydrationPayload(value: unknown): HydrationDocumentPayloadSource {\n  if (!isPlainObject(value)) malformedPayload();\n\n  for (const key of REQUIRED_PAYLOAD_KEYS) {\n    if (!Object.prototype.hasOwnProperty.call(value, key)) malformedPayload();\n  }\n\n  for (const key of OPTIONAL_OBJECT_PAYLOAD_KEYS) {\n    const optional = (value as Record<string, unknown>)[key];\n\n    if (optional !== undefined && !isPlainObject(optional)) malformedPayload();\n  }\n\n  const errorPage = (value as Record<string, unknown>).errorPage;\n  if (errorPage !== undefined) requireErrorPagePayload(errorPage);\n\n  return value as HydrationDocumentPayloadSource;\n}\n\n/**\n * Read the fixed payload script without changing the server-rendered root.\n *\n * Extra fields are ignored. The gate owns the FIVE required keys — absent or\n * malformed, both throw — plus a shape check on the three optional ones\n * ({@link OPTIONAL_OBJECT_PAYLOAD_KEYS}); it deliberately does not require\n * those to be present. `errorPage`, when present, is additionally validated as\n * one atomic `{ error, status }` selection with a serialized error and a 5xx.\n */\nexport function readHydrationPayload(documentNode: Document): HydrationDocumentPayloadSource {\n  const element = documentNode.getElementById(PAYLOAD_SCRIPT_ID);\n\n  if (element === null) throw new Error(ABSENT_PAYLOAD_MESSAGE);\n\n  let parsed: unknown;\n\n  try {\n    parsed = JSON.parse(element.textContent ?? \"\");\n  } catch {\n    malformedPayload();\n  }\n\n  return requireHydrationPayload(parsed);\n}\n"],"mappings":";;;;;;;;;AAkBA,MAAa,wBAAwB;CACnC;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,yBACJ,yCAAyC,kBAAkB;AAE7D,MAAM,4BACJ,2CAA2C,kBAAkB;AAE/D,SAAS,mBAA0B;CACjC,MAAM,IAAI,MAAM,yBAAyB;AAC3C;;;;;;;;;;;;;;;;AAiBA,MAAa,+BAA+B;CAAC;CAAY;CAAU;AAAW;AAE9E,SAAS,cAAc,OAAyB;CAC9C,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,mBACP,OACA,UACA,WAA8B,CAAC,GACtB;CACT,MAAM,UAAU,IAAI,IAAI,CAAC,GAAG,UAAU,GAAG,QAAQ,CAAC;CAClD,MAAM,OAAO,QAAQ,QAAQ,KAAK;CAElC,OACE,SAAS,OAAO,QAAQ,OAAO,UAAU,eAAe,KAAK,OAAO,GAAG,CAAC,KACxE,KAAK,OAAO,QAAQ,OAAO,QAAQ,YAAY,QAAQ,IAAI,GAAG,CAAC;AAEnE;;;;;;;AAQA,SAAS,wBAAwB,OAAsB;CACrD,IAAI,CAAC,cAAc,KAAK,GAAG,iBAAiB;CAE5C,MAAM,YAAY;CAElB,IAAI,CAAC,mBAAmB,WAAW,CAAC,SAAS,QAAQ,CAAC,GAAG,iBAAiB;CAC1E,IAAI,CAAC,cAAc,UAAU,KAAK,GAAG,iBAAiB;CAEtD,MAAM,QAAQ,UAAU;CAExB,IAAI,CAAC,mBAAmB,OAAO,CAAC,QAAQ,SAAS,GAAG,CAAC,OAAO,CAAC,GAAG,iBAAiB;CACjF,IAAI,OAAO,MAAM,SAAS,YAAY,OAAO,MAAM,YAAY,UAC7D,iBAAiB;CAEnB,IAAI,MAAM,UAAU,UAAa,OAAO,MAAM,UAAU,UAAU,iBAAiB;CAEnF,IACE,OAAO,UAAU,WAAW,YAC5B,CAAC,OAAO,UAAU,UAAU,MAAM,KAClC,UAAU,SAAS,OACnB,UAAU,SAAS,KAEnB,iBAAiB;AAErB;AAEA,SAAS,wBAAwB,OAAgD;CAC/E,IAAI,CAAC,cAAc,KAAK,GAAG,iBAAiB;CAE5C,KAAK,MAAM,OAAO,uBAChB,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,GAAG,GAAG,iBAAiB;CAG1E,KAAK,MAAM,OAAO,8BAA8B;EAC9C,MAAM,WAAY,MAAkC;EAEpD,IAAI,aAAa,UAAa,CAAC,cAAc,QAAQ,GAAG,iBAAiB;CAC3E;CAEA,MAAM,YAAa,MAAkC;CACrD,IAAI,cAAc,QAAW,wBAAwB,SAAS;CAE9D,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,qBAAqB,cAAwD;CAC3F,MAAM,UAAU,aAAa,eAAe,iBAAiB;CAE7D,IAAI,YAAY,MAAM,MAAM,IAAI,MAAM,sBAAsB;CAE5D,IAAI;CAEJ,IAAI;EACF,SAAS,KAAK,MAAM,QAAQ,eAAe,EAAE;CAC/C,QAAQ;EACN,iBAAiB;CACnB;CAEA,OAAO,wBAAwB,MAAM;AACvC"}

package/esm/index.d.mts

@@ -1,6 +1,8 @@
+import { HttpContext, PageContext } from "./context.mjs";
 import { AppLoader, LayoutLoader, PageLoader } from "./loaders.mjs";
 import { AppProps, LayoutProps, PageProps } from "./props.mjs";
 import { PageMetadata } from "./metadata.mjs";
+import { ErrorPageProps, SerializedErrorPageProps, SerializedPageError } from "./components/document-context.mjs";
 import { shared, useShared } from "./shared.mjs";
 import { QueryStringInput, QueryStringLeaf, QueryStringNested, QueryStringObject, QueryStringOptions, QueryStringValue, RepeatedKeyStrategy, UnserializableQueryValueError, queryString, queryStringOf, resetQueryStringOptions, setQueryStringOptions } from "./routing/query-string.mjs";
 import { RouteParameters, RouteQuery, href } from "./routing/route-table.mjs";
@@ -11,9 +13,8 @@ import { MatchedRoute, currentRoute, previousRoute } from "./client/navigation/c
 import { refresh } from "./client/navigation/refresh.mjs";
 import { Head } from "./components/head.mjs";
 import { Scripts } from "./components/scripts.mjs";
-import { PageContext } from "./context.mjs";
 
-//#region ../web/src/index.d.ts
+//#region web/src/index.d.ts
 /**
  * THE AUDIT SURFACE — everything the browser receives, declared by the app.
  *
@@ -31,5 +32,5 @@ import { PageContext } from "./context.mjs";
  */
 interface SharedContext {}
 //#endregion
-export { type AppLoader, type AppProps, Head, type LayoutLoader, type LayoutProps, Link, type MatchedRoute, type NavigationEndPayload, type NavigationErrorPayload, type NavigationStartPayload, type PageContext, type PageLoader, type PageMetadata, type PageProps, type QueryStringInput, type QueryStringLeaf, type QueryStringNested, type QueryStringObject, type QueryStringOptions, type QueryStringValue, type RepeatedKeyStrategy, type RouteParameters, type RouteQuery, Scripts, SharedContext, UnserializableQueryValueError, createRouterEvents, currentRoute, getHash, href, navigateBack, navigateTo, previousRoute, queryString, queryStringOf, refresh, resetQueryStringOptions, routerEvents, setQueryStringOptions, shared, useShared };
+export { type AppLoader, type AppProps, type ErrorPageProps, Head, type HttpContext, type LayoutLoader, type LayoutProps, Link, type MatchedRoute, type NavigationEndPayload, type NavigationErrorPayload, type NavigationStartPayload, type PageContext, type PageLoader, type PageMetadata, type PageProps, type QueryStringInput, type QueryStringLeaf, type QueryStringNested, type QueryStringObject, type QueryStringOptions, type QueryStringValue, type RepeatedKeyStrategy, type RouteParameters, type RouteQuery, Scripts, type SerializedErrorPageProps, type SerializedPageError, SharedContext, UnserializableQueryValueError, createRouterEvents, currentRoute, getHash, href, navigateBack, navigateTo, previousRoute, queryString, queryStringOf, refresh, resetQueryStringOptions, routerEvents, setQueryStringOptions, shared, useShared };
 //# sourceMappingURL=index.d.mts.map

package/esm/loaders.d.mts

@@ -1,46 +1,17 @@
-import { RouteDeclaration, RouteParamsOf } from "./route.mjs";
+import { PageContext } from "./context.mjs";
+import { RouteDeclaration } from "./route.mjs";
 import { PageValidation, ValidatedOutput } from "./validation.mjs";
 import { SharedContext } from "./index.mjs";
-import { PageContext, WebRequest, WebResponse } from "./context.mjs";
+import { Request, Response } from "@warlock.js/core";
 
-//#region ../web/src/loaders.d.ts
-/**
- * The context a PAGE loader receives, narrowed by the page's own sibling
- * exports: `TValidation` types `request.validated()` off the schema,
- * `TRoute` types `request.input()` off the path literal. A sibling export
- * cannot contextually type an already-authored function — the generics are
- * the mechanism that links them (product-details.page.tsx:20-41).
- */
-type PageLoaderContext<TValidation extends PageValidation | undefined, TRoute extends RouteDeclaration | undefined> = {
-  request: WebRequest<ValidatedOutput<TValidation>, RouteParamsOf<TRoute>>;
-  response: WebResponse;
+//#region web/src/loaders.d.ts
+type PageLoaderContext<TValidation extends PageValidation | undefined, _TRoute extends RouteDeclaration | undefined> = {
+  request: Request<ValidatedOutput<TValidation>>;
+  response: Response;
   shared: SharedContext;
 };
-/**
- * The page controller's contract. Used with `satisfies`, NEVER `:` — an
- * annotation replaces the inferred type and `PageProps<typeof loader>` loses
- * `data` (v5/app README §A). The return is `unknown` because `satisfies`
- * preserves whatever the loader actually returns; the short-circuit brand and
- * the props types do the narrowing on the way out.
- *
- * `TValidation` may be `undefined` — a page with no `validation` export
- * (product-details.page.tsx:69). `TRoute` may be the config object or a bare
- * string literal (contact-us.page.tsx:27).
- */
 type PageLoader<TValidation extends PageValidation | undefined = undefined, TRoute extends RouteDeclaration | undefined = undefined> = (context: PageLoaderContext<TValidation, TRoute>) => unknown;
-/**
- * A layout's controller. Bare — no generics — in every v5/app use
- * (products/web/layout.tsx:53-58, dashboard.layout.tsx:34-36): a layout has
- * no `validation`/`route` exports to link, and the contract is the annotated
- * type, not a parameter list (`async () => …` is still a controller with the
- * full context available).
- */
 type LayoutLoader = (context: PageContext) => unknown;
-/**
- * The application root's controller (root.tsx:56-58). Same shape as
- * `LayoutLoader`; a separate name because the two revalidate and nest under
- * different rules, and conflating them would make that drift invisible.
- */
 type AppLoader = (context: PageContext) => unknown;
 //#endregion
 export { AppLoader, LayoutLoader, PageLoader };

package/esm/metadata.d.mts

@@ -1,7 +1,7 @@
 import { LoaderData, LoaderFunction } from "./props.mjs";
 import { SharedContext } from "./index.mjs";
 
-//#region ../web/src/metadata.d.ts
+//#region web/src/metadata.d.ts
 /**
  * What the `metadata` export may produce. The pipeline injects it into
  * `<head>` before the first byte; `<Head />` only decides placement.

package/esm/metadata.mjs

@@ -1,4 +1,4 @@
-//#region ../web/src/metadata.ts
+//#region web/src/metadata.ts
 /**
 * The SAME key set as {@link MetadataOutput}, as a value.
 *

package/esm/metadata.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.mjs","names":[],"sources":["../../../../../../web/src/metadata.ts"],"sourcesContent":["import type { SharedContext } from \"./index\";\r\nimport type { LoaderData, LoaderFunction } from \"./props\";\r\n\r\n/**\r\n * What the `metadata` export may produce. The pipeline injects it into\r\n * `<head>` before the first byte; `<Head />` only decides placement.\r\n *\r\n * **Every member here is a member something READS.** The two renderers are\r\n * `components/head.ts:28-70` (the SSR'd document) and\r\n * `client/navigation/navigation-root.tsx:105-123` (the same head, rewritten\r\n * after a client navigation), and they agree key for key. This type is the list\r\n * of those keys and deliberately not one entry longer: a field the type promises\r\n * and no renderer consumes is the same silence as an unknown key — the page is\r\n * served without it and nothing says so.\r\n *\r\n * Adding a member is therefore a two-file change by construction. Add it here\r\n * and {@link METADATA_KEYS} stops matching, which is a compile error\r\n * ({@link MetadataKeysAreExact}); make it match and the build gate in\r\n * `build/discover-pages.ts` accepts the key — but until a renderer emits a tag\r\n * for it, the key still does nothing. Write the renderer.\r\n */\r\nexport type MetadataOutput = {\r\n  title?: string;\r\n  description?: string;\r\n  keywords?: string | readonly string[];\r\n  canonical?: string;\r\n  robots?: string;\r\n  /**\r\n   * `og:title`/`og:description` fall back to the top-level `title`/\r\n   * `description` when `openGraph` is present but the member is absent —\r\n   * no other member has a fallback.\r\n   */\r\n  openGraph?: {\r\n    title?: string;\r\n    description?: string;\r\n    image?: string;\r\n    url?: string;\r\n    type?: string;\r\n  };\r\n  twitter?: {\r\n    card?: string;\r\n    title?: string;\r\n    description?: string;\r\n    image?: string;\r\n  };\r\n};\r\n\r\n/**\r\n * The SAME key set as {@link MetadataOutput}, as a value.\r\n *\r\n * It exists because the defect this guards is one a type cannot reach.\r\n * `export const metadata = { tittle: \"x\" }` — no annotation — is a well-typed\r\n * program: TypeScript infers `{ tittle: string }` and has nothing to compare it\r\n * against, so the page is served with no title and the build says nothing. The\r\n * only place left to catch it is where pages are DISCOVERED, and discovery\r\n * refuses to run application code — it parses. A parser cannot ask a type what\r\n * its keys are, so the keys have to exist at runtime too.\r\n *\r\n * Two lists of one thing is exactly the drift this codebase refuses elsewhere,\r\n * so they are not two lists: {@link MetadataKeysAreExact} makes any\r\n * disagreement a compile error, in either direction. Add a key to the type\r\n * alone and this file stops compiling; add it here alone, likewise.\r\n */\r\nexport const METADATA_KEYS = [\r\n  \"title\",\r\n  \"description\",\r\n  \"keywords\",\r\n  \"canonical\",\r\n  \"robots\",\r\n  \"openGraph\",\r\n  \"twitter\",\r\n] as const;\r\n\r\n/** The members of `openGraph`, on the same terms as {@link METADATA_KEYS}. */\r\nexport const OPEN_GRAPH_KEYS = [\"title\", \"description\", \"image\", \"url\", \"type\"] as const;\r\n\r\n/** The members of `twitter`, on the same terms as {@link METADATA_KEYS}. */\r\nexport const TWITTER_KEYS = [\"card\", \"title\", \"description\", \"image\"] as const;\r\n\r\n/**\r\n * Instantiates only when `Difference` is empty. When it is not, the compiler\r\n * names the offending key in the error — \"Type '\\\"tittle\\\"' does not satisfy\r\n * the constraint 'never'\" — which is the whole message a drift needs.\r\n *\r\n * A mutual `extends` (`Exactly<A extends B, B extends A>`) says the same thing\r\n * more directly and TypeScript rejects it as a circular constraint (TS2313), so\r\n * the sets are compared by difference instead, once in each direction. BOTH\r\n * directions matter: a list that has fallen behind the type makes the build gate\r\n * reject a key it should accept, and a list that has run ahead makes it accept\r\n * one nothing renders.\r\n */\r\ntype NoDifference<Difference extends never> = Difference;\r\n\r\n/**\r\n * The drift guards, written out per key set rather than through one generic\r\n * helper: a `SameKeys<List, Keys>` alias would apply `NoDifference` to an\r\n * UNRESOLVED `Exclude<List, Keys>`, which the compiler cannot show is empty and\r\n * so rejects at the declaration (TS2344) whatever the real key sets are. Passed\r\n * concrete types, it resolves and checks the thing it is meant to check.\r\n *\r\n * Exported so they are not \"unused\", and named so a failure reads as what it\r\n * is: the key list and the type have diverged.\r\n */\r\nexport type MetadataKeysAreExact = [\r\n  NoDifference<Exclude<(typeof METADATA_KEYS)[number], keyof MetadataOutput>>,\r\n  NoDifference<Exclude<keyof MetadataOutput, (typeof METADATA_KEYS)[number]>>,\r\n];\r\n\r\ntype OpenGraphKey = keyof NonNullable<MetadataOutput[\"openGraph\"]>;\r\n\r\nexport type OpenGraphKeysAreExact = [\r\n  NoDifference<Exclude<(typeof OPEN_GRAPH_KEYS)[number], OpenGraphKey>>,\r\n  NoDifference<Exclude<OpenGraphKey, (typeof OPEN_GRAPH_KEYS)[number]>>,\r\n];\r\n\r\ntype TwitterKey = keyof NonNullable<MetadataOutput[\"twitter\"]>;\r\n\r\nexport type TwitterKeysAreExact = [\r\n  NoDifference<Exclude<(typeof TWITTER_KEYS)[number], TwitterKey>>,\r\n  NoDifference<Exclude<TwitterKey, (typeof TWITTER_KEYS)[number]>>,\r\n];\r\n\r\n/**\r\n * Static object OR a function of the loader's data (products.page.tsx:81-84,\r\n * product-details.page.tsx:71-74). The function form runs server-side, after\r\n * the loader, with the same `data` the component will receive — which is why\r\n * it can describe the page instead of guessing at it.\r\n *\r\n * **`data` is always present, and that is now true rather than merely\r\n * declared.** The function form runs only when the loader resolved; when it\r\n * rejected, the framework emits `ERROR_PAGE_METADATA` and this never runs\r\n * (`server/resolve-page-metadata.ts`, which explains why at length). An earlier\r\n * revision passed `{ data: undefined, error }` on the boundary path while\r\n * declaring `data` non-optional — every page that read `data` unguarded then\r\n * threw a `TypeError` that replaced the loader's real error.\r\n */\r\nexport type PageMetadata<TLoader extends LoaderFunction | undefined = undefined> =\r\n  | MetadataOutput\r\n  | ((context: {\r\n      data: LoaderData<TLoader>;\r\n      shared: Readonly<SharedContext>;\r\n    }) => MetadataOutput);\r\n"],"mappings":";;;;;;;;;;;;;;;;;AA+DA,MAAa,gBAAgB;CAC3B;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAa,kBAAkB;CAAC;CAAS;CAAe;CAAS;CAAO;AAAM;;AAG9E,MAAa,eAAe;CAAC;CAAQ;CAAS;CAAe;AAAO"}
+{"version":3,"file":"metadata.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/metadata.ts"],"sourcesContent":["import type { SharedContext } from \"./index\";\r\nimport type { LoaderData, LoaderFunction } from \"./props\";\r\n\r\n/**\r\n * What the `metadata` export may produce. The pipeline injects it into\r\n * `<head>` before the first byte; `<Head />` only decides placement.\r\n *\r\n * **Every member here is a member something READS.** The two renderers are\r\n * `components/head.ts:28-70` (the SSR'd document) and\r\n * `client/navigation/navigation-root.tsx:105-123` (the same head, rewritten\r\n * after a client navigation), and they agree key for key. This type is the list\r\n * of those keys and deliberately not one entry longer: a field the type promises\r\n * and no renderer consumes is the same silence as an unknown key — the page is\r\n * served without it and nothing says so.\r\n *\r\n * Adding a member is therefore a two-file change by construction. Add it here\r\n * and {@link METADATA_KEYS} stops matching, which is a compile error\r\n * ({@link MetadataKeysAreExact}); make it match and the build gate in\r\n * `build/discover-pages.ts` accepts the key — but until a renderer emits a tag\r\n * for it, the key still does nothing. Write the renderer.\r\n */\r\nexport type MetadataOutput = {\r\n  title?: string;\r\n  description?: string;\r\n  keywords?: string | readonly string[];\r\n  canonical?: string;\r\n  robots?: string;\r\n  /**\r\n   * `og:title`/`og:description` fall back to the top-level `title`/\r\n   * `description` when `openGraph` is present but the member is absent —\r\n   * no other member has a fallback.\r\n   */\r\n  openGraph?: {\r\n    title?: string;\r\n    description?: string;\r\n    image?: string;\r\n    url?: string;\r\n    type?: string;\r\n  };\r\n  twitter?: {\r\n    card?: string;\r\n    title?: string;\r\n    description?: string;\r\n    image?: string;\r\n  };\r\n};\r\n\r\n/**\r\n * The SAME key set as {@link MetadataOutput}, as a value.\r\n *\r\n * It exists because the defect this guards is one a type cannot reach.\r\n * `export const metadata = { tittle: \"x\" }` — no annotation — is a well-typed\r\n * program: TypeScript infers `{ tittle: string }` and has nothing to compare it\r\n * against, so the page is served with no title and the build says nothing. The\r\n * only place left to catch it is where pages are DISCOVERED, and discovery\r\n * refuses to run application code — it parses. A parser cannot ask a type what\r\n * its keys are, so the keys have to exist at runtime too.\r\n *\r\n * Two lists of one thing is exactly the drift this codebase refuses elsewhere,\r\n * so they are not two lists: {@link MetadataKeysAreExact} makes any\r\n * disagreement a compile error, in either direction. Add a key to the type\r\n * alone and this file stops compiling; add it here alone, likewise.\r\n */\r\nexport const METADATA_KEYS = [\r\n  \"title\",\r\n  \"description\",\r\n  \"keywords\",\r\n  \"canonical\",\r\n  \"robots\",\r\n  \"openGraph\",\r\n  \"twitter\",\r\n] as const;\r\n\r\n/** The members of `openGraph`, on the same terms as {@link METADATA_KEYS}. */\r\nexport const OPEN_GRAPH_KEYS = [\"title\", \"description\", \"image\", \"url\", \"type\"] as const;\r\n\r\n/** The members of `twitter`, on the same terms as {@link METADATA_KEYS}. */\r\nexport const TWITTER_KEYS = [\"card\", \"title\", \"description\", \"image\"] as const;\r\n\r\n/**\r\n * Instantiates only when `Difference` is empty. When it is not, the compiler\r\n * names the offending key in the error — \"Type '\\\"tittle\\\"' does not satisfy\r\n * the constraint 'never'\" — which is the whole message a drift needs.\r\n *\r\n * A mutual `extends` (`Exactly<A extends B, B extends A>`) says the same thing\r\n * more directly and TypeScript rejects it as a circular constraint (TS2313), so\r\n * the sets are compared by difference instead, once in each direction. BOTH\r\n * directions matter: a list that has fallen behind the type makes the build gate\r\n * reject a key it should accept, and a list that has run ahead makes it accept\r\n * one nothing renders.\r\n */\r\ntype NoDifference<Difference extends never> = Difference;\r\n\r\n/**\r\n * The drift guards, written out per key set rather than through one generic\r\n * helper: a `SameKeys<List, Keys>` alias would apply `NoDifference` to an\r\n * UNRESOLVED `Exclude<List, Keys>`, which the compiler cannot show is empty and\r\n * so rejects at the declaration (TS2344) whatever the real key sets are. Passed\r\n * concrete types, it resolves and checks the thing it is meant to check.\r\n *\r\n * Exported so they are not \"unused\", and named so a failure reads as what it\r\n * is: the key list and the type have diverged.\r\n */\r\nexport type MetadataKeysAreExact = [\r\n  NoDifference<Exclude<(typeof METADATA_KEYS)[number], keyof MetadataOutput>>,\r\n  NoDifference<Exclude<keyof MetadataOutput, (typeof METADATA_KEYS)[number]>>,\r\n];\r\n\r\ntype OpenGraphKey = keyof NonNullable<MetadataOutput[\"openGraph\"]>;\r\n\r\nexport type OpenGraphKeysAreExact = [\r\n  NoDifference<Exclude<(typeof OPEN_GRAPH_KEYS)[number], OpenGraphKey>>,\r\n  NoDifference<Exclude<OpenGraphKey, (typeof OPEN_GRAPH_KEYS)[number]>>,\r\n];\r\n\r\ntype TwitterKey = keyof NonNullable<MetadataOutput[\"twitter\"]>;\r\n\r\nexport type TwitterKeysAreExact = [\r\n  NoDifference<Exclude<(typeof TWITTER_KEYS)[number], TwitterKey>>,\r\n  NoDifference<Exclude<TwitterKey, (typeof TWITTER_KEYS)[number]>>,\r\n];\r\n\r\n/**\r\n * Static object OR a function of the loader's data (products.page.tsx:81-84,\r\n * product-details.page.tsx:71-74). The function form runs server-side, after\r\n * the loader, with the same `data` the component will receive — which is why\r\n * it can describe the page instead of guessing at it.\r\n *\r\n * **`data` is always present, and that is now true rather than merely\r\n * declared.** The function form runs only when the loader resolved; when it\r\n * rejected, the framework emits `ERROR_PAGE_METADATA` and this never runs\r\n * (`server/resolve-page-metadata.ts`, which explains why at length). An earlier\r\n * revision passed `{ data: undefined, error }` on the boundary path while\r\n * declaring `data` non-optional — every page that read `data` unguarded then\r\n * threw a `TypeError` that replaced the loader's real error.\r\n */\r\nexport type PageMetadata<TLoader extends LoaderFunction | undefined = undefined> =\r\n  | MetadataOutput\r\n  | ((context: {\r\n      data: LoaderData<TLoader>;\r\n      shared: Readonly<SharedContext>;\r\n    }) => MetadataOutput);\r\n"],"mappings":";;;;;;;;;;;;;;;;;AA+DA,MAAa,gBAAgB;CAC3B;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAa,kBAAkB;CAAC;CAAS;CAAe;CAAS;CAAO;AAAM;;AAG9E,MAAa,eAAe;CAAC;CAAQ;CAAS;CAAe;AAAO"}

package/esm/props.d.mts

@@ -1,17 +1,15 @@
 import { SharedContext } from "./index.mjs";
-import { LoaderShortCircuit } from "./context.mjs";
 import { ReactNode } from "react";
+import { Response } from "@warlock.js/core";
 
-//#region ../web/src/props.d.ts
+//#region web/src/props.d.ts
 /** Any loader authored with `satisfies` — the concrete function type. */
 type LoaderFunction = (...args: any[]) => unknown;
 /**
- * The loader's literal return shape MINUS the branded short-circuits:
- * `response.notFound()` / `response.redirect()` never union into `data`
- * (product-details.page.tsx:45-57, login.page.tsx:71-84). No loader → no
- * data.
+ * The loader's literal return shape minus core Response. Returning that exact
+ * class is terminal; every other value is data.
  */
-type LoaderData<TLoader> = TLoader extends LoaderFunction ? Exclude<Awaited<ReturnType<TLoader>>, LoaderShortCircuit> : undefined;
+type LoaderData<TLoader> = TLoader extends LoaderFunction ? Exclude<Awaited<ReturnType<TLoader>>, Response> : undefined;
 /**
  * What the pipeline hands a page component: its own loader's data plus the
  * per-request payload. Never `request` or `response` — the component also
@@ -20,6 +18,7 @@ type LoaderData<TLoader> = TLoader extends LoaderFunction ? Exclude<Awaited<Retu
 type PageProps<TLoader extends LoaderFunction | undefined = undefined> = {
   data: LoaderData<TLoader>;
   shared: Readonly<SharedContext>;
+  params: Readonly<Record<string, string>>;
 };
 /**
  * A layout additionally receives the subtree it wraps. Usable bare —
@@ -37,6 +36,15 @@ type AppProps<TLoader extends LoaderFunction | undefined = undefined> = {
   shared: Readonly<SharedContext>;
   children: ReactNode;
 };
+/**
+ * Props passed only while the server renders an application `error.page.tsx`.
+ * The thrown value intentionally remains intact here; its browser counterpart
+ * is normalized at the hydration boundary.
+ */
+type ServerErrorPageProps = {
+  error: unknown;
+  status: number;
+};
 //#endregion
-export { AppProps, LayoutProps, LoaderData, LoaderFunction, PageProps };
+export { AppProps, LayoutProps, LoaderData, LoaderFunction, PageProps, ServerErrorPageProps };
 //# sourceMappingURL=props.d.mts.map

package/esm/route.d.mts

@@ -1,4 +1,4 @@
-//#region ../web/src/route.d.ts
+//#region web/src/route.d.ts
 /**
  * The `route` export's accepted shapes: the configured object
  * (`{ path, name } as const` — the `as const` is what keeps `path` a literal
@@ -10,21 +10,6 @@ type RouteDeclaration = string | {
   readonly path: string;
   readonly name?: string;
 };
-type RoutePath<TRoute> = TRoute extends string ? TRoute : TRoute extends {
-  readonly path: infer TPath extends string;
-} ? TPath : never;
-/**
- * Parameter names out of a path literal: `"/:id"` → `"id"`,
- * `"/a/:x/:y"` → `"x" | "y"`, `"/"` and `"*"` → `never` (so `request.input()`
- * is uncallable where no parameter exists to read).
- */
-type PathParams<TPath extends string> = TPath extends `${string}:${infer TRest}` ? TRest extends `${infer TParam}/${infer TTail}` ? TParam | PathParams<`/${TTail}`> : TRest : never;
-/**
- * `undefined` (no route generic supplied) keeps `input()` loose rather than
- * uncallable — the contract only narrows when the loader links its route via
- * `satisfies PageLoader<…, typeof route>`.
- */
-type RouteParamsOf<TRoute> = [TRoute] extends [undefined] ? string : PathParams<RoutePath<TRoute>>;
 //#endregion
-export { RouteDeclaration, RouteParamsOf };
+export { RouteDeclaration };
 //# sourceMappingURL=route.d.mts.map

package/esm/routing/compose-route-path.d.mts

@@ -1,4 +1,4 @@
-//#region ../web/src/routing/compose-route-path.d.ts
+//#region web/src/routing/compose-route-path.d.ts
 /**
  * Route-path composition — the single, pure rule for turning a layout's
  * declared `prefix` and a page's declared `route.path` into the page's

package/esm/routing/compose-route-path.mjs

@@ -1,4 +1,4 @@
-//#region ../web/src/routing/compose-route-path.ts
+//#region web/src/routing/compose-route-path.ts
 /**
 * Route-path composition — the single, pure rule for turning a layout's
 * declared `prefix` and a page's declared `route.path` into the page's

package/esm/routing/compose-route-path.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"compose-route-path.mjs","names":[],"sources":["../../../../../../../web/src/routing/compose-route-path.ts"],"sourcesContent":["/**\n * Route-path composition — the single, pure rule for turning a layout's\n * declared `prefix` and a page's declared `route.path` into the page's\n * effective, registered path. Previously three hand-written copies: the dev\n * installer (`web/src/server/install-page-routes.ts`), the production\n * manifest installer (`web/src/server/install-page-routes-from-manifest.ts`)\n * and build discovery (`web/src/build/discover-pages.ts`) each carried this\n * exact rule so build and boot could not quietly disagree about it; all\n * three now delegate here instead.\n *\n * DIRECTORY CONTRACT — applies to everything in `web/src/routing/`: nothing\n * here may import `node:fs`, `node:path`, `vite`, or `fastify`. This module\n * receives canonical values and trusts nothing about them beyond the input\n * contract asserted below — it asserts rather than trusts, but it never\n * repairs.\n */\n\n/**\n * A page's effective path: its nearest layout's `prefix` followed by its own\n * declared `route.path`. A root prefix (\"/\") and a root path (\"/\") each\n * contribute nothing, so neither adds a slash of its own; every other case\n * joins on the slash `routePath` already starts with, which is what keeps a\n * double slash out of the result, and an empty concatenation is the site\n * root.\n */\nexport function composeRoutePath(layoutPrefix: string, routePath: string): string {\n  const normalizedPrefix = layoutPrefix === \"/\" ? \"\" : layoutPrefix.replace(/\\/+$/, \"\");\n  const normalizedRoute = routePath === \"/\" ? \"\" : routePath;\n  const composed = `${normalizedPrefix}${normalizedRoute}`;\n\n  return composed === \"\" ? \"/\" : composed;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,iBAAiB,cAAsB,WAA2B;CAGhF,MAAM,WAAW,GAFQ,iBAAiB,MAAM,KAAK,aAAa,QAAQ,QAAQ,EAAE,IAC5D,cAAc,MAAM,KAAK;CAGjD,OAAO,aAAa,KAAK,MAAM;AACjC"}
+{"version":3,"file":"compose-route-path.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/routing/compose-route-path.ts"],"sourcesContent":["/**\n * Route-path composition — the single, pure rule for turning a layout's\n * declared `prefix` and a page's declared `route.path` into the page's\n * effective, registered path. Previously three hand-written copies: the dev\n * installer (`web/src/server/install-page-routes.ts`), the production\n * manifest installer (`web/src/server/install-page-routes-from-manifest.ts`)\n * and build discovery (`web/src/build/discover-pages.ts`) each carried this\n * exact rule so build and boot could not quietly disagree about it; all\n * three now delegate here instead.\n *\n * DIRECTORY CONTRACT — applies to everything in `web/src/routing/`: nothing\n * here may import `node:fs`, `node:path`, `vite`, or `fastify`. This module\n * receives canonical values and trusts nothing about them beyond the input\n * contract asserted below — it asserts rather than trusts, but it never\n * repairs.\n */\n\n/**\n * A page's effective path: its nearest layout's `prefix` followed by its own\n * declared `route.path`. A root prefix (\"/\") and a root path (\"/\") each\n * contribute nothing, so neither adds a slash of its own; every other case\n * joins on the slash `routePath` already starts with, which is what keeps a\n * double slash out of the result, and an empty concatenation is the site\n * root.\n */\nexport function composeRoutePath(layoutPrefix: string, routePath: string): string {\n  const normalizedPrefix = layoutPrefix === \"/\" ? \"\" : layoutPrefix.replace(/\\/+$/, \"\");\n  const normalizedRoute = routePath === \"/\" ? \"\" : routePath;\n  const composed = `${normalizedPrefix}${normalizedRoute}`;\n\n  return composed === \"\" ? \"/\" : composed;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,iBAAiB,cAAsB,WAA2B;CAGhF,MAAM,WAAW,GAFQ,iBAAiB,MAAM,KAAK,aAAa,QAAQ,QAAQ,EAAE,IAC5D,cAAc,MAAM,KAAK;CAGjD,OAAO,aAAa,KAAK,MAAM;AACjC"}

package/esm/routing/data-request.mjs

@@ -1,4 +1,4 @@
-//#region ../web/src/routing/data-request.ts
+//#region web/src/routing/data-request.ts
 /**
 * The marker that turns a page request into a DATA request.
 *

package/esm/routing/data-request.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"data-request.mjs","names":[],"sources":["../../../../../../../web/src/routing/data-request.ts"],"sourcesContent":["/**\n * The marker that turns a page request into a DATA request.\n *\n * A client navigation needs exactly what a full page load needs — middleware,\n * validation, loaders, redirects, cookies, the settled status — and differs in\n * one respect only: it wants the hydration payload as JSON instead of a\n * rendered document. So it is deliberately NOT a separate `/_loader` route.\n *\n * WHY NOT A SEPARATE ROUTE. A `/_loader?path=/products/42` endpoint has to\n * resolve that path to a page itself, which is a SECOND implementation of route\n * semantics living beside the server's. This codebase already refuses that\n * bargain for the browser — the hydration payload carries the route `name` so\n * the client never re-matches — and the same reasoning applies here with more\n * force: a loader endpoint that disagreed with the real route about params,\n * prefixes or which page owns a path would answer a different request than the\n * one the user navigated to. Same URL, same route, same matcher, same pipeline;\n * only the final representation differs.\n *\n * WHY A HEADER AND NOT `?_data=1`. The query string belongs to the page — it is\n * what `validation` and loaders read. Injecting a framework key into it means a\n * page with strict query validation rejects its own client navigations, and\n * every loader that echoes its query starts leaking a private flag.\n *\n * Responses to a data request must carry `Vary: <this header>` so a shared\n * cache can never hand a document to a client that asked for JSON, or the\n * reverse. Page responses are `private, no-store` today, which makes that\n * theoretical — `Vary` is what keeps it theoretical if the caching policy\n * changes.\n */\nexport const WARLOCK_DATA_REQUEST_HEADER = \"x-warlock-data\";\n\n/**\n * The value the client sends. Any non-empty value is honoured on the way in —\n * the header's PRESENCE is the signal — but the client sends this one so the\n * traffic is self-describing in a log or a network panel.\n */\nexport const WARLOCK_DATA_REQUEST_VALUE = \"1\";\n\n/**\n * Declared explicitly because the payload goes on the wire ALREADY SERIALIZED,\n * as a string, and core only auto-picks `application/json` for object bodies.\n * See the send site for why it must be a string.\n */\nexport const DATA_RESPONSE_CONTENT_TYPE = \"application/json\";\n\n/**\n * Whether a request asked for the payload rather than the document.\n *\n * Presence-based on purpose: a proxy that rewrites the value, or a client on a\n * newer version that sends something more specific, still means \"data\". Only an\n * absent or empty header means \"render the document\".\n */\nexport function isDataRequest(headerValue: string | string[] | undefined): boolean {\n  const value = Array.isArray(headerValue) ? headerValue[0] : headerValue;\n\n  return typeof value === \"string\" && value.length > 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,8BAA8B;;;;;;AAc3C,MAAa,6BAA6B;;;;;;;;AAS1C,SAAgB,cAAc,aAAqD;CACjF,MAAM,QAAQ,MAAM,QAAQ,WAAW,IAAI,YAAY,KAAK;CAE5D,OAAO,OAAO,UAAU,YAAY,MAAM,SAAS;AACrD"}
+{"version":3,"file":"data-request.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/routing/data-request.ts"],"sourcesContent":["/**\n * The marker that turns a page request into a DATA request.\n *\n * A client navigation needs exactly what a full page load needs — middleware,\n * validation, loaders, redirects, cookies, the settled status — and differs in\n * one respect only: it wants the hydration payload as JSON instead of a\n * rendered document. So it is deliberately NOT a separate `/_loader` route.\n *\n * WHY NOT A SEPARATE ROUTE. A `/_loader?path=/products/42` endpoint has to\n * resolve that path to a page itself, which is a SECOND implementation of route\n * semantics living beside the server's. This codebase already refuses that\n * bargain for the browser — the hydration payload carries the route `name` so\n * the client never re-matches — and the same reasoning applies here with more\n * force: a loader endpoint that disagreed with the real route about params,\n * prefixes or which page owns a path would answer a different request than the\n * one the user navigated to. Same URL, same route, same matcher, same pipeline;\n * only the final representation differs.\n *\n * WHY A HEADER AND NOT `?_data=1`. The query string belongs to the page — it is\n * what `validation` and loaders read. Injecting a framework key into it means a\n * page with strict query validation rejects its own client navigations, and\n * every loader that echoes its query starts leaking a private flag.\n *\n * Responses to a data request must carry `Vary: <this header>` so a shared\n * cache can never hand a document to a client that asked for JSON, or the\n * reverse. Page responses are `private, no-store` today, which makes that\n * theoretical — `Vary` is what keeps it theoretical if the caching policy\n * changes.\n */\nexport const WARLOCK_DATA_REQUEST_HEADER = \"x-warlock-data\";\n\n/**\n * The value the client sends. Any non-empty value is honoured on the way in —\n * the header's PRESENCE is the signal — but the client sends this one so the\n * traffic is self-describing in a log or a network panel.\n */\nexport const WARLOCK_DATA_REQUEST_VALUE = \"1\";\n\n/**\n * Declared explicitly because the payload goes on the wire ALREADY SERIALIZED,\n * as a string, and core only auto-picks `application/json` for object bodies.\n * See the send site for why it must be a string.\n */\nexport const DATA_RESPONSE_CONTENT_TYPE = \"application/json\";\n\n/**\n * Whether a request asked for the payload rather than the document.\n *\n * Presence-based on purpose: a proxy that rewrites the value, or a client on a\n * newer version that sends something more specific, still means \"data\". Only an\n * absent or empty header means \"render the document\".\n */\nexport function isDataRequest(headerValue: string | string[] | undefined): boolean {\n  const value = Array.isArray(headerValue) ? headerValue[0] : headerValue;\n\n  return typeof value === \"string\" && value.length > 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,8BAA8B;;;;;;AAc3C,MAAa,6BAA6B;;;;;;;;AAS1C,SAAgB,cAAc,aAAqD;CACjF,MAAM,QAAQ,MAAM,QAAQ,WAAW,IAAI,YAAY,KAAK;CAE5D,OAAO,OAAO,UAAU,YAAY,MAAM,SAAS;AACrD"}

package/esm/routing/filesystem-route.mjs

@@ -0,0 +1,45 @@
+//#region web/src/routing/filesystem-route.ts
+function isGroup(segment) {
+	return /^\([^/]+\)$/.test(segment);
+}
+function routeSegment(segment) {
+	const dynamic = /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.exec(segment);
+	return dynamic ? `:${dynamic[1]}` : segment;
+}
+function prefixSegments(prefix) {
+	return prefix.split("/").filter(Boolean);
+}
+function pageParts(pageFile) {
+	if (pageFile.includes("\\")) throw new Error(`filesystem-route: pageFile must use POSIX separators: "${pageFile}"`);
+	if (!pageFile.endsWith(".page.tsx")) throw new Error(`filesystem-route: pageFile must end in .page.tsx: "${pageFile}"`);
+	const parts = pageFile.split("/");
+	return {
+		directories: parts,
+		basename: parts.pop().slice(0, -9)
+	};
+}
+/** Derive the effective URL for a page with no explicit `route` export. */
+function deriveFilesystemRoutePath(input) {
+	const { directories, basename } = pageParts(input.pageFile);
+	const prefixes = input.layoutPrefixes ?? {};
+	const segments = [...prefixSegments(prefixes[""] ?? "")];
+	for (let index = 0; index < directories.length; index++) {
+		const directory = directories[index];
+		const prefix = prefixes[directories.slice(0, index + 1).join("/")];
+		if (prefix !== void 0) segments.push(...prefixSegments(prefix));
+		else if (!isGroup(directory)) segments.push(routeSegment(directory));
+	}
+	if (basename !== "index") segments.push(routeSegment(basename));
+	return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+/** Derive the stable dotted route name from a page's filesystem identity. */
+function deriveFilesystemRouteName(pageFile) {
+	const { directories, basename } = pageParts(pageFile);
+	const segments = directories.filter((segment) => !isGroup(segment)).map(routeSegment);
+	if (basename !== "index") segments.push(routeSegment(basename));
+	return segments.map((segment) => segment.replace(/^:/, "")).join(".") || "index";
+}
+
+//#endregion
+export { deriveFilesystemRouteName, deriveFilesystemRoutePath };
+//# sourceMappingURL=filesystem-route.mjs.map

package/esm/routing/filesystem-route.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-route.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/routing/filesystem-route.ts"],"sourcesContent":["export type FilesystemRouteInput = {\n  /** POSIX path relative to `src/web`, ending in `.page.tsx`. */\n  pageFile: string;\n  /** Layout prefixes keyed by their POSIX directory relative to `src/web`; root uses `\"\"`. */\n  layoutPrefixes?: Readonly<Record<string, string>>;\n};\n\nfunction isGroup(segment: string): boolean {\n  return /^\\([^/]+\\)$/.test(segment);\n}\n\nfunction routeSegment(segment: string): string {\n  const dynamic = /^\\[([A-Za-z_][A-Za-z0-9_]*)\\]$/.exec(segment);\n\n  return dynamic ? `:${dynamic[1]}` : segment;\n}\n\nfunction prefixSegments(prefix: string): string[] {\n  return prefix.split(\"/\").filter(Boolean);\n}\n\nfunction pageParts(pageFile: string): { directories: string[]; basename: string } {\n  if (pageFile.includes(\"\\\\\")) {\n    throw new Error(`filesystem-route: pageFile must use POSIX separators: \"${pageFile}\"`);\n  }\n\n  if (!pageFile.endsWith(\".page.tsx\")) {\n    throw new Error(`filesystem-route: pageFile must end in .page.tsx: \"${pageFile}\"`);\n  }\n\n  const parts = pageFile.split(\"/\");\n  const filename = parts.pop() as string;\n\n  return {\n    directories: parts,\n    basename: filename.slice(0, -\".page.tsx\".length),\n  };\n}\n\n/** Derive the effective URL for a page with no explicit `route` export. */\nexport function deriveFilesystemRoutePath(input: FilesystemRouteInput): string {\n  const { directories, basename } = pageParts(input.pageFile);\n  const prefixes = input.layoutPrefixes ?? {};\n  const segments = [...prefixSegments(prefixes[\"\"] ?? \"\")];\n\n  for (let index = 0; index < directories.length; index++) {\n    const directory = directories[index];\n    const directoryPath = directories.slice(0, index + 1).join(\"/\");\n    const prefix = prefixes[directoryPath];\n\n    if (prefix !== undefined) {\n      segments.push(...prefixSegments(prefix));\n    } else if (!isGroup(directory)) {\n      segments.push(routeSegment(directory));\n    }\n  }\n\n  if (basename !== \"index\") {\n    segments.push(routeSegment(basename));\n  }\n\n  return segments.length === 0 ? \"/\" : `/${segments.join(\"/\")}`;\n}\n\n/** Derive the stable dotted route name from a page's filesystem identity. */\nexport function deriveFilesystemRouteName(pageFile: string): string {\n  const { directories, basename } = pageParts(pageFile);\n  const segments = directories.filter((segment) => !isGroup(segment)).map(routeSegment);\n\n  if (basename !== \"index\") {\n    segments.push(routeSegment(basename));\n  }\n\n  return segments.map((segment) => segment.replace(/^:/, \"\")).join(\".\") || \"index\";\n}\n"],"mappings":";AAOA,SAAS,QAAQ,SAA0B;CACzC,OAAO,cAAc,KAAK,OAAO;AACnC;AAEA,SAAS,aAAa,SAAyB;CAC7C,MAAM,UAAU,iCAAiC,KAAK,OAAO;CAE7D,OAAO,UAAU,IAAI,QAAQ,OAAO;AACtC;AAEA,SAAS,eAAe,QAA0B;CAChD,OAAO,OAAO,MAAM,GAAG,EAAE,OAAO,OAAO;AACzC;AAEA,SAAS,UAAU,UAA+D;CAChF,IAAI,SAAS,SAAS,IAAI,GACxB,MAAM,IAAI,MAAM,0DAA0D,SAAS,EAAE;CAGvF,IAAI,CAAC,SAAS,SAAS,WAAW,GAChC,MAAM,IAAI,MAAM,sDAAsD,SAAS,EAAE;CAGnF,MAAM,QAAQ,SAAS,MAAM,GAAG;CAGhC,OAAO;EACL,aAAa;EACb,UAJe,MAAM,IAIJ,EAAE,MAAM,GAAG,EAAmB;CACjD;AACF;;AAGA,SAAgB,0BAA0B,OAAqC;CAC7E,MAAM,EAAE,aAAa,aAAa,UAAU,MAAM,QAAQ;CAC1D,MAAM,WAAW,MAAM,kBAAkB,CAAC;CAC1C,MAAM,WAAW,CAAC,GAAG,eAAe,SAAS,OAAO,EAAE,CAAC;CAEvD,KAAK,IAAI,QAAQ,GAAG,QAAQ,YAAY,QAAQ,SAAS;EACvD,MAAM,YAAY,YAAY;EAE9B,MAAM,SAAS,SADO,YAAY,MAAM,GAAG,QAAQ,CAAC,EAAE,KAAK,GACvB;EAEpC,IAAI,WAAW,QACb,SAAS,KAAK,GAAG,eAAe,MAAM,CAAC;OAClC,IAAI,CAAC,QAAQ,SAAS,GAC3B,SAAS,KAAK,aAAa,SAAS,CAAC;CAEzC;CAEA,IAAI,aAAa,SACf,SAAS,KAAK,aAAa,QAAQ,CAAC;CAGtC,OAAO,SAAS,WAAW,IAAI,MAAM,IAAI,SAAS,KAAK,GAAG;AAC5D;;AAGA,SAAgB,0BAA0B,UAA0B;CAClE,MAAM,EAAE,aAAa,aAAa,UAAU,QAAQ;CACpD,MAAM,WAAW,YAAY,QAAQ,YAAY,CAAC,QAAQ,OAAO,CAAC,EAAE,IAAI,YAAY;CAEpF,IAAI,aAAa,SACf,SAAS,KAAK,aAAa,QAAQ,CAAC;CAGtC,OAAO,SAAS,KAAK,YAAY,QAAQ,QAAQ,MAAM,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;AAC3E"}

package/esm/routing/layout-policy.mjs

@@ -1,4 +1,4 @@
-//#region ../web/src/routing/layout-policy.ts
+//#region web/src/routing/layout-policy.ts
 /**
 * Raised when a `chain` passed to {@link selectPageLayout} contains an empty
 * layout identifier. An empty string is not a layout identifier a caller could