@gradial/aci 0.1.45 → 0.1.46

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/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/provider.d.ts

@@ -10,7 +10,7 @@ export interface RouteEntry {
 export interface RouteVariantEntry {
     variantKey: string;
     payloadRef: string;
-    digest?: string;
+    digest: string;
     variantValues?: Record<string, string>;
 }
 export interface FragmentEntry {

package/dist/content/resolve-slots.js

@@ -12,7 +12,6 @@ export async function resolveSlots(layout, pageRegions, getFragment) {
             for (const ref of defaults) {
                 const fragment = await getFragment(ref.fragmentId);
                 blocks.push({
-                    $type: 'component',
                     id: fragment.id,
                     component: fragment.component,
                     props: fragment.props || {},

package/dist/content/types.d.ts

@@ -42,13 +42,11 @@ export interface KernelPageSeo {
     canonical?: string;
 }
 export interface KernelPageBlock {
-    $type: 'component';
     id: string;
     component: string;
     props: Record<string, unknown>;
 }
 export interface KernelAtomicBlock {
-    $type: 'component';
     id: string;
     component: string;
     props: Record<string, unknown>;

package/dist/internal/render-proof.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/render-proof.js

@@ -0,0 +1,197 @@
+const RENDER_PROOF_VERSION = 'gradial.aci.renderProof.v1';
+const RENDER_PROOF_KEYS = [
+    'version',
+    'releaseId',
+    'route',
+    'contentRef',
+    'contentSha256',
+    'variantKey',
+];
+const MAX_RENDER_PROOF_CONTENT_BYTES = 4096;
+const receiptBrand = Symbol('aci.verified-page-receipt');
+const renderProofReceipts = new WeakMap();
+/** @internal */
+export const selectVerifiedPage = Symbol('aci.select-verified-page');
+/** @internal */
+export function createVerifiedPageReceipt(value) {
+    // Selection itself must fail if the coupled marker cannot be emitted.
+    // `getPage` also uses this capability and intentionally discards the
+    // receipt, so deferring the size check to React would permit markerless
+    // success on that public server loader.
+    validateVerifiedPageReceipt(value);
+    return Object.freeze({
+        ...value,
+        [receiptBrand]: true,
+    });
+}
+/** @internal */
+export function validateVerifiedPageReceipt(value) {
+    encodeRenderProofContent(toRenderProof(value));
+}
+/** @internal */
+export function attachRenderProofReceipt(input, receipt) {
+    if (receipt[receiptBrand] !== true) {
+        throw new Error('ACI render proof integrity error: unverified receipt');
+    }
+    renderProofReceipts.set(input, receipt);
+}
+/** @internal */
+export function renderProofContentFor(input) {
+    const receipt = renderProofReceipts.get(input);
+    return receipt ? encodeRenderProofContent(toRenderProof(receipt)) : null;
+}
+/** @internal */
+export function encodeRenderProofContent(proof) {
+    validateRenderProof(proof);
+    const canonicalJSON = JSON.stringify({
+        version: proof.version,
+        releaseId: proof.releaseId,
+        route: proof.route,
+        contentRef: proof.contentRef,
+        contentSha256: proof.contentSha256,
+        variantKey: proof.variantKey,
+    });
+    const content = Buffer.from(canonicalJSON, 'utf8').toString('base64url');
+    if (content.length < 1 || content.length > MAX_RENDER_PROOF_CONTENT_BYTES) {
+        throw new Error(`ACI render proof integrity error: marker content is ${content.length} bytes`);
+    }
+    return content;
+}
+/** @internal */
+export function decodeRenderProofContent(content) {
+    if (content.length < 1
+        || content.length > MAX_RENDER_PROOF_CONTENT_BYTES
+        || !/^[A-Za-z0-9_-]+$/.test(content)) {
+        throw new Error('ACI render proof integrity error: invalid marker encoding');
+    }
+    const bytes = Buffer.from(content, 'base64url');
+    if (bytes.toString('base64url') !== content) {
+        throw new Error('ACI render proof integrity error: non-canonical base64url');
+    }
+    let canonicalJSON = '';
+    try {
+        canonicalJSON = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch (cause) {
+        throw integrityError('marker is not valid UTF-8', cause);
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(canonicalJSON);
+    }
+    catch (cause) {
+        throw integrityError('marker is not valid JSON', cause);
+    }
+    if (!isRecord(decoded)) {
+        throw new Error('ACI render proof integrity error: marker must be an object');
+    }
+    if (!sameKeys(Object.keys(decoded), RENDER_PROOF_KEYS)) {
+        throw new Error('ACI render proof integrity error: marker keys are not canonical');
+    }
+    const proof = {
+        version: decoded.version,
+        releaseId: decoded.releaseId,
+        route: decoded.route,
+        contentRef: decoded.contentRef,
+        contentSha256: decoded.contentSha256,
+        variantKey: decoded.variantKey,
+    };
+    validateRenderProof(proof);
+    if (JSON.stringify(proof) !== canonicalJSON) {
+        throw new Error('ACI render proof integrity error: marker JSON is not canonical');
+    }
+    return Object.freeze(proof);
+}
+function toRenderProof(receipt) {
+    return {
+        version: RENDER_PROOF_VERSION,
+        releaseId: receipt.releaseId,
+        route: receipt.route,
+        contentRef: receipt.contentRef,
+        contentSha256: receipt.contentSha256,
+        variantKey: receipt.variantKey,
+    };
+}
+function validateRenderProof(proof) {
+    if (!isRecord(proof)) {
+        throw new Error('ACI render proof integrity error: proof must be an object');
+    }
+    for (const key of RENDER_PROOF_KEYS) {
+        if (typeof proof[key] !== 'string') {
+            throw new Error(`ACI render proof integrity error: ${key} must be a string`);
+        }
+        if (hasUnpairedSurrogate(proof[key])) {
+            throw new Error(`ACI render proof integrity error: ${key} has invalid Unicode`);
+        }
+    }
+    if (proof.version !== RENDER_PROOF_VERSION) {
+        throw new Error('ACI render proof integrity error: unsupported version');
+    }
+    if (Buffer.byteLength(proof.releaseId, 'ascii') > 128
+        || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(proof.releaseId)) {
+        throw new Error('ACI render proof integrity error: invalid releaseId');
+    }
+    if (Buffer.byteLength(proof.route, 'utf8') > 2048
+        || !isCanonicalRoute(proof.route)) {
+        throw new Error('ACI render proof integrity error: invalid route');
+    }
+    if (Buffer.byteLength(proof.contentRef, 'utf8') > 2048
+        || !isCleanContentRef(proof.contentRef)) {
+        throw new Error('ACI render proof integrity error: invalid contentRef');
+    }
+    if (!/^[0-9a-f]{64}$/.test(proof.contentSha256)) {
+        throw new Error('ACI render proof integrity error: invalid contentSha256');
+    }
+    if (Buffer.byteLength(proof.variantKey, 'utf8') > 1024
+        || /[\u0000-\u001f\u007f]/.test(proof.variantKey)) {
+        throw new Error('ACI render proof integrity error: invalid variantKey');
+    }
+}
+function isCanonicalRoute(route) {
+    if (route === '/')
+        return true;
+    if (!route.startsWith('/')
+        || route.startsWith('//')
+        || route.endsWith('/')
+        || /[\u0000-\u001f\u007f]/.test(route)) {
+        return false;
+    }
+    return route.slice(1).split('/').every((segment) => (segment !== '' && segment !== '.' && segment !== '..'));
+}
+function isCleanContentRef(ref) {
+    if (!ref
+        || ref.startsWith('/')
+        || ref.endsWith('/')
+        || ref.includes('\\')
+        || /[\u0000-\u001f\u007f]/.test(ref)) {
+        return false;
+    }
+    return ref.split('/').every((segment) => (segment !== '' && segment !== '.' && segment !== '..'));
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function sameKeys(actual, expected) {
+    return actual.length === expected.length
+        && actual.every((key, index) => key === expected[index]);
+}
+function hasUnpairedSurrogate(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return true;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return true;
+        }
+    }
+    return false;
+}
+function integrityError(message, cause) {
+    const error = new Error(`ACI render proof integrity error: ${message}`);
+    error.cause = cause;
+    return error;
+}