@gradial/aci 0.1.46 → 0.1.48

package/dist/content/error-pages.js

@@ -0,0 +1,120 @@
+import { normalizeRoute } from './routes.js';
+// The kind/page_type vocabulary is defined once (quorum SIMPLE-005) in the
+// client-safe leaf module ./error-page-kind.ts — THIS module reaches
+// node:path via routes.js, so 'use client' components must import the leaf
+// directly. Re-exported here as the canonical server-side import site.
+export { errorPageType, errorPageInstrumentationTag, defaultPushErrorPageView, serializeErrorPageInstrumentation, } from './error-page-kind.js';
+const ERROR_PAGE_KINDS = ['notFound', 'catchAll'];
+/**
+ * The one D-5 posture config surface, shared by every stack: the same
+ * variable the Go content build and publish materializer read.
+ */
+export const ERROR_PAGES_POSTURE_ENV = 'ACI_ERROR_PAGES_POSTURE';
+/**
+ * Normalizes a raw posture value exactly like the Go side
+ * (`contentbuild.normalizeErrorPagePosture`): absent/empty means warn, and an
+ * unknown value throws so a config typo cannot silently disable enforcement.
+ */
+function normalizeErrorPagePosture(raw) {
+    const value = raw ?? '';
+    if (value === '' || value === 'warn')
+        return 'warn';
+    if (value === 'enforce')
+        return 'enforce';
+    throw new Error(`unknown errorPages validation posture ${JSON.stringify(value)} (want "warn" or "enforce")`);
+}
+/** Reads the D-5 posture from ACI_ERROR_PAGES_POSTURE; throws on unknown values (fail closed). */
+export function errorPagePostureFromEnv(env = process.env) {
+    return normalizeErrorPagePosture(env[ERROR_PAGES_POSTURE_ENV]);
+}
+/** Mirrors the site.schema.json binding pattern: "/<segment>/". */
+export const ERROR_PAGE_ROUTE_PATTERN = /^\/(?:[A-Za-z0-9._~-]+\/)+$/;
+const ERROR_PAGES_ABSENT_WARNING = 'site config has no errorPages bindings; the shipped branded-neutral default error page will be served for 404/5xx — author /404/ and /error/ pages and bind them via site.json#errorPages before the enforce posture lands (authorable-error-pages REQ-4/D-5)';
+/**
+ * Validates the site's error-page bindings under the given posture.
+ * Never throws for validation outcomes: callers fail their build closed on a
+ * non-empty `errors` array.
+ */
+export async function resolveErrorPageBindings(siteConfig, options = {}) {
+    const warnings = [];
+    const errors = [];
+    // Unknown posture values fail closed (quorum BUG-002, Go parity): a typo
+    // in ACI_ERROR_PAGES_POSTURE must never silently mean "warn".
+    let posture;
+    try {
+        posture = normalizeErrorPagePosture(options.posture);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+        return { bindings: null, defaulted: false, warnings, errors };
+    }
+    const raw = siteConfig?.errorPages;
+    if (raw == null) {
+        if (posture === 'enforce') {
+            errors.push('site config requires errorPages.notFound and errorPages.catchAll bindings (posture "enforce")');
+            return { bindings: null, defaulted: false, warnings, errors };
+        }
+        warnings.push(ERROR_PAGES_ABSENT_WARNING);
+        return { bindings: null, defaulted: true, warnings, errors };
+    }
+    // Present bindings are strict in every posture (REQ-5).
+    for (const kind of ERROR_PAGE_KINDS) {
+        const route = raw[kind];
+        if (typeof route !== 'string' || route === '') {
+            errors.push(`errorPages.${kind} binding is required`);
+        }
+        else if (!ERROR_PAGE_ROUTE_PATTERN.test(route)) {
+            errors.push(`errorPages.${kind} "${route}" is not a route path (want "/<segment>/")`);
+        }
+    }
+    if (errors.length > 0) {
+        return { bindings: null, defaulted: false, warnings, errors };
+    }
+    const bindings = { notFound: raw.notFound, catchAll: raw.catchAll };
+    if (options.source) {
+        const routes = await options.source.listRoutes();
+        const byPath = new Map(routes.map((entry) => [entry.path, entry]));
+        for (const kind of ERROR_PAGE_KINDS) {
+            const route = bindings[kind];
+            const normalized = normalizeRoute(route);
+            const entry = byPath.get(normalized);
+            if (!entry) {
+                errors.push(`errorPages.${kind} "${route}" does not resolve to any page`);
+                continue;
+            }
+            if (entry.variants && Object.keys(entry.variants).length > 0) {
+                errors.push(`errorPages.${kind} "${route}" must not have audience or experiment overlays`);
+                continue;
+            }
+            const page = await options.source
+                .getPage(normalized)
+                .catch(() => null);
+            if (!page || page.status !== 'published') {
+                errors.push(`errorPages.${kind} "${route}" must be a published page (status "${page?.status ?? 'unknown'}")`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        return { bindings: null, defaulted: false, warnings, errors };
+    }
+    return { bindings, defaulted: false, warnings, errors };
+}
+/**
+ * Resolves one error-page kind under the warn posture (default). Unlike the
+ * build-time `resolveErrorPageBindings`, this NEVER fails: error surfaces
+ * must not crash and must not re-enter the failing system (ANTI-2), so a
+ * broken binding — which the build already failed closed on (REQ-5) —
+ * degrades to the shipped default with the problem surfaced in `warnings`.
+ */
+export async function resolveErrorPage(kind, siteConfig, options = {}) {
+    const resolution = await resolveErrorPageBindings(siteConfig, options);
+    if (resolution.errors.length > 0 || resolution.defaulted || !resolution.bindings) {
+        return {
+            kind,
+            route: null,
+            defaulted: true,
+            warnings: [...resolution.warnings, ...resolution.errors]
+        };
+    }
+    return { kind, route: resolution.bindings[kind], defaulted: false, warnings: resolution.warnings };
+}

package/dist/content/index.d.ts

@@ -5,3 +5,5 @@ export * from './personalization.js';
 export * from './cache.js';
 export * from './resolve-slots.js';
 export * from './assets.js';
+export * from './default-error-page.js';
+export * from './error-pages.js';

package/dist/content/index.js

@@ -5,3 +5,5 @@ export * from './personalization.js';
 export * from './cache.js';
 export * from './resolve-slots.js';
 export * from './assets.js';
+export * from './default-error-page.js';
+export * from './error-pages.js';

package/dist/content/types.d.ts

@@ -85,9 +85,21 @@ export interface KernelSiteConfig {
         description?: string;
         siteName?: string;
     };
+    /**
+     * Error-page route bindings (authorable-error-pages REQ-1). Both values
+     * are public route paths (`/<segment>/`) resolving to ordinary published
+     * pages. Optional under the warn-then-enforce posture (REQ-4/D-5):
+     * absence is legal and produces a loud build/publish warning plus the
+     * shipped branded-neutral default page.
+     */
+    errorPages?: SiteErrorPages;
     /** Personalization collect-tag config (design/04); absent = disabled. */
     personalization?: SitePersonalizationConfig;
 }
+export interface SiteErrorPages {
+    notFound: string;
+    catchAll: string;
+}
 export interface KernelRouteMetadata {
     title: string;
     description: string;

package/dist/edge/personalization-core.js

@@ -7,7 +7,7 @@ export function selectPersonalizationVariant(request, route, claims, experiments
 export function resolvePersonalizationDecision(request, route, claims, experiments, identity) {
     if (!route)
         return { variant: null, experiment: null };
-    let variant = selectRuleVariant(request, route, claims);
+    let variant = selectRuleVariant(request, route, claims, experiments);
     let experiment = null;
     if (identity && identity.usable && route.variants && experiments) {
         const candidates = Object.values(experiments)
@@ -30,13 +30,17 @@ export function resolvePersonalizationDecision(request, route, claims, experimen
     }
     return { variant: variant || null, experiment };
 }
-function selectRuleVariant(request, route, claims) {
+function selectRuleVariant(request, route, claims, experiments) {
     if (!route.variants)
         return null;
     const matches = [];
     for (const key in route.variants) {
         const variant = route.variants[key];
         const values = variant.variantValues || variantValuesFromKey(key);
+        const experimentID = String(values.experiment || '').trim();
+        if (experimentID && (!experiments || !experiments[experimentID]
+            || experiments[experimentID].status !== 'running'))
+            continue;
         if (!requestDimensionsMatch(request, values))
             continue;
         const membershipMatch = (values.audience && claims && (claims.aud || []).includes(values.audience))

package/dist/next/config.js

@@ -2,6 +2,7 @@ import { readdirSync, existsSync } from 'fs';
 import { join, relative } from 'path';
 import { createRequire } from 'module';
 import { createContentWatchWebpackPlugin } from './content-watch.js';
+import { buildErrorSeatPayload } from './error-seat-payload.js';
 const require = createRequire(import.meta.url);
 export function withAci(nextConfig = {}, options = {}) {
     if (process.env.TURBOPACK) {
@@ -11,6 +12,21 @@ export function withAci(nextConfig = {}, options = {}) {
             '`next dev` / `next build` without --turbopack.');
     }
     const publicPaths = collectPublicPaths(join(process.cwd(), 'public'));
+    // Authorable error pages (D-9): the Next error seat is client-only, so the
+    // bound catchAll page's content is serialized here — while next.config is
+    // evaluated — and injected into the bundle via DefinePlugin below. The D-5
+    // posture rides ACI_ERROR_PAGES_POSTURE (the same variable the Go stack
+    // reads): under warn (default), absent bindings/content and non-REQ-5
+    // serialization failures warn and serialize the shipped default (REQ-4);
+    // under enforce they fail the build closed, and unknown posture values
+    // fail closed too. Present-but-broken bindings fail closed always (REQ-5).
+    const errorSeat = buildErrorSeatPayload(undefined, process.env.ACI_ERROR_PAGES_POSTURE);
+    if (errorSeat.errors.length > 0) {
+        throw new Error(`ACI errorPages bindings are invalid (site.json#errorPages):\n- ${errorSeat.errors.join('\n- ')}`);
+    }
+    for (const warning of errorSeat.warnings) {
+        console.warn(`\n[aci error-pages] WARNING: ${warning}\n`);
+    }
     const passthroughRoutes = normalizePassthroughRoutes(options.passthroughRoutes ?? []);
     const assetPrefix = options.assetPrefix || '/.gradial-dam';
     const assetOrigin = options.assetOrigin || '';
@@ -82,6 +98,7 @@ export function withAci(nextConfig = {}, options = {}) {
                 '__ACI_PUBLIC_PATHS__': JSON.stringify(publicPaths),
                 '__ACI_PASSTHROUGH_ROUTES__': JSON.stringify(passthroughRoutes),
                 '__ACI_ASSET_PREFIX__': JSON.stringify(assetPrefix),
+                '__ACI_ERROR_PAGE__': JSON.stringify(errorSeat.payload),
             }));
             return typeof userWebpack === 'function'
                 ? userWebpack(config, context)

package/dist/next/error-page-instrumentation.d.ts

@@ -0,0 +1,23 @@
+import { type ErrorPageKind, type ErrorPagePush } from '../content/error-page-kind.js';
+/**
+ * Error-surface analytics MECHANISM (authorable-error-pages REQ-12 / D-14 /
+ * D-15): calls the site's push function exactly ONCE per error view with
+ * the D-14 page_type. The push BODY is site policy — the seats forward the
+ * tenant-owned scaffolded module's `pushErrorPageView` via `push`; without
+ * it, `defaultPushErrorPageView` (the scaffolded default's twin) runs.
+ *
+ * Delivery MUST be a 'use client' useEffect: the not-found seat is
+ * client-rendered from the RSC flight payload, where React skips execution
+ * of inline script elements (spike A learning 3). The SDK error seats mount
+ * this only with error render context; ordinary routes — including direct
+ * GET /404/ and /error/ previews — never render it (REQ-12).
+ *
+ * Renders nothing. The seats (createNotFound, ErrorSeat) render the inert
+ * `data-aci-error-page` marker themselves — server-side where possible, so
+ * gates can assert it in fetched documents (a client component's output
+ * never appears in the serialized flight text).
+ */
+export declare function ErrorPageInstrumentation({ kind, push, }: {
+    kind: ErrorPageKind;
+    push?: ErrorPagePush;
+}): null;

package/dist/next/error-page-instrumentation.js

@@ -0,0 +1,36 @@
+'use client';
+import { useEffect } from 'react';
+// Client-safe leaf import — see error-page-marker.tsx.
+import { defaultPushErrorPageView, errorPageType, } from '../content/error-page-kind.js';
+/**
+ * Error-surface analytics MECHANISM (authorable-error-pages REQ-12 / D-14 /
+ * D-15): calls the site's push function exactly ONCE per error view with
+ * the D-14 page_type. The push BODY is site policy — the seats forward the
+ * tenant-owned scaffolded module's `pushErrorPageView` via `push`; without
+ * it, `defaultPushErrorPageView` (the scaffolded default's twin) runs.
+ *
+ * Delivery MUST be a 'use client' useEffect: the not-found seat is
+ * client-rendered from the RSC flight payload, where React skips execution
+ * of inline script elements (spike A learning 3). The SDK error seats mount
+ * this only with error render context; ordinary routes — including direct
+ * GET /404/ and /error/ previews — never render it (REQ-12).
+ *
+ * Renders nothing. The seats (createNotFound, ErrorSeat) render the inert
+ * `data-aci-error-page` marker themselves — server-side where possible, so
+ * gates can assert it in fetched documents (a client component's output
+ * never appears in the serialized flight text).
+ */
+export function ErrorPageInstrumentation({ kind, push, }) {
+    const pageType = errorPageType(kind);
+    useEffect(() => {
+        let effectivePush = push ?? defaultPushErrorPageView;
+        if (typeof effectivePush !== 'function') {
+            // FIND-002: a non-function push (broken config plumbing) must degrade
+            // to the default, never crash the error surface itself.
+            console.warn('[aci error-pages] pushErrorPageView is not a function; using the SDK default push (D-15)');
+            effectivePush = defaultPushErrorPageView;
+        }
+        effectivePush(pageType);
+    }, [pageType, push]);
+    return null;
+}

package/dist/next/error-page-marker.d.ts

@@ -0,0 +1,11 @@
+import { type ErrorPageKind } from '../content/error-page-kind.js';
+/**
+ * Inert, invisible marker naming the error surface
+ * (`data-aci-error-page="not_found"|"error"`). Rendered by the seats next to
+ * ErrorPageInstrumentation as the fetch-level assertion hook for build and
+ * serve gates; its absence on ordinary routes proves direct /404/ and
+ * /error/ visits carry no error-typed instrumentation (REQ-12).
+ */
+export declare function ErrorPageMarker({ kind }: {
+    kind: ErrorPageKind;
+}): import("react").JSX.Element;

package/dist/next/error-page-marker.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Deliberately NO 'use client' directive: this module is shared by the
+// server-rendered not-found seat and the client-only error seat. At the
+// not-found seat the marker must be a SERVER-rendered element so it lands in
+// the RSC flight payload — a client component's rendered output never
+// appears in the serialized document, which is exactly why the build/serve
+// gates could not assert a marker owned by ErrorPageInstrumentation.
+// Import the client-safe leaf directly: content/error-pages.js reaches
+// node:path via routes.js, which webpack rejects in browser bundles.
+import { errorPageType } from '../content/error-page-kind.js';
+/**
+ * Inert, invisible marker naming the error surface
+ * (`data-aci-error-page="not_found"|"error"`). Rendered by the seats next to
+ * ErrorPageInstrumentation as the fetch-level assertion hook for build and
+ * serve gates; its absence on ordinary routes proves direct /404/ and
+ * /error/ visits carry no error-typed instrumentation (REQ-12).
+ */
+export function ErrorPageMarker({ kind }) {
+    return _jsx("span", { hidden: true, "data-aci-error-page": errorPageType(kind) });
+}

package/dist/next/error-pages.d.ts

@@ -0,0 +1,52 @@
+import type { ReactElement } from 'react';
+import { type FetchConfig } from './server.js';
+import { type ErrorPageKind, type ErrorPagePush, type ResolvedErrorPage } from '../content/error-pages.js';
+import type { KernelSiteConfig } from '../content/types.js';
+import type { Registry } from '../registry.js';
+/**
+ * Next runtime seams for authorable error pages (REQ-6, 02-design "SDK
+ * core"): `resolveErrorPage(kind)` + `renderPageForRoute(route)` — the pair
+ * both spike wrappers hand-rolled — plus `createNotFound(registry)`, which
+ * composes them so the starter's `not-found.tsx` stays thin.
+ */
+export interface NextResolvedErrorPage extends ResolvedErrorPage {
+    siteConfig: KernelSiteConfig | null;
+}
+/**
+ * Resolves one error-page binding from the active site config under the
+ * warn posture (D-5). Never throws: an unreachable site config degrades to
+ * the shipped default — an error surface must not re-enter the failing
+ * system (ANTI-2).
+ */
+export declare function resolveErrorPage(kind: ErrorPageKind, config?: FetchConfig): Promise<NextResolvedErrorPage>;
+/**
+ * Renders the content page bound to `route` through the normal page
+ * pipeline (createPage: layout slots, fragments, registry blocks, collect/
+ * assignments tags), resolving to the same tree the catch-all route would
+ * serve. Throws whatever the pipeline throws — including the notFound()
+ * control error for missing content — so callers at error seats must wrap
+ * it (createNotFound does).
+ */
+export declare function renderPageForRoute(registry: Registry, route: string): Promise<ReactElement>;
+/**
+ * The shipped branded-neutral default error page (REQ-4/D-5) as an inline
+ * fragment — used when no binding exists or the bound content cannot be
+ * rendered. Self-contained by construction (inline styles only, REQ-14).
+ */
+export declare function DefaultErrorPageContent(): import("react").JSX.Element;
+/**
+ * Builds the component for Next's native not-found seat
+ * (`src/app/not-found.tsx`). The SDK catch-all invokes `notFound()` on
+ * missing content, so this renders with a real HTTP 404 (REQ-3/REQ-6).
+ *
+ * Fallback contract: if the bound notFound content is itself missing or
+ * fails to render at request time, the shipped default renders INLINE —
+ * the seat never re-invokes notFound() (a recursive seat was the spike's
+ * kill-list item) and never throws.
+ *
+ * `pushErrorPageView` (D-15): the tenant-owned policy module's push,
+ * forwarded to ErrorPageInstrumentation; omitted → the SDK default.
+ */
+export declare function createNotFound(registry: Registry, config?: FetchConfig & {
+    pushErrorPageView?: ErrorPagePush;
+}): () => Promise<ReactElement>;

package/dist/next/error-pages.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { headers } from 'next/headers.js';
+import { createPage } from './page.js';
+import { getSiteConfig } from './server.js';
+import { resolveErrorPage as resolveErrorPageForSite, } from '../content/error-pages.js';
+import { defaultErrorPageFragmentHtml } from '../content/default-error-page.js';
+import { ErrorPageInstrumentation } from './error-page-instrumentation.js';
+import { ErrorPageMarker } from './error-page-marker.js';
+/**
+ * Resolves one error-page binding from the active site config under the
+ * warn posture (D-5). Never throws: an unreachable site config degrades to
+ * the shipped default — an error surface must not re-enter the failing
+ * system (ANTI-2).
+ */
+export async function resolveErrorPage(kind, config = {}) {
+    let siteConfig = null;
+    const warnings = [];
+    try {
+        siteConfig = await getSiteConfig(config);
+    }
+    catch (error) {
+        warnings.push(`site config unavailable at the error seat: ${String(error)}`);
+    }
+    const resolved = await resolveErrorPageForSite(kind, siteConfig);
+    return { ...resolved, warnings: [...warnings, ...resolved.warnings], siteConfig };
+}
+/**
+ * Renders the content page bound to `route` through the normal page
+ * pipeline (createPage: layout slots, fragments, registry blocks, collect/
+ * assignments tags), resolving to the same tree the catch-all route would
+ * serve. Throws whatever the pipeline throws — including the notFound()
+ * control error for missing content — so callers at error seats must wrap
+ * it (createNotFound does).
+ */
+export async function renderPageForRoute(registry, route) {
+    const page = createPage(registry);
+    const slug = route.split('/').filter(Boolean);
+    return await page.default({ params: Promise.resolve({ slug }) });
+}
+/**
+ * The shipped branded-neutral default error page (REQ-4/D-5) as an inline
+ * fragment — used when no binding exists or the bound content cannot be
+ * rendered. Self-contained by construction (inline styles only, REQ-14).
+ */
+export function DefaultErrorPageContent() {
+    return _jsx("div", { dangerouslySetInnerHTML: { __html: defaultErrorPageFragmentHtml() } });
+}
+/**
+ * Builds the component for Next's native not-found seat
+ * (`src/app/not-found.tsx`). The SDK catch-all invokes `notFound()` on
+ * missing content, so this renders with a real HTTP 404 (REQ-3/REQ-6).
+ *
+ * Fallback contract: if the bound notFound content is itself missing or
+ * fails to render at request time, the shipped default renders INLINE —
+ * the seat never re-invokes notFound() (a recursive seat was the spike's
+ * kill-list item) and never throws.
+ *
+ * `pushErrorPageView` (D-15): the tenant-owned policy module's push,
+ * forwarded to ErrorPageInstrumentation; omitted → the SDK default.
+ */
+export function createNotFound(registry, config = {}) {
+    return async function NotFound() {
+        // Force dynamic rendering: Next prerenders /_not-found at build time,
+        // where no content provider is reachable. The DYNAMIC_SERVER_USAGE
+        // bailout must propagate for Next to mark the route dynamic; outside a
+        // request scope (unit tests, tooling) headers() just throws and is
+        // ignored.
+        try {
+            await headers();
+        }
+        catch (error) {
+            const digest = error?.digest;
+            if (typeof digest === 'string' && digest.startsWith('DYNAMIC_SERVER_USAGE'))
+                throw error;
+        }
+        const resolved = await resolveErrorPage('notFound', config);
+        for (const warning of resolved.warnings) {
+            console.warn(`[aci error-pages] ${warning}`);
+        }
+        let content = null;
+        if (resolved.route) {
+            try {
+                content = await renderPageForRoute(registry, resolved.route);
+            }
+            catch (error) {
+                // Includes the pipeline's own notFound() control error: bound
+                // content missing at request time → shipped default, inline.
+                console.warn(`[aci error-pages] bound notFound page "${resolved.route}" failed to render; serving the shipped default: ${String(error)}`);
+                content = null;
+            }
+        }
+        return (_jsxs(_Fragment, { children: [content ?? _jsx(DefaultErrorPageContent, {}), _jsx(ErrorPageMarker, { kind: "notFound" }), _jsx(ErrorPageInstrumentation, { kind: "notFound", push: config.pushErrorPageView })] }));
+    };
+}

package/dist/next/error-seat-payload.d.ts

@@ -0,0 +1,33 @@
+import type { ErrorSeatPayload } from './error-seat.js';
+/**
+ * Build-time serialization of the bound catchAll page for the client-only
+ * Next error seat (authorable-error-pages D-9). Synchronous by design: it
+ * runs inside withAci() while next.config is evaluated, reading the compiled
+ * content tree directly (the async providers cannot be awaited there).
+ *
+ * Posture (REQ-4/REQ-5, D-5 warn-then-enforce; `posture` carries the
+ * ACI_ERROR_PAGES_POSTURE value, unknown values fail closed):
+ * - warn (default): absent bindings or absent compiled content → defaulted
+ *   payload + warnings (withAci surfaces them loudly);
+ * - enforce: absent bindings/content are errors and withAci fails closed;
+ * - present-but-broken bindings — exactly the enumerated REQ-5 failures
+ *   (malformed route, unresolved page, unpublished page, audience/experiment
+ *   overlays — REQ-11) → `errors` in BOTH postures;
+ * - ANY other exception (stale/corrupt compiled content, old manifest
+ *   shapes) warns-and-defaults under warn and errors only under enforce, so
+ *   a stale .aci/compiled tree can never break a binding-less build.
+ *
+ * NOTE: this is a SYNCHRONOUS twin of the async binding validation in
+ * `src/content/error-pages.ts` (resolveErrorPageBindings). Keep the REQ-5
+ * semantics in lockstep when editing either; extraction is deferred.
+ *
+ * REQ-11 stripping is by construction: only the page's resolved content
+ * blocks are serialized — no collect/assignment tags, and the page-level
+ * `experiments` assignment context is dropped.
+ */
+export interface ErrorSeatPayloadResult {
+    payload: ErrorSeatPayload;
+    warnings: string[];
+    errors: string[];
+}
+export declare function buildErrorSeatPayload(contentRoot?: string, posture?: string): ErrorSeatPayloadResult;

package/dist/next/error-seat-payload.js

@@ -0,0 +1,143 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { ERROR_PAGE_ROUTE_PATTERN } from '../content/error-pages.js';
+import { defaultErrorPageFragmentHtml } from '../content/default-error-page.js';
+import { normalizeRoute } from '../content/routes.js';
+export function buildErrorSeatPayload(contentRoot, posture) {
+    const warnings = [];
+    const errors = [];
+    const defaultHtml = defaultErrorPageFragmentHtml();
+    const defaulted = () => ({
+        payload: { defaulted: true, defaultHtml },
+        warnings,
+        errors,
+    });
+    // Unknown posture values fail closed (quorum BUG-002, Go parity).
+    let effectivePosture;
+    const rawPosture = posture ?? '';
+    if (rawPosture === '' || rawPosture === 'warn') {
+        effectivePosture = 'warn';
+    }
+    else if (rawPosture === 'enforce') {
+        effectivePosture = 'enforce';
+    }
+    else {
+        errors.push(`unknown errorPages validation posture ${JSON.stringify(rawPosture)} (want "warn" or "enforce")`);
+        return defaulted();
+    }
+    const root = path.resolve(process.cwd(), contentRoot || process.env.ACI_CONTENT_ROOT || '.aci/compiled');
+    if (!existsSync(path.join(root, 'manifest.json'))) {
+        const message = `no compiled content at ${root}; the error seat will serve the shipped default page — `
+            + 'run the content compile before `next build` (the template build script\'s '
+            + '`emit-error-pages.mjs prepare` phase does this)';
+        if (effectivePosture === 'enforce') {
+            errors.push(`${message} (posture "enforce" fails closed, D-5)`);
+        }
+        else {
+            warnings.push(message);
+        }
+        return defaulted();
+    }
+    try {
+        const manifest = readJSON(root, 'manifest.json');
+        const siteConfig = readJSON(root, manifest.siteConfigRef);
+        const bindings = siteConfig.errorPages;
+        if (bindings == null) {
+            if (effectivePosture === 'enforce') {
+                errors.push('site config requires errorPages.notFound and errorPages.catchAll bindings (posture "enforce", D-5)');
+                return defaulted();
+            }
+            warnings.push('site config has no errorPages bindings; the error seat will serve the shipped '
+                + 'branded-neutral default page — author /404/ and /error/ pages and bind them via '
+                + 'site.json#errorPages (authorable-error-pages REQ-4/D-5)');
+            return defaulted();
+        }
+        // Present bindings are strict in every posture (REQ-5): BOTH kinds are
+        // validated here so a broken notFound binding fails `next build` too,
+        // even though only catchAll is serialized for the error seat.
+        let catchAllEntry = null;
+        for (const kind of ['notFound', 'catchAll']) {
+            const route = bindings[kind];
+            if (typeof route !== 'string' || !ERROR_PAGE_ROUTE_PATTERN.test(route)) {
+                errors.push(`errorPages.${kind} ${JSON.stringify(route)} is not a route path (want "/<segment>/")`);
+                continue;
+            }
+            const normalized = normalizeRoute(route);
+            const entry = Object.values(manifest.routes).find((candidate) => normalizeRoute(candidate.path) === normalized);
+            if (!entry) {
+                errors.push(`errorPages.${kind} "${route}" does not resolve to any page`);
+                continue;
+            }
+            if (entry.variants && Object.keys(entry.variants).length > 0) {
+                errors.push(`errorPages.${kind} "${route}" must not have audience or experiment overlays (REQ-11)`);
+                continue;
+            }
+            const boundPage = readJSON(root, entry.payloadRef);
+            if (boundPage.status !== 'published') {
+                errors.push(`errorPages.${kind} "${route}" must be a published page (status "${boundPage.status}")`);
+                continue;
+            }
+            if (kind === 'catchAll')
+                catchAllEntry = entry;
+        }
+        if (errors.length > 0 || !catchAllEntry) {
+            return defaulted();
+        }
+        const route = bindings.catchAll;
+        const page = readJSON(root, catchAllEntry.payloadRef);
+        const layout = readJSON(root, `layouts/${page.layout}.json`);
+        const slots = {};
+        const slotOrder = [];
+        for (const slot of layout.slots) {
+            slotOrder.push(slot.name);
+            const pageBlocks = page.regions?.[slot.name];
+            if (pageBlocks?.length) {
+                slots[slot.name] = pageBlocks;
+                continue;
+            }
+            const defaults = layout.defaults?.[slot.name];
+            if (!defaults?.length)
+                continue;
+            const blocks = [];
+            for (const ref of defaults) {
+                const fragmentRef = manifest.fragments[ref.fragmentId]?.payloadRef;
+                if (!fragmentRef)
+                    continue;
+                const fragment = readJSON(root, fragmentRef);
+                blocks.push({ id: fragment.id, component: fragment.component, props: fragment.props || {} });
+            }
+            if (blocks.length)
+                slots[slot.name] = blocks;
+        }
+        return {
+            payload: {
+                defaulted: false,
+                defaultHtml,
+                route,
+                title: page.metadata?.title,
+                slotOrder,
+                slots,
+            },
+            warnings,
+            errors,
+        };
+    }
+    catch (error) {
+        // Not one of the enumerated REQ-5 binding failures (those are pushed to
+        // `errors` above): stale/corrupt compiled content or an old manifest
+        // shape. Warn-and-default under the warn posture so it can never break a
+        // build; fail closed only under enforce (quorum RISK-002).
+        const message = `error-seat serialization failed reading compiled content at ${root}: ${String(error)}`
+            + ' — the error seat will serve the shipped default page; recompile the content (.aci/compiled) to clear this';
+        if (effectivePosture === 'enforce') {
+            errors.push(`${message} (posture "enforce" fails closed, D-5)`);
+        }
+        else {
+            warnings.push(message);
+        }
+        return defaulted();
+    }
+}
+function readJSON(root, ref) {
+    return JSON.parse(readFileSync(path.join(root, ref), 'utf8'));
+}