@gradial/aci 0.1.45 → 0.1.47

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'));
+}

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

@@ -0,0 +1,57 @@
+import type { KernelPageBlock } from '../content/types.js';
+import type { ErrorPagePush } from '../content/error-page-kind.js';
+import type { Registry } from '../registry.js';
+/**
+ * Build-time serialization of the bound catchAll page (authorable-error-pages
+ * D-9): Next's error seat is client-only and cannot reach the server content
+ * provider, so withAci() resolves `site.json#errorPages.catchAll` while
+ * next.config is evaluated and injects the page's resolved slots into the
+ * bundle as the `__ACI_ERROR_PAGE__` webpack define (same mechanism as the
+ * middleware's `__ACI_PUBLIC_PATHS__`). Content edits to the bound page
+ * therefore require a code build — accepted by D-4.
+ */
+export interface ErrorSeatPayload {
+    /** True when no binding is authored: render the shipped default (REQ-4). */
+    defaulted: boolean;
+    /** Shipped branded-neutral default fragment — always present as last resort. */
+    defaultHtml: string;
+    route?: string;
+    title?: string;
+    /** Layout slot order, then resolved blocks per slot (fragments included). */
+    slotOrder?: string[];
+    slots?: Record<string, KernelPageBlock[]>;
+}
+/** The build-time serialized payload, or null when the define is absent. */
+export declare function errorSeatPayload(): ErrorSeatPayload | null;
+export interface ErrorSeatProps {
+    registry: Registry;
+    /** Next passes the boundary error; it is logged by Next, never rendered. */
+    error?: (Error & {
+        digest?: string;
+    }) | null;
+    /** Test seam: overrides the build-time serialization when provided. */
+    payload?: ErrorSeatPayload | null;
+    /**
+     * The tenant-owned policy module's push (D-15), forwarded to
+     * ErrorPageInstrumentation; omitted → the SDK default.
+     */
+    pushErrorPageView?: ErrorPagePush;
+}
+/**
+ * The Next app-error seat (`src/app/error.tsx` delegates here). Renders the
+ * bound catchAll page's serialized content entirely from the client bundle —
+ * no fetch, no content provider: the failing system is never re-entered
+ * (ANTI-2). Collect/assignment tags are stripped by construction (REQ-11):
+ * only content blocks are serialized and this renderer emits no script tags.
+ *
+ * Coverage (documented for operators): an error boundary catches render/
+ * lifecycle errors of route segments BELOW the root layout. It does NOT
+ * catch: errors in the root layout itself (Next's global-error seat),
+ * middleware failures, event-handler/async errors, or platform 5xx
+ * (crash/timeout/throttle) — the latter are covered by the emitted
+ * `public/500.html` where the hosting plan supports substitution (REQ-10).
+ *
+ * The seat must never throw: unknown serialized components are skipped, and
+ * a missing/defaulted payload renders the shipped default fragment.
+ */
+export declare function ErrorSeat({ registry, payload, pushErrorPageView }: ErrorSeatProps): import("react").JSX.Element;

package/dist/next/error-seat.js

@@ -0,0 +1,83 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Component, Fragment } from 'react';
+import { ErrorPageInstrumentation } from './error-page-instrumentation.js';
+import { ErrorPageMarker } from './error-page-marker.js';
+/** The build-time serialized payload, or null when the define is absent. */
+export function errorSeatPayload() {
+    return typeof __ACI_ERROR_PAGE__ === 'undefined' ? null : __ACI_ERROR_PAGE__;
+}
+/**
+ * The Next app-error seat (`src/app/error.tsx` delegates here). Renders the
+ * bound catchAll page's serialized content entirely from the client bundle —
+ * no fetch, no content provider: the failing system is never re-entered
+ * (ANTI-2). Collect/assignment tags are stripped by construction (REQ-11):
+ * only content blocks are serialized and this renderer emits no script tags.
+ *
+ * Coverage (documented for operators): an error boundary catches render/
+ * lifecycle errors of route segments BELOW the root layout. It does NOT
+ * catch: errors in the root layout itself (Next's global-error seat),
+ * middleware failures, event-handler/async errors, or platform 5xx
+ * (crash/timeout/throttle) — the latter are covered by the emitted
+ * `public/500.html` where the hosting plan supports substitution (REQ-10).
+ *
+ * The seat must never throw: unknown serialized components are skipped, and
+ * a missing/defaulted payload renders the shipped default fragment.
+ */
+export function ErrorSeat({ registry, payload, pushErrorPageView }) {
+    const data = payload !== undefined ? payload : errorSeatPayload();
+    return (_jsxs(_Fragment, { children: [_jsx(PayloadBoundary, { fallbackHtml: data?.defaultHtml || LAST_RESORT_HTML, children: renderPayload(data, registry) }), _jsx(ErrorPageMarker, { kind: "catchAll" }), _jsx(ErrorPageInstrumentation, { kind: "catchAll", push: pushErrorPageView })] }));
+}
+/**
+ * The seat's own safety net (quorum RISK-004): the serialized payload renders
+ * arbitrary registry components, and one that throws at the error seat would
+ * otherwise take the whole seat down. This client error boundary catches the
+ * render failure and falls back to the shipped default HTML.
+ */
+class PayloadBoundary extends Component {
+    state = { failed: false };
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    render() {
+        if (this.state.failed) {
+            return _jsx("div", { dangerouslySetInnerHTML: { __html: this.props.fallbackHtml } });
+        }
+        return this.props.children;
+    }
+}
+const LAST_RESORT_HTML = '<main style="max-width:26rem;margin:0 auto;padding:4rem 1rem;text-align:center;font-family:system-ui,sans-serif">'
+    + '<h1 style="font-size:1.5rem">Something went wrong.</h1>'
+    + '<p>An unexpected error occurred while serving this page.</p>'
+    + '<a href="/">Back to homepage</a></main>';
+function renderPayload(data, registry) {
+    if (!data || data.defaulted || !data.slots || !data.slotOrder) {
+        return _jsx("div", { dangerouslySetInnerHTML: { __html: data?.defaultHtml || LAST_RESORT_HTML } });
+    }
+    return data.slotOrder.map((slotName) => {
+        const blocks = data.slots?.[slotName];
+        if (!blocks?.length)
+            return null;
+        const rendered = renderClientBlocks(blocks, registry);
+        if (slotName === 'main') {
+            return (_jsx("main", { id: "content-main", children: rendered }, "main"));
+        }
+        return _jsx(Fragment, { children: rendered }, slotName);
+    });
+}
+// A synchronous client-side mirror of next/render renderBlocks (that one is
+// async and server-oriented). Unknown components are skipped — the error
+// seat degrades, it never crashes.
+function renderClientBlocks(blocks, registry) {
+    return blocks.map((block) => {
+        const entry = registry.find((r) => r.id === block.component);
+        if (!entry)
+            return null;
+        const Component = entry.component;
+        const componentProps = { ...block.props };
+        if (entry.contract.blockSlots) {
+            componentProps.renderChildren = (children) => renderClientBlocks(children, registry);
+        }
+        return _jsx(Component, { ...componentProps }, block.id);
+    });
+}

package/dist/next/index.d.ts

@@ -7,3 +7,7 @@ export { PageNotFoundError, FragmentNotFoundError, LayoutNotFoundError } from '.
 export { CollectScript, type CollectScriptProps } from './collect-script.js';
 export { aciMiddlewareMatcher } from './middleware.js';
 export { AssignmentsScript, type AssignmentsScriptProps } from './assignments-script.js';
+export { createNotFound, renderPageForRoute, resolveErrorPage, type NextResolvedErrorPage, } from './error-pages.js';
+export { ErrorPageInstrumentation } from './error-page-instrumentation.js';
+export { ErrorPageMarker } from './error-page-marker.js';
+export { errorPageType, type ErrorPageType } from '../content/error-pages.js';

package/dist/next/index.js

@@ -7,3 +7,11 @@ export { PageNotFoundError, FragmentNotFoundError, LayoutNotFoundError } from '.
 export { CollectScript } from './collect-script.js';
 export { aciMiddlewareMatcher } from './middleware.js';
 export { AssignmentsScript } from './assignments-script.js';
+export { createNotFound, renderPageForRoute, resolveErrorPage, } from './error-pages.js';
+export { ErrorPageInstrumentation } from './error-page-instrumentation.js';
+export { ErrorPageMarker } from './error-page-marker.js';
+// Single definition of the kind→page_type mapping (quorum SIMPLE-005).
+export { errorPageType } from '../content/error-pages.js';
+// NOTE: ErrorSeat is deliberately NOT re-exported here — client components
+// (src/app/error.tsx) must import '@gradial/aci/next/error-seat', because
+// this barrel pulls server-only modules (next/headers).

package/dist/next/middleware.js

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { PREVIEW_TOKEN_COOKIE, PREVIEW_RELEASE_COOKIE, extractPreviewToken, resolvePreviewContext, createPreviewCookies, previewSignKey, } from '../preview/core.js';
 import { CONTENT_PATH_HEADER, CONTENT_PATH_CACHE_PARAM, resolvePersonalizationRequest, } from './personalization-host.js';
+import { activeReleaseV1Key, clampDeploymentCompatibleReleaseV1, decodeActiveReleaseV1, decodeDeploymentCompatibilityV1, deploymentCompatibilityKey, } from './vercel-edge-projection-v1.js';
 const RELEASE_SCOPED_PREFIX = '/__r';
 const FRAMEWORK_ORIGIN_AUTH_HEADER = 'x-gradial-framework-origin-auth';
 const FRAMEWORK_SITE_ID_HEADER = 'x-baremetal-site-id';
@@ -371,73 +372,27 @@ async function activeReleaseFromEdgeConfig(config) {
     if (!edgeConfig || !siteId)
         return '';
     const active = await activeReleasePointer(edgeConfig, siteId);
-    if (!active.releaseId)
+    if (active == null)
         return '';
     const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
     if (!deploymentId)
         return active.releaseId;
-    const compatibility = await getEdgeConfigJSON(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
-    if (!compatibility)
+    const compatibilityValue = await getEdgeConfigValue(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
+    if (compatibilityValue == null)
         return active.releaseId;
-    return clampRelease(active.releaseId, active.sequence || 0, compatibility);
+    return clampDeploymentCompatibleReleaseV1(active, decodeDeploymentCompatibilityV1(compatibilityValue));
 }
 function siteIdForConfig(config) {
     return config.siteId || process.env.ACI_SITE_ID || '';
 }
-async function getEdgeConfigJSON(edgeConfig, key) {
-    const value = await getEdgeConfigValue(edgeConfig, key);
-    if (!value)
-        return null;
-    if (typeof value === 'string') {
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return null;
-        }
-    }
-    return value;
-}
 async function getEdgeConfigValue(edgeConfig, key) {
     return getUncachedEdgeConfigValue(edgeConfig, key);
 }
-function activeReleaseKey(siteId) {
-    return `activeRelease_${edgeKeySegment(siteId)}`;
-}
-function deploymentCompatibilityKey(siteId, deploymentId) {
-    return `deploymentCompatibility_${edgeKeySegment(siteId)}_${edgeKeySegment(deploymentId)}`;
-}
 async function activeReleasePointer(edgeConfig, siteId) {
-    const value = await getEdgeConfigValue(edgeConfig, activeReleaseKey(siteId));
-    if (!value)
-        return { releaseId: '' };
-    if (typeof value === 'string') {
-        try {
-            const parsed = JSON.parse(value);
-            if (parsed.releaseId)
-                return parsed;
-        }
-        catch {
-            return { releaseId: value };
-        }
-        return { releaseId: value };
-    }
-    const pointer = value;
-    return { releaseId: pointer.releaseId || '', sequence: pointer.sequence };
-}
-function clampRelease(activeReleaseId, activeSequence, compatibility) {
-    if (!activeSequence)
-        return activeReleaseId;
-    if (compatibility.minSequence && activeSequence < compatibility.minSequence && compatibility.minReleaseId) {
-        return compatibility.minReleaseId;
-    }
-    if (compatibility.maxSequence && activeSequence > compatibility.maxSequence && compatibility.maxReleaseId) {
-        return compatibility.maxReleaseId;
-    }
-    return activeReleaseId;
-}
-function edgeKeySegment(value) {
-    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+    const value = await getEdgeConfigValue(edgeConfig, activeReleaseV1Key(siteId));
+    if (value == null)
+        return null;
+    return decodeActiveReleaseV1(value);
 }
 function isPassthroughRoute(pathname) {
     return PASSTHROUGH_ROUTES.some((route) => routeMatches(pathname, route));