@gradial/aci 0.1.44 → 0.1.46

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.45 - 2026-07-29
+
+### Fixed
+
+- Require the explicit `$type: "component"` discriminator for top-level and
+  nested component blocks across schema generation, content validation, and
+  rendering.
+- Execute the registry compiler and content validator correctly through
+  package-manager symlinks while keeping their reusable functions importable.
+
 ## 0.1.44 - 2026-07-28
 
 ### Fixed

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.44` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.45` 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.44 zod@^4
+npm install @gradial/aci@0.1.45 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.44 init my-site --template next-starter
+npx @gradial/aci@0.1.45 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.44 init --list
+npx @gradial/aci@0.1.45 init --list
 ```
 
 ## Personalization: The One-Tag Install

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/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/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;
+}

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));

package/dist/next/page.js

@@ -6,6 +6,7 @@ import { routeMetadataForContent, resolveSlots, } from '../content/index.js';
 import { renderBlocks } from './render.js';
 import { AssignmentsScript } from './assignments-script.js';
 import { CollectScript } from './collect-script.js';
+import { renderProofContentFor } from '../internal/render-proof.js';
 /**
  * Creates the catch-all route handler for a Next.js ACI site.
  *
@@ -64,12 +65,14 @@ export function createPage(registry, options) {
     }
     async function CatchAllPage({ params }) {
         const { route, releaseId } = await resolveRouteAndRelease(params);
+        const fetchConfig = { releaseId };
         try {
-            const input = await getRenderInput(route, { releaseId });
+            const input = await getRenderInput(route, fetchConfig);
             if (!input.page)
                 notFound();
-            const layout = await getLayout(input.page.layout);
-            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id));
+            const renderProofContent = renderProofContentFor(input);
+            const layout = await getLayout(input.page.layout, fetchConfig);
+            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id, fetchConfig));
             const renderedSlots = await Promise.all(layout.slots.map(async (slot) => {
                 const blocks = resolvedSlots[slot.name];
                 if (!blocks?.length)
@@ -81,7 +84,9 @@ export function createPage(registry, options) {
                 }
                 return (_jsx(Fragment, { children: renderedBlocks }, slot.name));
             }));
-            return (_jsxs(_Fragment, { children: [renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
+            return (_jsxs(_Fragment, { children: [renderProofContent
+                        ? _jsx("meta", { name: "aci-render-proof", content: renderProofContent })
+                        : null, renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
         }
         catch (error) {
             if (error instanceof PageNotFoundError)

package/dist/next/personalization-host.d.ts

@@ -29,12 +29,17 @@ export interface EdgeRouteEntry {
     dispatch: EdgeDispatch;
     variants?: Record<string, EdgeRouteVariant>;
 }
+export interface CollectSDKEntry {
+    hash: string;
+    path: string;
+}
 export interface EdgeRouteManifest {
     manifestVersion: string;
     releaseId: string;
     siteId: string;
     routes: Record<string, EdgeRouteEntry>;
     experiments?: Record<string, PersonalizationExperiment>;
+    collectSdk?: CollectSDKEntry;
     notFoundPage?: string;
     errorPage?: string;
 }