@gradial/aci 0.1.45 → 0.1.47

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.45` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.47` is a pre-1.0 public-surface reset for the ACI
 client SDK. Breaking changes from the old `0.1.x` accidental surface are
 intentional: the root import is framework-neutral, framework runtime behavior is
 behind explicit subpaths, and the first required customer path is React/Next.
@@ -8,7 +8,7 @@ behind explicit subpaths, and the first required customer path is React/Next.
 ## Install
 
 ```bash
-npm install @gradial/aci@0.1.45 zod@^4
+npm install @gradial/aci@0.1.47 zod@^4
 ```
 
 ## Root Import
@@ -85,13 +85,13 @@ go through an app-owned HTTP endpoint backed server-side by a `ContentProvider`.
 The first RC scaffold path is Next:
 
 ```bash
-npx @gradial/aci@0.1.45 init my-site --template next-starter
+npx @gradial/aci@0.1.47 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.45 init --list
+npx @gradial/aci@0.1.47 init --list
 ```
 
 ## Personalization: The One-Tag Install

package/dist/astro/error-page.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Astro error-page render helper (authorable-error-pages REQ-7 / REQ-11 /
+ * D-10 / D-11; 02-design "SDK core"). The Astro counterpart of the Next
+ * seams in `src/next/error-pages.tsx`: resolve the page bound by
+ * `site.json#errorPages[kind]` and load it through the normal page pipeline
+ * (`getPageData`) so the template's `404.astro`/`500.astro` stay thin —
+ * the spike's hand-rolled binding resolution and siteConfig casting live
+ * here instead (spike A kill list).
+ *
+ * Never throws: an error surface must not crash and must not re-enter the
+ * failing system (ANTI-2). Any failure — no bindings (REQ-4 warn posture),
+ * unreadable content, a bound page missing at render time — degrades to the
+ * shipped branded-neutral default fragment with the problem surfaced via
+ * console.warn.
+ *
+ * REQ-11: error pages are base-audience with no personalization, so the
+ * returned page data always carries empty collect/assignment tags.
+ */
+import { type AstroGlobal, type PageData } from './page.js';
+import { type ErrorPageKind, type ErrorPagePush, type ErrorPageType } from '../content/error-pages.js';
+import type { KernelRouteMetadata } from '../content/types.js';
+export interface AstroErrorPageData {
+    kind: ErrorPageKind;
+    /** D-14 page_type for the seat's instrumentation script. */
+    pageType: ErrorPageType;
+    /**
+     * Pre-rendered D-14 analytics `<script>` tag: the site's push function
+     * (`options.pushErrorPageView`, D-15 — normally the tenant-owned
+     * `src/aci/error-page-instrumentation.mjs`; the SDK default when omitted)
+     * serialized via `serializeErrorPageInstrumentation`. The seat injects it
+     * via `<Fragment set:html={...}>` — Astro serves real HTML documents, so
+     * the inline script executes.
+     */
+    instrumentationTag: string;
+    /**
+     * The bound page loaded through the normal pipeline, with collect and
+     * assignment tags suppressed (REQ-11). Null when the shipped default
+     * applies — render `fallbackHtml` instead.
+     */
+    data: PageData | null;
+    /** Shipped branded-neutral default fragment (REQ-4) when `data` is null. */
+    fallbackHtml: string | null;
+    /** Document metadata for the layout shell, valid in either branch. */
+    meta: KernelRouteMetadata;
+}
+/**
+ * Resolves and loads the error page bound to `kind` for Astro's native
+ * error seats (`404.astro` / `500.astro`). `astro` is the seat's Astro
+ * global; the bound route's content is loaded as if it were the requested
+ * route, so static builds emit it into `dist/404.html`/`dist/500.html` and
+ * server output renders it at error time from local compiled content — no
+ * CMS fetch on the failing path (ANTI-2).
+ */
+export declare function getErrorPageData(astro: AstroGlobal, kind: ErrorPageKind, options?: {
+    pushErrorPageView?: ErrorPagePush;
+}): Promise<AstroErrorPageData>;

package/dist/astro/error-page.js

@@ -0,0 +1,79 @@
+/**
+ * Astro error-page render helper (authorable-error-pages REQ-7 / REQ-11 /
+ * D-10 / D-11; 02-design "SDK core"). The Astro counterpart of the Next
+ * seams in `src/next/error-pages.tsx`: resolve the page bound by
+ * `site.json#errorPages[kind]` and load it through the normal page pipeline
+ * (`getPageData`) so the template's `404.astro`/`500.astro` stay thin —
+ * the spike's hand-rolled binding resolution and siteConfig casting live
+ * here instead (spike A kill list).
+ *
+ * Never throws: an error surface must not crash and must not re-enter the
+ * failing system (ANTI-2). Any failure — no bindings (REQ-4 warn posture),
+ * unreadable content, a bound page missing at render time — degrades to the
+ * shipped branded-neutral default fragment with the problem surfaced via
+ * console.warn.
+ *
+ * REQ-11: error pages are base-audience with no personalization, so the
+ * returned page data always carries empty collect/assignment tags.
+ */
+import { getPageData } from './page.js';
+import { defaultPushErrorPageView, errorPageType, resolveErrorPage, serializeErrorPageInstrumentation, } from '../content/error-pages.js';
+import { defaultErrorPageFragmentHtml } from '../content/default-error-page.js';
+const FALLBACK_META = {
+    notFound: {
+        title: 'Page not found',
+        description: 'The page you requested does not exist.',
+    },
+    catchAll: {
+        title: 'Something went wrong',
+        description: 'The page you requested could not be served right now.',
+    },
+};
+/**
+ * Resolves and loads the error page bound to `kind` for Astro's native
+ * error seats (`404.astro` / `500.astro`). `astro` is the seat's Astro
+ * global; the bound route's content is loaded as if it were the requested
+ * route, so static builds emit it into `dist/404.html`/`dist/500.html` and
+ * server output renders it at error time from local compiled content — no
+ * CMS fetch on the failing path (ANTI-2).
+ */
+export async function getErrorPageData(astro, kind, options = {}) {
+    const pageType = errorPageType(kind);
+    const instrumentationTag = serializeErrorPageInstrumentation(options.pushErrorPageView ?? defaultPushErrorPageView, kind);
+    try {
+        const { FileContentProvider } = await import('../providers/file.js');
+        const siteConfig = await new FileContentProvider().getSiteConfig();
+        const resolved = await resolveErrorPage(kind, siteConfig);
+        for (const warning of resolved.warnings) {
+            console.warn(`[aci error-pages] ${warning}`);
+        }
+        if (resolved.route) {
+            const slug = resolved.route.replace(/^\/+|\/+$/g, '');
+            const data = await getPageData({
+                params: { slug },
+                request: astro.request,
+                url: astro.url,
+            });
+            return {
+                kind,
+                pageType,
+                instrumentationTag,
+                // Base audience, no personalization on error surfaces (REQ-11).
+                data: { ...data, collectTag: '', assignmentsTag: '' },
+                fallbackHtml: null,
+                meta: data.meta,
+            };
+        }
+    }
+    catch (error) {
+        console.warn(`[aci error-pages] bound ${kind} page failed to load; serving the shipped default: ${String(error)}`);
+    }
+    return {
+        kind,
+        pageType,
+        instrumentationTag,
+        data: null,
+        fallbackHtml: defaultErrorPageFragmentHtml(),
+        meta: { ...FALLBACK_META[kind], siteName: 'Gradial' },
+    };
+}

package/dist/astro/index.d.ts

@@ -36,6 +36,10 @@ export declare function getGradialStaticPaths(): Promise<Array<{
 }>>;
 export declare function getPageRuntimeRenderInput(request: Request): RenderInput | null;
 export { getPageData, type PageData, type AstroGlobal, type GetPageDataOptions, } from './page.js';
+export { getErrorPageData, type AstroErrorPageData, } from './error-page.js';
+export { errorPageType, type ErrorPageType } from '../content/error-pages.js';
+export type { ErrorPageKind } from '../content/error-pages.js';
+export { PageNotFoundError } from '../content/provider.js';
 export { createRegistry, registryLookup } from '../registry.js';
 export type { Registry, RegistryEntry, AnyComponent } from '../registry.js';
 export type { BlockRef } from '../types/block-ref.js';

package/dist/astro/index.js

@@ -37,6 +37,15 @@ export function getPageRuntimeRenderInput(request) {
 // ---------------------------------------------------------------------------
 export { getPageData, } from './page.js';
 // ---------------------------------------------------------------------------
+// Authorable error pages (specs/features/authorable-error-pages, REQ-7/D-10)
+// — the seats' resolve+render helper, and PageNotFoundError so the catch-all
+// can map content misses to a 404 response in server output.
+// ---------------------------------------------------------------------------
+export { getErrorPageData, } from './error-page.js';
+// Single definition of the kind→page_type mapping (quorum SIMPLE-005).
+export { errorPageType } from '../content/error-pages.js';
+export { PageNotFoundError } from '../content/provider.js';
+// ---------------------------------------------------------------------------
 // Registry helpers
 // ---------------------------------------------------------------------------
 export { createRegistry, registryLookup } from '../registry.js';

package/dist/audience-data-models.d.ts

@@ -80,6 +80,41 @@ export declare const segmentDataModel: import("./index.js").DataModelContract<z.
             properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
             type: z.ZodLiteral<"event_latest">;
         }, z.core.$strict>], "type">>>;
+        none: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            minCount: z.ZodNumber;
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_count">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_exists">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_latest">;
+        }, z.core.$strict>], "type">>>;
     }, z.core.$strict>, z.ZodObject<{
         all: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             minCount: z.ZodNumber;
@@ -151,6 +186,41 @@ export declare const segmentDataModel: import("./index.js").DataModelContract<z.
             properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
             type: z.ZodLiteral<"event_latest">;
         }, z.core.$strict>], "type">>;
+        none: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            minCount: z.ZodNumber;
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_count">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_exists">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_latest">;
+        }, z.core.$strict>], "type">>>;
     }, z.core.$strict>]>>;
 }, z.core.$strip>, "segment">;
 export declare const audienceDataModel: import("./index.js").DataModelContract<z.ZodObject<{
@@ -163,11 +233,11 @@ export declare const audienceDataModel: import("./index.js").DataModelContract<z
     }>;
     priority: z.ZodNumber;
     membershipSource: z.ZodEnum<{
+        none: "none";
         segment: "segment";
         rule: "rule";
         manual: "manual";
         external: "external";
-        none: "none";
     }>;
     ruleRef: z.ZodOptional<z.ZodString>;
     segmentRef: z.ZodOptional<z.ZodString>;
@@ -473,6 +543,41 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
             properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
             type: z.ZodLiteral<"event_latest">;
         }, z.core.$strict>], "type">>>;
+        none: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            minCount: z.ZodNumber;
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_count">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_exists">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_latest">;
+        }, z.core.$strict>], "type">>>;
     }, z.core.$strict>, z.ZodObject<{
         all: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             minCount: z.ZodNumber;
@@ -544,6 +649,41 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
             properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
             type: z.ZodLiteral<"event_latest">;
         }, z.core.$strict>], "type">>;
+        none: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            minCount: z.ZodNumber;
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_count">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_exists">;
+        }, z.core.$strict>, z.ZodObject<{
+            event: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            referrer: z.ZodOptional<z.ZodString>;
+            withinDays: z.ZodOptional<z.ZodNumber>;
+            experiment: z.ZodOptional<z.ZodObject<{
+                experimentId: z.ZodString;
+                armId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            type: z.ZodLiteral<"event_latest">;
+        }, z.core.$strict>], "type">>>;
     }, z.core.$strict>]>>;
 }, z.core.$strip>, "segment"> | import("./index.js").DataModelContract<z.ZodObject<{
     id: z.ZodString;
@@ -555,11 +695,11 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
     }>;
     priority: z.ZodNumber;
     membershipSource: z.ZodEnum<{
+        none: "none";
         segment: "segment";
         rule: "rule";
         manual: "manual";
         external: "external";
-        none: "none";
     }>;
     ruleRef: z.ZodOptional<z.ZodString>;
     segmentRef: z.ZodOptional<z.ZodString>;

package/dist/audience-data-models.js

@@ -43,10 +43,12 @@ const segmentCriteriaSchema = z.union([
     z.object({
         all: z.array(segmentCriteriaConditionSchema).min(1),
         any: z.array(segmentCriteriaConditionSchema).optional(),
+        none: z.array(segmentCriteriaConditionSchema).optional(),
     }).strict(),
     z.object({
         all: z.array(segmentCriteriaConditionSchema).optional(),
         any: z.array(segmentCriteriaConditionSchema).min(1),
+        none: z.array(segmentCriteriaConditionSchema).optional(),
     }).strict(),
 ]);
 const requestRuleConditionSchema = z.object({

package/dist/cli/compile-registry.d.mts

@@ -1,6 +1,2 @@
 #!/usr/bin/env node
-export function compileRegistry(options: any): Promise<{
-    registry: string;
-    schemas: string[];
-}>;
-export function generatePageSchema(schemaDir: any, componentEntries: any, outDir: any): Promise<string>;
+export {};

package/dist/cli/compile-registry.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
-import { realpathSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { pathToFileURL } from 'node:url';
 import { z } from 'zod';
 import { ImageSchema } from '../types/image.ts';
 import { VideoSchema } from '../types/video.ts';
@@ -19,16 +18,14 @@ try {
         globalThis.React = React;
 }
 catch { /* react not available — component files without JSX will still work */ }
-if (isMainModule()) {
-    const args = parseArgs(process.argv.slice(2));
-    try {
-        const result = await compileRegistry(args);
-        console.log(JSON.stringify({ success: true, ...result, errors: [] }, null, 2));
-    }
-    catch (error) {
-        console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
-        process.exitCode = 1;
-    }
+const args = parseArgs(process.argv.slice(2));
+try {
+    const result = await compileRegistry(args);
+    console.log(JSON.stringify({ success: true, ...result, errors: [] }, null, 2));
+}
+catch (error) {
+    console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
+    process.exitCode = 1;
 }
 async function compileRegistry(options) {
     const required = ['components', 'layouts', 'output'];
@@ -443,10 +440,9 @@ async function generatePageSchema(schemaDir, componentEntries, outDir) {
     const defs = {
         baseBlock: {
             type: 'object',
-            required: ['$type', 'id', 'component', 'props'],
+            required: ['id', 'component', 'props'],
             additionalProperties: true,
             properties: {
-                $type: { const: 'component' },
                 id: { type: 'string', minLength: 1 },
                 component: { type: 'string' },
                 props: { type: 'object' },
@@ -761,14 +757,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 { compileRegistry, generatePageSchema };

package/dist/cli/emit-error-pages.d.mts

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * 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 function resolveInstrumentationTag(root: string | undefined, content: any): Promise<any>;
+/**
+ * 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 function writeInstrumentationArtifact(root: string | undefined, content: any, outRoot?: string): Promise<string>;
+/**
+ * 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: any, instrumentationTag: any): any;