@gradial/aci 0.1.45 → 0.1.47

package/dist/cli/emit-error-pages.mjs

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+// Authorable error pages — build integration (spec:
+// specs/features/authorable-error-pages, T3/T11; REQ-10/REQ-11/REQ-14, D-9,
+// D-16).
+//
+// Two phases. The Next template wires both around `next build`; the Astro
+// template runs only `prepare` before `astro build` (its 404/500 seats
+// render through the framework, but the D-16 instrumentation artifact must
+// still reach the compiled content root for the AWS lane):
+//
+//   prepare  (before `next build`)
+//     Ensures compiled content exists at .aci/compiled so withAci() can
+//     serialize the bound catchAll page for the client-only error seat
+//     (D-9). Compiles ./.content via the platform CLI when needed; when
+//     neither compiled content nor authored content exists, it warns and
+//     leaves the shipped default in play (REQ-4, warn posture). Then writes
+//     error-pages/instrumentation.json (both kinds' serialized tags) into
+//     the compiled content root so the tag crosses the JS→Go boundary as
+//     data: the AWS-lane code capsule packs source/.aci/compiled/** and the
+//     Go publish materializer stamps the kind-matching tag into the CDN
+//     error artifacts (D-16). An unserializable tenant push fails the build
+//     loudly here (delta FIND-006).
+//
+//   emit     (after `next build`)
+//     Materializes `public/500.html` from the page bound to
+//     site.json#errorPages.catchAll by booting the standalone build,
+//     fetching the bound route, and post-processing the document. Boot-and-
+//     fetch beats re-rendering the page here because the standalone server
+//     is the only renderer that produces the document exactly as served
+//     (layout shell, resolved fragments, RSC-injected head and styles).
+//     Post-processing:
+//       - all script tags and preload/prefetch links stripped — this
+//         removes the collect and assignment tags (REQ-11) along with the
+//         framework runtime, which is useless in a statically served copy;
+//       - same-origin stylesheets inlined from .next/static (REQ-14 spirit:
+//         inline styles; note @font-face/image URLs inside the CSS keep
+//         their same-origin paths — this copy is served by the Vercel
+//         platform on the deployment that owns those assets);
+//       - one self-contained inline script appended pushing the D-14
+//         `page_view` (page_type "error") — a static document executes
+//         inline scripts, unlike the flight-rendered not-found seat. The
+//         push body is site policy (D-15): the tenant-owned
+//         src/aci/error-page-instrumentation.mjs when present, the SDK
+//         default otherwise;
+//       - hard size budget: ≤150 KB raw (REQ-14) — exceeding it fails the
+//         build; trimming the design system or falling back to system
+//         fonts is the sanctioned escape hatch.
+//     Skips when the site already provides its own public/500.html (a file
+//     without the generation marker); regenerates its own prior output.
+//     Absent bindings emit the shipped branded-neutral default (REQ-4).
+//     Vercel picks static per-status files out of the build output
+//     ("file presence = configuration"); on the current Pro plan the file
+//     serves app-level 500s only and lights up for platform 5xx on a plan
+//     upgrade (REQ-10, P-1).
+//
+// Usage: node ./node_modules/@gradial/aci/src/cli/emit-error-pages.mjs <prepare|emit>
+import { execFileSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const MARKER = '<!-- aci:error-pages generated -->';
+const SIZE_BUDGET = 150 * 1024;
+const BOOT_DEADLINE_MS = 60_000;
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const siteRoot = process.cwd();
+const contentRoot = path.resolve(siteRoot, process.env.ACI_CONTENT_ROOT || '.aci/compiled');
+function log(message) {
+    console.log(`[aci error-pages] ${message}`);
+}
+function warn(message) {
+    console.warn(`\n[aci error-pages] WARNING: ${message}\n`);
+}
+function fail(message) {
+    console.error(`\n[aci error-pages] ERROR: ${message}\n`);
+    process.exit(1);
+}
+async function sdkContent() {
+    return await import(pathToFileURL(path.join(packageRoot, 'dist', 'content', 'index.js')).href);
+}
+function hasCompiledContent() {
+    return fs.existsSync(path.join(contentRoot, 'manifest.json'));
+}
+// ---------------------------------------------------------------------------
+// prepare
+// ---------------------------------------------------------------------------
+async function prepare() {
+    if (hasCompiledContent()) {
+        log(`compiled content present at ${contentRoot}`);
+    }
+    else {
+        const authored = path.join(siteRoot, '.content');
+        if (!fs.existsSync(authored)) {
+            warn(`neither compiled content (${contentRoot}) nor authored content (./.content) exists; `
+                + 'the error seat and 500.html will serve the shipped default page (REQ-4)');
+        }
+        else {
+            log('compiling ./.content for the error-page build steps');
+            execFileSync('node', [path.join(packageRoot, 'bin', 'aci.js'), 'content', 'compile', '--content', authored, '--out', contentRoot], { cwd: siteRoot, stdio: 'inherit' });
+        }
+    }
+    // D-16: the instrumentation artifact rides the compiled content root into
+    // the AWS-lane code capsule (source/.aci/compiled/**). Written even when
+    // content is absent — the tenant policy module is independent of authored
+    // content, and an artifact the Go materializer never receives silently
+    // degrades to the default tags (the exact gap D-16 closes).
+    try {
+        await writeInstrumentationArtifact();
+    }
+    catch (error) {
+        fail(error.message);
+    }
+}
+// ---------------------------------------------------------------------------
+// emit
+// ---------------------------------------------------------------------------
+async function resolveCatchAllRoute() {
+    const { resolveErrorPageBindings, defaultErrorPageHtml, errorPagePostureFromEnv } = await sdkContent();
+    // D-5 posture: the one shared config surface (ACI_ERROR_PAGES_POSTURE);
+    // unknown values fail closed here just like the Go stack.
+    let posture;
+    try {
+        posture = errorPagePostureFromEnv();
+    }
+    catch (error) {
+        fail(error.message);
+    }
+    if (!hasCompiledContent()) {
+        if (posture === 'enforce') {
+            fail(`no compiled content at ${contentRoot}; the enforce posture fails closed (D-5)`);
+        }
+        warn(`no compiled content at ${contentRoot}; emitting the shipped default 500.html (REQ-4)`);
+        return { route: null, defaultHtml: defaultErrorPageHtml() };
+    }
+    const { FileContentProvider } = await import(pathToFileURL(path.join(packageRoot, 'dist', 'providers', 'file.js')).href);
+    const provider = new FileContentProvider(contentRoot);
+    const siteConfig = await provider.getSiteConfig();
+    const resolution = await resolveErrorPageBindings(siteConfig, { source: provider, posture });
+    if (resolution.errors.length > 0) {
+        fail(`errorPages bindings are invalid (REQ-5, fail closed):\n- ${resolution.errors.join('\n- ')}`);
+    }
+    for (const warning of resolution.warnings)
+        warn(warning);
+    if (resolution.defaulted || !resolution.bindings) {
+        return { route: null, defaultHtml: defaultErrorPageHtml() };
+    }
+    return { route: resolution.bindings.catchAll, defaultHtml: defaultErrorPageHtml() };
+}
+async function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const { port } = server.address();
+            server.close(() => resolve(port));
+        });
+    });
+}
+async function fetchRenderedRoute(route) {
+    const serverPath = path.join(siteRoot, '.next', 'standalone', 'server.js');
+    if (!fs.existsSync(serverPath)) {
+        fail(`${serverPath} missing — the emit phase must run after \`next build\` (withAci uses standalone output)`);
+    }
+    const port = await freePort();
+    const logChunks = [];
+    const child = spawn('node', [serverPath], {
+        cwd: siteRoot,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            NODE_ENV: 'production',
+            PORT: String(port),
+            HOSTNAME: '127.0.0.1',
+            ACI_CONTENT_PROVIDER: 'file',
+            ACI_CONTENT_ROOT: contentRoot,
+        },
+    });
+    child.stdout.on('data', (c) => logChunks.push(String(c)));
+    child.stderr.on('data', (c) => logChunks.push(String(c)));
+    const exited = new Promise((resolve) => {
+        child.on('exit', resolve);
+        child.on('error', (error) => {
+            logChunks.push(`spawn failed: ${error.message}\n`);
+            resolve(null);
+        });
+    });
+    try {
+        const url = `http://127.0.0.1:${port}${route}`;
+        const start = Date.now();
+        let last = 'no attempt made';
+        while (Date.now() - start < BOOT_DEADLINE_MS) {
+            try {
+                const response = await fetch(url, { redirect: 'follow' });
+                if (response.status === 200)
+                    return await response.text();
+                last = `status ${response.status}`;
+            }
+            catch (error) {
+                last = error.message;
+            }
+            await new Promise((r) => setTimeout(r, 500));
+        }
+        fail(`GET ${url} did not render within ${BOOT_DEADLINE_MS}ms (last: ${last})\n--- server output ---\n${logChunks.join('').slice(-4000)}`);
+        return '';
+    }
+    finally {
+        const killGroup = (signal) => {
+            if (!child.pid)
+                return;
+            try {
+                process.kill(-child.pid, signal);
+            }
+            catch { /* gone */ }
+        };
+        killGroup('SIGTERM');
+        const killTimer = setTimeout(() => killGroup('SIGKILL'), 10_000);
+        await exited;
+        clearTimeout(killTimer);
+        killGroup('SIGKILL');
+    }
+}
+function inlineStylesheets(html) {
+    return html.replace(/<link\b[^>]*rel="stylesheet"[^>]*>/gi, (tag) => {
+        const href = tag.match(/href="([^"]+)"/i)?.[1];
+        if (!href || !href.startsWith('/_next/')) {
+            warn(`dropping non-inlinable stylesheet ${href ?? '<unknown>'} from 500.html (self-containment, REQ-14)`);
+            return '';
+        }
+        const cssPath = path.join(siteRoot, '.next', href.replace(/^\/_next\//, ''));
+        if (!fs.existsSync(cssPath)) {
+            warn(`stylesheet ${href} not found in .next output; dropping it from 500.html`);
+            return '';
+        }
+        return `<style>${fs.readFileSync(cssPath, 'utf8')}</style>`;
+    });
+}
+// Relative convention path of the tenant-owned instrumentation policy
+// module (D-15, code-organization R-14).
+const INSTRUMENTATION_MODULE = path.join('src', 'aci', 'error-page-instrumentation.mjs');
+/**
+ * D-15 policy resolution for the 500.html instrumentation tag (page_type
+ * "error"; self-contained inline delivery — this copy is a real static
+ * document where inline scripts execute). Convention path: the tenant-owned
+ * `src/aci/error-page-instrumentation.mjs` exporting `pushErrorPageView` is
+ * serialized via the SDK mechanism; absent → the SDK default tag. A module
+ * that EXISTS but fails to import or lacks the export fails the emit loudly:
+ * a typo'd policy module silently reverting to the default is the failure
+ * mode D-15 guards against. The source used is logged either way.
+ *
+ * Exported for unit tests; `content` injects the SDK content functions so
+ * tests stay dist-free (at runtime they arrive through the same lazy dist
+ * import every other SDK internal uses here, sdkContent).
+ */
+export async function resolveInstrumentationTag(root = siteRoot, content) {
+    const sdk = content ?? (await sdkContent());
+    const push = await resolveInstrumentationPush(root);
+    if (!push)
+        return sdk.errorPageInstrumentationTag('catchAll');
+    return sdk.serializeErrorPageInstrumentation(push, 'catchAll');
+}
+/**
+ * Resolves the tenant policy module's push function by the D-15 convention
+ * path. Absent module → null (callers fall back to the SDK default); a
+ * module that exists but fails to import or lacks the export throws — a
+ * typo'd policy module silently reverting to the default is the failure
+ * mode D-15 guards against. The source used is logged either way.
+ */
+async function resolveInstrumentationPush(root = siteRoot) {
+    const modulePath = path.join(root, INSTRUMENTATION_MODULE);
+    if (!fs.existsSync(modulePath)) {
+        log(`instrumentation source: SDK default (no ${INSTRUMENTATION_MODULE})`);
+        return null;
+    }
+    let policy;
+    try {
+        policy = await import(pathToFileURL(modulePath).href);
+    }
+    catch (error) {
+        throw new Error(`${INSTRUMENTATION_MODULE} exists but failed to import: ${error.message}\n`
+            + 'A broken policy module must not silently revert to the SDK default (D-15); '
+            + 'fix the module or delete it to use the default.');
+    }
+    if (typeof policy.pushErrorPageView !== 'function') {
+        throw new Error(`${INSTRUMENTATION_MODULE} does not export a pushErrorPageView function (D-15 policy contract); `
+            + 'export one or delete the file to use the SDK default.');
+    }
+    log(`instrumentation source: site module ${INSTRUMENTATION_MODULE}`);
+    return policy.pushErrorPageView;
+}
+/**
+ * D-16 prepare-phase artifact: serializes BOTH kinds' instrumentation tags
+ * (tenant module when present, SDK default otherwise) into
+ * error-pages/instrumentation.json under the compiled content root. The
+ * AWS-lane code capsule packs source/.aci/compiled/**, so the Go publish
+ * materializer reads this file from the capsule and stamps the kind-matching
+ * tag into the CDN error artifacts — the tag crosses the JS→Go boundary as
+ * data. Serialization failures (bind/method-shorthand exports, FIND-006)
+ * throw before anything is written.
+ *
+ * Exported for unit tests; `content` and `outRoot` are injected there like
+ * resolveInstrumentationTag's `content`.
+ */
+export async function writeInstrumentationArtifact(root = siteRoot, content, outRoot = contentRoot) {
+    const sdk = content ?? (await sdkContent());
+    const push = await resolveInstrumentationPush(root);
+    const tagFor = (kind) => (push
+        ? sdk.serializeErrorPageInstrumentation(push, kind)
+        : sdk.errorPageInstrumentationTag(kind));
+    const artifact = {
+        version: 1,
+        notFound: tagFor('notFound'),
+        error: tagFor('catchAll'),
+    };
+    const dir = path.join(outRoot, 'error-pages');
+    fs.mkdirSync(dir, { recursive: true });
+    const target = path.join(dir, 'instrumentation.json');
+    fs.writeFileSync(target, `${JSON.stringify(artifact)}\n`);
+    log(`wrote ${path.relative(root, target) || target} (D-16 instrumentation transport)`);
+    return target;
+}
+/**
+ * Appends the D-14 instrumentation script tag and the generation marker
+ * before </body>. Exported for unit tests (the tag is a parameter so the
+ * function stays synchronous and dist-free there). Throws when the document
+ * has no </body> (quorum BUG-003): writing an UNMARKED 500.html would poison
+ * every later build via the skip-if-present contract, so the emit fails
+ * loudly instead.
+ */
+export function stampInstrumentation(html, instrumentationTag) {
+    const stamped = html.replace(/<\/body>/i, `${instrumentationTag}\n${MARKER}\n</body>`);
+    if (!stamped.includes(MARKER)) {
+        throw new Error('rendered HTML has no </body> tag, so the instrumentation script and generation marker '
+            + 'could not be appended; refusing to write an unmarked public/500.html (skip-if-present contract)');
+    }
+    return stamped;
+}
+function postProcess(html, instrumentationTag) {
+    let out = html;
+    // Strip every script tag: framework runtime chunks are dead weight in a
+    // statically served copy, and this removes the collect script and the
+    // data-aci-assignments tag (REQ-11) in one sweep.
+    out = out.replace(/<script\b[\s\S]*?<\/script>/gi, '');
+    out = out.replace(/<link\b[^>]*rel="(?:preload|modulepreload|prefetch)"[^>]*>/gi, '');
+    out = out.replace(/<meta\b[^>]*name="aci-render-proof"[^>]*>/gi, '');
+    out = inlineStylesheets(out);
+    return stampInstrumentation(out, instrumentationTag);
+}
+async function emit() {
+    const publicDir = path.join(siteRoot, 'public');
+    const target = path.join(publicDir, '500.html');
+    if (fs.existsSync(target) && !fs.readFileSync(target, 'utf8').includes(MARKER)) {
+        log('public/500.html already provided by the site; leaving it untouched (skip-if-present)');
+        return;
+    }
+    const { route, defaultHtml } = await resolveCatchAllRoute();
+    let instrumentationTag;
+    try {
+        instrumentationTag = await resolveInstrumentationTag();
+    }
+    catch (error) {
+        fail(error.message);
+    }
+    let html;
+    try {
+        if (!route) {
+            // The shipped default is already self-contained; it gets the same
+            // instrumentation-plus-marker append used for rendered pages.
+            html = stampInstrumentation(defaultHtml, instrumentationTag);
+        }
+        else {
+            log(`rendering bound catchAll page ${route} for public/500.html`);
+            html = postProcess(await fetchRenderedRoute(route), instrumentationTag);
+        }
+    }
+    catch (error) {
+        fail(error.message);
+    }
+    const size = Buffer.byteLength(html);
+    if (size > SIZE_BUDGET) {
+        fail(`public/500.html is ${size} bytes, over the ${SIZE_BUDGET}-byte budget (REQ-14). `
+            + 'Trim the bound page/design-system CSS or fall back to system fonts (the sanctioned escape hatch).');
+    }
+    fs.mkdirSync(publicDir, { recursive: true });
+    fs.writeFileSync(target, html);
+    log(`wrote public/500.html (${size} bytes${route ? `, from ${route}` : ', shipped default'})`);
+}
+// Run only when executed as a CLI — the module is also imported by unit
+// tests for stampInstrumentation.
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (isMain) {
+    const phase = process.argv[2];
+    if (phase !== 'prepare' && phase !== 'emit') {
+        console.error('usage: emit-error-pages.mjs <prepare|emit>');
+        process.exit(2);
+    }
+    if (phase === 'prepare')
+        await prepare();
+    else
+        await emit();
+}

package/dist/cli/validate-content.d.mts

@@ -1,32 +1,2 @@
 #!/usr/bin/env node
-export function validateContent(options: any): Promise<{
-    warnings?: any[] | undefined;
-    success: boolean;
-    pagesValidated: number;
-    blocksValidated: number;
-    errors: ({
-        page: string;
-        message: string;
-        fragment?: undefined;
-        component?: undefined;
-        path?: undefined;
-    } | {
-        fragment: string;
-        message: string;
-        page?: undefined;
-        component?: undefined;
-        path?: undefined;
-    } | {
-        fragment: string;
-        component: any;
-        message: string;
-        page?: undefined;
-        path?: undefined;
-    } | {
-        fragment: string;
-        component: any;
-        path: any;
-        message: any;
-        page?: undefined;
-    })[];
-}>;
+export {};

package/dist/cli/validate-content.mjs

@@ -19,25 +19,21 @@
  * Uses the JSON schemas generated by compile-registry — portable, no React/CSS
  * imports needed, same schemas usable by Go backend or other tools.
  */
-import { realpathSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-if (isMainModule()) {
-    const args = parseArgs(process.argv.slice(2));
-    try {
-        const result = await validateContent(args);
-        console.log(JSON.stringify(result, null, 2));
-        if (!result.success)
-            process.exitCode = 1;
-    }
-    catch (error) {
-        console.error(JSON.stringify({
-            success: false,
-            errors: [{ message: String(error?.message ?? error) }],
-        }, null, 2));
+const args = parseArgs(process.argv.slice(2));
+try {
+    const result = await validateContent(args);
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.success)
         process.exitCode = 1;
-    }
+}
+catch (error) {
+    console.error(JSON.stringify({
+        success: false,
+        errors: [{ message: String(error?.message ?? error) }],
+    }, null, 2));
+    process.exitCode = 1;
 }
 // ---------------------------------------------------------------------------
 // Main
@@ -90,22 +86,6 @@ async function validateContent(options) {
         const blocks = collectBlocks(pageData);
         for (const block of blocks) {
             blocksValidated++;
-            if (!block || typeof block !== 'object') {
-                collector.push({
-                    page: relativePath,
-                    blockId: '<unknown>',
-                    message: 'page region entry must be a component block',
-                });
-                continue;
-            }
-            if (block.$type !== 'component') {
-                collector.push({
-                    page: relativePath,
-                    blockId: block.id ?? '<unknown>',
-                    path: '$type',
-                    message: 'block "$type" must be "component"',
-                });
-            }
             if (!block.component) {
                 collector.push({
                     page: relativePath,
@@ -368,13 +348,6 @@ function validateNestedSlots(parentBlock, componentMap, schemaMap, path = 'props
                 issues.push({ path: nestedPath, message: `${parentBlock.component}: block ref child must be a block` });
                 continue;
             }
-            if (nestedBlock.$type !== 'component') {
-                issues.push({
-                    path: `${nestedPath}.$type`,
-                    message: `${parentBlock.component}: block ref child "$type" must be "component"`,
-                });
-                continue;
-            }
             if (!componentMap.has(nestedBlock.component)) {
                 issues.push({ path: `${nestedPath}.component`, message: `${parentBlock.component}: unknown nested component "${nestedBlock.component}"` });
                 continue;
@@ -451,14 +424,3 @@ function parseArgs(argv) {
     }
     return out;
 }
-function isMainModule() {
-    if (!process.argv[1])
-        return false;
-    try {
-        return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(path.resolve(process.argv[1]));
-    }
-    catch {
-        return false;
-    }
-}
-export { validateContent };

package/dist/cli/verify-next-cdn-routes.mjs

@@ -32,6 +32,7 @@ checkMissing('legacy required catch-all is removed', 'src/app/[...slug]/page.tsx
 checkFile('canonical asset route exists', 'src/app/gradial/assets/[...path]/route.ts', (content) => content.includes('@gradial/aci/next/asset-route'), 'Expected the canonical asset route to use @gradial/aci/next/asset-route.');
 checkMissing('legacy release-scoped asset route is removed', 'src/app/gradial/assets/[releaseId]/[...path]/route.ts', 'Release-scoped asset URLs are produced by withAci() rewrites into the canonical src/app/gradial/assets/[...path]/route.ts; do not add a [releaseId] route.');
 checkMissing('no separate __r route folder', 'src/app/__r/[releaseId]/routes/[[...slug]]/page.tsx', 'The root catch-all handles release-scoped rewrites. Do not create a separate __r route folder.');
+checkMissing('platform-owned collect route is absent', 'src/app/collect/route.ts', 'ACI injects the reserved /collect function during Vercel Build Output composition; customer source must not own it.');
 checkFile('next.config uses withAci', 'next.config.mjs', (content) => content.includes('withAci'), 'Expected next.config.mjs to use withAci() from @gradial/aci/next.');
 for (const line of checks) {
     console.log(line);

package/dist/content/default-error-page-html.d.ts

@@ -0,0 +1,2 @@
+/** Shipped branded-neutral default error page, embedded at build time. */
+export declare const DEFAULT_ERROR_PAGE_HTML = "<!doctype html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<meta name=\"robots\" content=\"noindex\">\n<title>Page unavailable</title>\n</head>\n<body style=\"margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#fafafa;color:#1a1a1a;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;text-align:center\">\n<main style=\"max-width:26rem;padding:2rem\">\n<p style=\"margin:0 0 0.75rem;font-size:0.8rem;letter-spacing:0.12em;text-transform:uppercase;color:#6b6b6b\">Page unavailable</p>\n<h1 style=\"margin:0 0 1rem;font-size:1.5rem;font-weight:600;line-height:1.3\">This page can&rsquo;t be shown right now.</h1>\n<p style=\"margin:0 0 1.5rem;font-size:1rem;line-height:1.6;color:#4a4a4a\">The page you requested doesn&rsquo;t exist or couldn&rsquo;t be served. Check the address, try again in a moment, or return to the homepage.</p>\n<a href=\"/\" style=\"display:inline-block;padding:0.6rem 1.4rem;border:1px solid #1a1a1a;border-radius:999px;color:#1a1a1a;text-decoration:none;font-size:0.9rem\">Back to homepage</a>\n</main>\n</body>\n</html>\n";

package/dist/content/default-error-page-html.js

@@ -0,0 +1,6 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source of truth: assets/error-pages/default.html
+// Regenerate with: node scripts/generate-default-error-page.mjs
+// (default-error-page.test.ts fails if this file drifts from the asset.)
+/** Shipped branded-neutral default error page, embedded at build time. */
+export const DEFAULT_ERROR_PAGE_HTML = "<!doctype html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<meta name=\"robots\" content=\"noindex\">\n<title>Page unavailable</title>\n</head>\n<body style=\"margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#fafafa;color:#1a1a1a;font-family:system-ui,-apple-system,'Segoe UI',sans-serif;text-align:center\">\n<main style=\"max-width:26rem;padding:2rem\">\n<p style=\"margin:0 0 0.75rem;font-size:0.8rem;letter-spacing:0.12em;text-transform:uppercase;color:#6b6b6b\">Page unavailable</p>\n<h1 style=\"margin:0 0 1rem;font-size:1.5rem;font-weight:600;line-height:1.3\">This page can&rsquo;t be shown right now.</h1>\n<p style=\"margin:0 0 1.5rem;font-size:1rem;line-height:1.6;color:#4a4a4a\">The page you requested doesn&rsquo;t exist or couldn&rsquo;t be served. Check the address, try again in a moment, or return to the homepage.</p>\n<a href=\"/\" style=\"display:inline-block;padding:0.6rem 1.4rem;border:1px solid #1a1a1a;border-radius:999px;color:#1a1a1a;text-decoration:none;font-size:0.9rem\">Back to homepage</a>\n</main>\n</body>\n</html>\n";

package/dist/content/default-error-page.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shipped branded-neutral default error page (authorable-error-pages
+ * REQ-4/D-5). Materialized with a loud warning when a site has no
+ * `errorPages` binding under the warn-then-enforce posture. Self-contained
+ * by construction: inline styles only, no external references (REQ-14).
+ *
+ * The human-editable source of truth is `assets/error-pages/default.html`;
+ * it is embedded here as a generated constant (default-error-page-html.ts)
+ * because bundled serverless functions cannot read package assets at
+ * runtime — webpack rewrites module-URL resolution and output file tracing
+ * does not carry the .html into the function bundle, so a runtime file read
+ * crashes the very error surface this page exists to protect.
+ */
+/** Returns the shipped branded-neutral default error page HTML. */
+export declare function defaultErrorPageHtml(): string;
+/**
+ * The shipped default page's `<body>` content as an embeddable fragment: the
+ * body element renamed to a `<div>` (its inline styles preserved) so
+ * framework error seats can inline the default INSIDE an existing document —
+ * the not-found seat and the client error seat render within the app's root
+ * layout, where a nested `<body>`/`<html>` would be invalid.
+ */
+export declare function defaultErrorPageFragmentHtml(): string;

package/dist/content/default-error-page.js

@@ -0,0 +1,34 @@
+import { DEFAULT_ERROR_PAGE_HTML } from './default-error-page-html.js';
+/**
+ * Shipped branded-neutral default error page (authorable-error-pages
+ * REQ-4/D-5). Materialized with a loud warning when a site has no
+ * `errorPages` binding under the warn-then-enforce posture. Self-contained
+ * by construction: inline styles only, no external references (REQ-14).
+ *
+ * The human-editable source of truth is `assets/error-pages/default.html`;
+ * it is embedded here as a generated constant (default-error-page-html.ts)
+ * because bundled serverless functions cannot read package assets at
+ * runtime — webpack rewrites module-URL resolution and output file tracing
+ * does not carry the .html into the function bundle, so a runtime file read
+ * crashes the very error surface this page exists to protect.
+ */
+/** Returns the shipped branded-neutral default error page HTML. */
+export function defaultErrorPageHtml() {
+    return DEFAULT_ERROR_PAGE_HTML;
+}
+/**
+ * The shipped default page's `<body>` content as an embeddable fragment: the
+ * body element renamed to a `<div>` (its inline styles preserved) so
+ * framework error seats can inline the default INSIDE an existing document —
+ * the not-found seat and the client error seat render within the app's root
+ * layout, where a nested `<body>`/`<html>` would be invalid.
+ */
+export function defaultErrorPageFragmentHtml() {
+    const match = defaultErrorPageHtml().match(/<body([^>]*)>([\s\S]*?)<\/body>/i);
+    if (!match) {
+        // The shipped asset is package-controlled; this is a packaging bug, but
+        // error surfaces must never crash — fall back to the raw document body.
+        return defaultErrorPageHtml();
+    }
+    return `<div${match[1]}>${match[2]}</div>`;
+}

package/dist/content/error-page-kind.d.ts

@@ -0,0 +1,57 @@
+export type ErrorPageKind = 'notFound' | 'catchAll';
+/** D-14 page_type values for the error-surface `page_view` event. */
+export type ErrorPageType = 'not_found' | 'error';
+/** Maps a binding kind to its D-14 page_type. */
+export declare function errorPageType(kind: ErrorPageKind): ErrorPageType;
+declare global {
+    interface Window {
+        dataLayer?: Array<Record<string, unknown>>;
+    }
+}
+/**
+ * The D-15 policy shape: the dataLayer push for one error-surface view.
+ * Site policy lives in the tenant-owned scaffolded module
+ * `src/aci/error-page-instrumentation.mjs` (`pushErrorPageView`); the SDK
+ * ships `defaultPushErrorPageView` as the scaffolded default's twin. A push
+ * MUST be self-contained (browser globals only — no imports, no closed-over
+ * identifiers): the Astro seats and the 500.html emitter execute it
+ * STRINGIFIED via `serializeErrorPageInstrumentation`.
+ */
+export type ErrorPagePush = (pageType: ErrorPageType) => void;
+/**
+ * The SDK's copy of the D-14 default payload push — the same body the
+ * scaffolded policy module ships with. Used when no tenant module is in
+ * play: the Next `ErrorPageInstrumentation` component's default, the Astro
+ * seats' fallback, and the emitter's fallback tag. Self-contained by the
+ * ErrorPagePush contract (it serializes via toString()).
+ */
+export declare function defaultPushErrorPageView(pageType: ErrorPageType): void;
+/**
+ * SDK MECHANISM (D-15, code-organization R-14): serializes a self-contained
+ * push function into the inline analytics `<script>` tag the Astro seats
+ * inject via `<Fragment set:html>` and the Next emit-error-pages CLI stamps
+ * into `public/500.html`. The marker attribute and IIFE wrapper are
+ * SDK-owned platform contract (D-14: `data-aci-error-page` is the STABLE
+ * GTM suppression signal); the function body is site policy. `</script`,
+ * `<script` and `<!--` occurrences in the body are escaped (the script-data
+ * escaping table) so a push can neither break out of the tag nor walk the
+ * HTML parser into the escaped-script-data states (FIND-007).
+ *
+ * A non-function push degrades to the default tag with a warning
+ * (FIND-002): this is the runtime mechanism boundary and error surfaces
+ * must not crash over a broken policy value — the emitter keeps its own
+ * fail-loud stance at build time.
+ */
+export declare function serializeErrorPageInstrumentation(push: ErrorPagePush, kind: ErrorPageKind): string;
+/**
+ * The SDK DEFAULT analytics tag (D-15 amended D-14): the serialized
+ * `defaultPushErrorPageView`. Consumers fall back to it when no tenant
+ * policy module is provided — the Astro seats without
+ * `options.pushErrorPageView` and the emitter when
+ * `src/aci/error-page-instrumentation.mjs` is absent. The Next 'use client'
+ * component (`next/error-page-instrumentation.tsx`) cannot consume a script
+ * tag (RSC skips inline scripts); it calls the same default function
+ * directly, and the parity test beside it holds both deliveries in
+ * lockstep.
+ */
+export declare function errorPageInstrumentationTag(kind: ErrorPageKind): string;