@gradial/aci 0.1.52-rc.1 → 0.1.52-rc.10

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.52-rc.1` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.52-rc.10` 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.52-rc.1 zod@^4
+npm install @gradial/aci@0.1.52-rc.10 zod@^4
 ```
 
 ## Root Import
@@ -78,13 +78,13 @@ host bundles select and serve immutable release artifacts.
 The first RC scaffold path is Next:
 
 ```bash
-npx @gradial/aci@0.1.52-rc.1 init my-site --template next-starter
+npx @gradial/aci@0.1.52-rc.10 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.52-rc.1 init --list
+npx @gradial/aci@0.1.52-rc.10 init --list
 ```
 
 ## Personalization: The One-Tag Install

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

@@ -336,6 +336,9 @@ export declare const experimentDataModel: import("./index.js").DataModelContract
         routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         fragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
+    eligibility: z.ZodOptional<z.ZodObject<{
+        audienceRef: z.ZodString;
+    }, z.core.$strict>>;
     primaryGoalRef: z.ZodOptional<z.ZodString>;
     primaryGoalId: z.ZodOptional<z.ZodString>;
     goalRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -426,6 +429,9 @@ export declare const experimentationDataModels: (import("./index.js").DataModelC
         routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         fragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
+    eligibility: z.ZodOptional<z.ZodObject<{
+        audienceRef: z.ZodString;
+    }, z.core.$strict>>;
     primaryGoalRef: z.ZodOptional<z.ZodString>;
     primaryGoalId: z.ZodOptional<z.ZodString>;
     goalRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -794,6 +800,9 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
         routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         fragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
+    eligibility: z.ZodOptional<z.ZodObject<{
+        audienceRef: z.ZodString;
+    }, z.core.$strict>>;
     primaryGoalRef: z.ZodOptional<z.ZodString>;
     primaryGoalId: z.ZodOptional<z.ZodString>;
     goalRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/audience-data-models.js

@@ -127,6 +127,9 @@ export const experimentDataModel = defineDataModel({
             routes: z.array(z.string().min(1)).optional(),
             fragments: z.array(z.string().min(1)).optional(),
         }),
+        eligibility: z.object({
+            audienceRef: z.string().min(1),
+        }).strict().optional(),
         primaryGoalRef: z.string().optional(),
         primaryGoalId: z.string().optional(),
         goalRefs: z.array(z.string().min(1)).optional(),

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

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

package/dist/cli/compile-registry.mjs

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

package/dist/cli/validate-content.mjs

@@ -19,21 +19,25 @@
  * 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';
-const args = parseArgs(process.argv.slice(2));
-try {
-    const result = await validateContent(args);
-    console.log(JSON.stringify(result, null, 2));
-    if (!result.success)
+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));
         process.exitCode = 1;
-}
-catch (error) {
-    console.error(JSON.stringify({
-        success: false,
-        errors: [{ message: String(error?.message ?? error) }],
-    }, null, 2));
-    process.exitCode = 1;
+    }
 }
 // ---------------------------------------------------------------------------
 // Main
@@ -86,6 +90,22 @@ 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,
@@ -348,6 +368,13 @@ 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;
@@ -424,3 +451,14 @@ 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/content/provider.d.ts

@@ -21,6 +21,7 @@ export interface FragmentEntry {
 }
 export interface LayoutEntry {
     name: string;
+    payloadRef: string;
     slots: LayoutSlot[];
     defaults?: Record<string, FragmentRef[]>;
 }

package/dist/content/resolve-slots.d.ts

@@ -1,9 +1,16 @@
 import type { LayoutEntry } from './provider.js';
 import type { KernelPageBlock } from './types.js';
-export interface FragmentData {
-    id: string;
+export interface FragmentBlock {
+    $type: 'component';
     component: string;
     props?: Record<string, unknown>;
 }
+export interface FragmentData {
+    fragmentId?: string;
+    id?: string;
+    block?: FragmentBlock;
+    component?: string;
+    props?: Record<string, unknown>;
+}
 export type FragmentLoader = (id: string) => Promise<FragmentData>;
 export declare function resolveSlots(layout: LayoutEntry, pageRegions: Record<string, KernelPageBlock[]>, getFragment: FragmentLoader): Promise<Record<string, KernelPageBlock[]>>;

package/dist/content/resolve-slots.js

@@ -11,10 +11,12 @@ export async function resolveSlots(layout, pageRegions, getFragment) {
             const blocks = [];
             for (const ref of defaults) {
                 const fragment = await getFragment(ref.fragmentId);
+                const block = fragment.block ?? { component: fragment.component ?? '', props: fragment.props };
                 blocks.push({
-                    id: fragment.id,
-                    component: fragment.component,
-                    props: fragment.props || {},
+                    $type: 'component',
+                    id: fragment.id ?? fragment.fragmentId ?? ref.fragmentId,
+                    component: block.component,
+                    props: block.props || {},
                 });
             }
             resolved[slot.name] = blocks;

package/dist/content/types.d.ts

@@ -42,11 +42,13 @@ 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/edge/personalization-core.js

@@ -13,6 +13,7 @@ export function resolvePersonalizationDecision(request, route, claims, experimen
         const candidates = Object.values(experiments)
             .filter((item) => (item.kind === 'ab' || item.kind === 'abn') && item.status === 'running')
             .filter((item) => routeHasExperiment(route, item.id))
+            .filter((item) => experimentEligible(item, claims))
             .sort((left, right) => (right.priority || 0) - (left.priority || 0)
             || String(left.id || '').localeCompare(String(right.id || '')));
         for (let index = 0; index < candidates.length; index++) {
@@ -39,7 +40,8 @@ function selectRuleVariant(request, route, claims, experiments) {
         const values = variant.variantValues || variantValuesFromKey(key);
         const experimentID = String(values.experiment || '').trim();
         if (experimentID && (!experiments || !experiments[experimentID]
-            || experiments[experimentID].status !== 'running'))
+            || experiments[experimentID].status !== 'running'
+            || !experimentEligible(experiments[experimentID], claims)))
             continue;
         if (!requestDimensionsMatch(request, values))
             continue;
@@ -66,6 +68,16 @@ function variantValuesFromKey(key) {
     }
     return values;
 }
+// The eligibility gate (audience-scoped-experiments ASE-F4/F5), mirrored
+// from internal/domain/edge/personalization-core.ts: an experiment declaring
+// eligibilityAudienceId is skipped unless the verified claims carry the ID.
+// Ungated experiments return true, preserving byte-identical behavior.
+function experimentEligible(item, claims) {
+    const audienceID = String(item.eligibilityAudienceId || '').trim();
+    if (!audienceID)
+        return true;
+    return !!claims && (claims.aud || []).includes(audienceID);
+}
 function routeHasExperiment(route, experimentID) {
     for (const key in route.variants || {}) {
         const values = route.variants[key].variantValues || variantValuesFromKey(key);

package/dist/internal/domain/edge/compose.d.ts

@@ -0,0 +1,24 @@
+export interface ObjectReader {
+    readObject(path: string): Promise<Uint8Array>;
+}
+export interface ComposeObjectRef {
+    path: string;
+    digest: string;
+}
+export interface ComposeSlot {
+    name: string;
+    required: boolean;
+    placeholder: string;
+    parts: ComposeObjectRef[];
+}
+export interface ComposeEnvelope {
+    schema: 'gradial.compose-envelope.v1';
+    algorithm: 'aci-html-compose-v1';
+    shell: ComposeObjectRef;
+    slots: ComposeSlot[];
+}
+export declare function composeEnvelope(reader: ObjectReader, envelopePath: string, envelopeDigest: string): Promise<{
+    html: string;
+    contentType: string;
+}>;
+export declare function validateEnvelope(envelope: unknown): ComposeEnvelope;

package/dist/internal/domain/edge/compose.js

@@ -0,0 +1,89 @@
+const decoder = new TextDecoder('utf-8', { fatal: true });
+export async function composeEnvelope(reader, envelopePath, envelopeDigest) {
+    const envelopeBytes = await reader.readObject(envelopePath);
+    await requireDigest(envelopeBytes, envelopeDigest, 'compose envelope');
+    let parsed;
+    try {
+        parsed = JSON.parse(decoder.decode(envelopeBytes));
+    }
+    catch {
+        throw new Error('compose envelope is malformed');
+    }
+    const envelope = validateEnvelope(parsed);
+    const shellBytes = await reader.readObject(envelope.shell.path);
+    await requireDigest(shellBytes, envelope.shell.digest, 'compose shell');
+    let html = decoder.decode(shellBytes);
+    for (const slot of envelope.slots) {
+        if (occurrences(html, slot.placeholder) !== 1) {
+            throw new Error(`compose slot ${JSON.stringify(slot.name)} placeholder must occur exactly once`);
+        }
+        if (slot.required && slot.parts.length === 0) {
+            throw new Error(`compose slot ${JSON.stringify(slot.name)} is required`);
+        }
+        const parts = [];
+        for (const part of slot.parts) {
+            const bytes = await reader.readObject(part.path);
+            await requireDigest(bytes, part.digest, `compose slot ${slot.name}`);
+            parts.push(decoder.decode(bytes));
+        }
+        html = html.replace(slot.placeholder, parts.join(''));
+    }
+    if (html.includes('<!--ACI_SLOT:')) {
+        throw new Error('compose shell has unresolved slots');
+    }
+    return { html, contentType: 'text/html; charset=utf-8' };
+}
+export function validateEnvelope(envelope) {
+    if (!envelope || typeof envelope !== 'object') {
+        throw new Error('compose envelope is malformed');
+    }
+    const obj = envelope;
+    if (obj.schema !== 'gradial.compose-envelope.v1'
+        || obj.algorithm !== 'aci-html-compose-v1'
+        || !Array.isArray(obj.slots)) {
+        throw new Error('compose envelope is malformed');
+    }
+    const env = envelope;
+    validateRef(env.shell);
+    const names = new Set();
+    for (const slot of env.slots) {
+        if (!slot || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(slot.name) || names.has(slot.name)) {
+            throw new Error('compose slot is malformed');
+        }
+        names.add(slot.name);
+        if (slot.placeholder !== `<!--ACI_SLOT:${slot.name}-->` || !Array.isArray(slot.parts)) {
+            throw new Error(`compose slot ${JSON.stringify(slot.name)} is malformed`);
+        }
+        for (const part of slot.parts)
+            validateRef(part);
+    }
+    return env;
+}
+function validateRef(ref) {
+    const path = String(ref?.path || '');
+    if (!path || path.includes('\\') || path.split('/').some((part) => !part || part === '.' || part === '..')) {
+        throw new Error('compose object path is invalid');
+    }
+    if (!/^[0-9a-f]{64}$/.test(String(ref.digest || '').toLowerCase())) {
+        throw new Error('compose object digest is invalid');
+    }
+}
+async function requireDigest(bytes, want, label) {
+    const ab = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(ab).set(bytes);
+    const actual = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', ab)), (byte) => byte.toString(16).padStart(2, '0')).join('');
+    if (actual !== want.toLowerCase())
+        throw new Error(`${label} digest mismatch`);
+}
+function occurrences(value, needle) {
+    let count = 0;
+    let offset = 0;
+    while (true) {
+        offset = value.indexOf(needle, offset);
+        if (offset < 0)
+            break;
+        count += 1;
+        offset += needle.length;
+    }
+    return count;
+}

package/dist/internal/domain/edge/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types.js';
 export * from './personalization-core.js';
 export * from './identity.js';
+export * from './compose.js';
 export { resolvePersonalizationRequest, } from './resolve.js';

package/dist/internal/domain/edge/index.js

@@ -3,4 +3,5 @@
 export * from './types.js';
 export * from './personalization-core.js';
 export * from './identity.js';
+export * from './compose.js';
 export { resolvePersonalizationRequest, } from './resolve.js';

package/dist/internal/domain/edge/personalization-core.d.ts

@@ -8,9 +8,12 @@ export declare function resolvePersonalizationDecision(request: PersonalizationR
  * @param data    Release-level classification data (audiences, segments, experiments)
  * @param identity Visitor identity (for experiment bucketing). Pass undefined
  *                 if no identity or privacy denied.
+ * @param claims  The verified claims the caller already holds (eligibility
+ *                gate input, ASE-F4). Undefined/null means "no claims" —
+ *                gated experiments are skipped.
  * @returns Classification — matched audiences, segments, and experiment arm assignments
  */
-export declare function classify(ctx: PersonalizationRequestContext, data: ClassificationData, identity?: PersonalizationIdentity): Classification;
+export declare function classify(ctx: PersonalizationRequestContext, data: ClassificationData, identity?: PersonalizationIdentity, claims?: PersonalizationClaims | null): Classification;
 /**
  * Phase 2: Decide the winning variant for a specific route.
  *

package/dist/internal/domain/edge/personalization-core.js

@@ -20,6 +20,7 @@ export function resolvePersonalizationDecision(request, route, claims, experimen
         const candidates = Object.values(experiments)
             .filter((item) => (item.kind === 'ab' || item.kind === 'abn') && item.status === 'running')
             .filter((item) => routeHasExperiment(route, item.id))
+            .filter((item) => experimentEligible(item, claims))
             .sort((left, right) => (right.priority || 0) - (left.priority || 0)
             || String(left.id || '').localeCompare(String(right.id || '')));
         for (let index = 0; index < candidates.length; index++) {
@@ -50,7 +51,8 @@ function selectRuleVariant(request, route, claims, experiments) {
         const values = variant.variantValues || variantValuesFromKey(key);
         const experimentID = String(values.experiment || '').trim();
         if (experimentID && (!experiments || !experiments[experimentID]
-            || experiments[experimentID].status !== 'running'))
+            || experiments[experimentID].status !== 'running'
+            || !experimentEligible(experiments[experimentID], claims)))
             continue;
         if (!requestDimensionsMatch(request, values))
             continue;
@@ -64,6 +66,16 @@ function selectRuleVariant(request, route, claims, experiments) {
         || String(left.variantKey || '').localeCompare(String(right.variantKey || '')));
     return matches[0] || null;
 }
+// The eligibility gate (audience-scoped-experiments ASE-F4/F5): an
+// experiment declaring eligibilityAudienceId is skipped entirely — before
+// bucketing or arm candidacy — unless the verified claims carry the ID.
+// Ungated experiments return true, preserving byte-identical behavior.
+function experimentEligible(item, claims) {
+    const audienceID = String(item.eligibilityAudienceId || '').trim();
+    if (!audienceID)
+        return true;
+    return !!claims && (claims.aud || []).includes(audienceID);
+}
 function routeHasExperiment(route, experimentID) {
     for (const key in route.variants || {}) {
         const values = route.variants[key].variantValues || variantValuesFromKey(key);
@@ -279,9 +291,12 @@ function utf8(value) {
  * @param data    Release-level classification data (audiences, segments, experiments)
  * @param identity Visitor identity (for experiment bucketing). Pass undefined
  *                 if no identity or privacy denied.
+ * @param claims  The verified claims the caller already holds (eligibility
+ *                gate input, ASE-F4). Undefined/null means "no claims" —
+ *                gated experiments are skipped.
  * @returns Classification — matched audiences, segments, and experiment arm assignments
  */
-export function classify(ctx, data, identity) {
+export function classify(ctx, data, identity, claims) {
     // Evaluate audience rules
     const matchedAudiences = [];
     for (const key in data.audiences) {
@@ -307,6 +322,8 @@ export function classify(ctx, data, identity) {
                 continue;
             if (exp.kind !== 'ab' && exp.kind !== 'abn')
                 continue;
+            if (!experimentEligible(exp, claims))
+                continue;
             const assignment = assignExperiment(exp, identity);
             if (assignment) {
                 experimentArms[expId] = assignment;
@@ -348,21 +365,21 @@ export function decide(record, classification, ctx) {
         if (!matched && values.segment && classification.matchedSegments.includes(values.segment)) {
             matched = true;
         }
-        // Experiment arm assignment
+        // Experiment arm assignment. The arm is a candidate only — committing it
+        // inside the win block prevents a losing arm variant from leaving a
+        // stale experiment decision behind when another variant wins.
+        let armMatch = null;
         if (!matched && experimentID) {
             const arm = classification.experimentArms[experimentID];
             if (arm && arm.variantKey === variant.variantKey) {
                 matched = true;
-                bestExperiment = arm;
+                armMatch = arm;
             }
         }
         if (matched) {
             if (!bestVariant || betterVariant(variant.priority || 0, variant.variantKey, bestVariant.priority || 0, bestVariant.variantKey)) {
                 bestVariant = variant;
-                // Only set experiment if this variant's experiment arm won
-                if (!experimentID || !classification.experimentArms[experimentID]) {
-                    bestExperiment = null;
-                }
+                bestExperiment = armMatch;
             }
         }
     }

package/dist/internal/domain/edge/resolve.js

@@ -10,11 +10,13 @@ export async function resolvePersonalizationRequest(request, config) {
     const cookies = parseCookieHeader(request.headers.get('cookie'));
     const consent = consentSignals(request, cookies);
     const now = (config.now ?? (() => new Date()))();
-    // Consent-gated identity model (R25): static artifact selection NEVER mints
+    // Consent-gated identity model (R25): artifact selection NEVER mints
     // identity. It reads cookies for classification but never writes them.
-    // Identity (aci_id) is minted by the collect/consent endpoint after
-    // explicit consent. This keeps all content responses cacheable and is
-    // GDPR-compliant (no non-essential cookie before consent).
+    // Identity (aci_id) is minted only after explicit consent — by the
+    // collect/consent endpoint, and by the hosting edge router / framework
+    // host on consented 200 HTML page responses (which then bypass shared
+    // caches). Unconsented content responses stay cookie-free and cacheable
+    // (no non-essential cookie before consent).
     //
     // GPC/DNT deny fully: no read, no identity, no experiment bucketing.
     const rawIdentity = consent.privacyDenied

package/dist/internal/domain/edge/types.d.ts

@@ -75,6 +75,7 @@ export interface PersonalizationExperiment {
     priority?: number;
     allocationVersion?: string;
     salt?: string;
+    eligibilityAudienceId?: string;
     arms: Array<{
         id: string;
         allocationBasisPoints?: number;
@@ -178,4 +179,15 @@ export interface PersonalizationResolution {
         allocationVersion: string;
     };
 }
+export interface CompositionDescriptor {
+    layoutArtifact: string;
+    fragments?: Record<string, string>;
+}
+export type SelectedTargetKind = 'direct' | 'compose' | 'render';
+export interface SelectedTarget {
+    kind: SelectedTargetKind;
+    path: string;
+    digest: string;
+    composition?: CompositionDescriptor;
+}
 export { IdentityErasureFencedError } from '../../platform/collectionstore/errors.js';

package/dist/next/error-seat-payload.js

@@ -104,7 +104,7 @@ export function buildErrorSeatPayload(contentRoot, posture) {
                 if (!fragmentRef)
                     continue;
                 const fragment = readJSON(root, fragmentRef);
-                blocks.push({ id: fragment.id, component: fragment.component, props: fragment.props || {} });
+                blocks.push({ $type: 'component', id: fragment.id, component: fragment.component, props: fragment.props || {} });
             }
             if (blocks.length)
                 slots[slot.name] = blocks;

package/dist/next/page.js

@@ -84,9 +84,9 @@ export function createPage(registry, options) {
                 }
                 return (_jsx(Fragment, { children: renderedBlocks }, slot.name));
             }));
-            return (_jsxs(_Fragment, { children: [renderProofContent
+            return (_jsxs(_Fragment, { children: [renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig }), renderProofContent
                         ? _jsx("meta", { name: "aci-render-proof", content: renderProofContent })
-                        : null, renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
+                        : null] }));
         }
         catch (error) {
             if (error instanceof PageNotFoundError)