@gradial/aci 0.1.50 → 0.1.51-ssr.2

package/dist/internal/domain/edge/record/codec.js

@@ -0,0 +1,401 @@
+// Compact JSON codec for edge-decisioning route records and classification data.
+//
+// project(): canonical → compact (short field names via alias table, omit defaults)
+// expand():  compact → canonical (reverse, never throws — returns INVALID sentinel on failure)
+//
+// Laws (property-tested):
+//   expand(project(r)) ≡ normalize(r)
+//   expand() never throws — malformed input → INVALID
+//   Unknown field code on expand = invalid data (→ base + alarm)
+//
+// The alias table is the single source of truth (schema/alias-table.v1.json).
+// These codecs are hand-written from it; cross-language round-trip tests
+// enforce drift between the Go and TS implementations.
+//
+// Failure is represented by the exported INVALID sentinel (a unique object).
+// Expand functions return the value directly on success, or INVALID on failure.
+// Callers check `result === INVALID`. This avoids the {ok,value,reason}
+// wrapper in the byte-constrained runtime.
+// ── INVALID sentinel ─────────────────────────────────────────────────
+/**
+ * Unique sentinel object returned by expand functions on failure.
+ * Callers check `result === INVALID`. Never throws.
+ */
+export const INVALID = Symbol();
+const te = new TextEncoder();
+// ── Alias table (hand-mirrored from schema/alias-table.v1.json) ──────
+const FIELD_ALIASES = {
+    schema: 's', path: 'p', dispatch: 'd', variants: 'v', experiments: 'x',
+    priority: 'pr', kind: 'k', rule: 'r', all: 'a', any: 'n', field: 'f',
+    operator: 'o', value: 'w', audiences: 'au', segments: 'sg',
+    classification: 'c', arms: 'ar', id: 'id', status: 'st',
+    allocationVersion: 'av', salt: 'sl', allocationBasisPoints: 'ab',
+    variantKey: 'vk', variantValues: 'vv', artifactPath: 'ap',
+    displayName: 'dn', primaryGoalId: 'pg', goalIds: 'gl', role: 'ro',
+};
+const DISPATCH_KIND_TO_COMPACT = {
+    'static-direct': 's',
+};
+const DISPATCH_KIND_FROM_COMPACT = {
+    s: 'static-direct',
+};
+const OPERATOR_TO_COMPACT = {
+    equals: 'eq', contains: 'ct', startsWith: 'sw', exists: 'ex',
+};
+const OPERATOR_FROM_COMPACT = {
+    eq: 'equals', ct: 'contains', sw: 'startsWith', ex: 'exists',
+};
+const EXPERIMENT_STATUS_TO_COMPACT = {
+    running: 'r', paused: 'p', completed: 'd',
+};
+const EXPERIMENT_STATUS_FROM_COMPACT = {
+    r: 'running', p: 'paused', d: 'completed',
+};
+const EXPERIMENT_KIND_TO_COMPACT = {
+    ab: 'a', abn: 'n',
+};
+const EXPERIMENT_KIND_FROM_COMPACT = {
+    a: 'ab', n: 'abn',
+};
+// Compact type guard — reduces minified bytes vs repeated typeof+null+isArray checks
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function projectDispatch(dispatch) {
+    if (dispatch.kind !== 'static-direct' || !dispatch.artifactPath) {
+        throw new Error('edge dispatch must name one static artifact');
+    }
+    return { k: DISPATCH_KIND_TO_COMPACT[dispatch.kind], ap: dispatch.artifactPath };
+}
+function expandDispatch(raw) {
+    if (raw == null)
+        return undefined;
+    if (!isObj(raw))
+        return INVALID;
+    const kind = DISPATCH_KIND_FROM_COMPACT[raw.k];
+    const artifactPath = raw.ap;
+    if (kind !== 'static-direct' || typeof artifactPath !== 'string' || artifactPath.length === 0)
+        return INVALID;
+    return { kind, artifactPath };
+}
+function projectCondition(cond) {
+    if (!cond || !cond.field || !cond.operator)
+        return null;
+    const compactOp = OPERATOR_TO_COMPACT[cond.operator];
+    if (!compactOp)
+        return null;
+    const result = { f: cond.field, o: compactOp };
+    if (cond.operator !== 'exists' && cond.value !== undefined)
+        result.w = cond.value;
+    return result;
+}
+function expandCondition(raw) {
+    if (!isObj(raw))
+        return INVALID;
+    const f = raw.f;
+    const co = raw.o;
+    if (typeof f !== 'string')
+        return INVALID;
+    const op = OPERATOR_FROM_COMPACT[co];
+    if (!op)
+        return INVALID;
+    const c = { field: f, operator: op };
+    if (op !== 'exists' && raw.w !== undefined)
+        c.value = raw.w;
+    return c;
+}
+function projectRule(rule) {
+    if (!rule)
+        return undefined;
+    const result = {};
+    if (rule.all && rule.all.length > 0)
+        result.a = rule.all.map(projectCondition).filter((c) => c !== null);
+    if (rule.any && rule.any.length > 0)
+        result.n = rule.any.map(projectCondition).filter((c) => c !== null);
+    if (!result.a && !result.n)
+        return undefined;
+    return result;
+}
+function expandRule(raw) {
+    if (raw == null)
+        return undefined;
+    if (!isObj(raw))
+        return INVALID;
+    const rule = {};
+    if (Array.isArray(raw.a))
+        for (const c of raw.a) {
+            const r = expandCondition(c);
+            if (r === INVALID)
+                return INVALID;
+            if (r)
+                (rule.all = rule.all || []).push(r);
+        }
+    if (Array.isArray(raw.n))
+        for (const c of raw.n) {
+            const r = expandCondition(c);
+            if (r === INVALID)
+                return INVALID;
+            if (r)
+                (rule.any = rule.any || []).push(r);
+        }
+    if (!rule.all && !rule.any)
+        return undefined;
+    return rule;
+}
+function projectVariant(variant) {
+    const result = {};
+    if (variant.priority)
+        result.pr = variant.priority;
+    if (variant.rule)
+        result.r = projectRule(variant.rule);
+    result.d = projectDispatch(variant.dispatch);
+    if (variant.variantValues && Object.keys(variant.variantValues).length > 0)
+        result.vv = variant.variantValues;
+    return result;
+}
+function expandVariant(raw) {
+    if (!isObj(raw))
+        return INVALID;
+    const obj = raw;
+    if (obj.d === undefined)
+        return INVALID;
+    const dispatchResult = expandDispatch(obj.d);
+    if (dispatchResult === INVALID || !dispatchResult)
+        return INVALID;
+    const variant = { variantKey: '', dispatch: dispatchResult };
+    if (typeof obj.pr === 'number')
+        variant.priority = obj.pr;
+    if (obj.r !== undefined) {
+        const ruleResult = expandRule(obj.r);
+        if (ruleResult === INVALID)
+            return INVALID;
+        if (ruleResult)
+            variant.rule = ruleResult;
+    }
+    if (isObj(obj.vv))
+        variant.variantValues = obj.vv;
+    return variant;
+}
+export function projectRouteRecord(entry) {
+    const result = { p: entry.pattern, d: projectDispatch(entry.dispatch) };
+    result.s = 1;
+    if (entry.variants && Object.keys(entry.variants).length > 0) {
+        result.v = {};
+        for (const [key, variant] of Object.entries(entry.variants))
+            result.v[key] = projectVariant(variant);
+    }
+    return result;
+}
+export function expandRouteRecord(raw) {
+    if (!isObj(raw))
+        return INVALID;
+    const obj = raw;
+    if (obj.s !== undefined && obj.s !== 1)
+        return INVALID;
+    const path = obj.p;
+    if (typeof path !== 'string')
+        return INVALID;
+    if (obj.d === undefined)
+        return INVALID;
+    const dispatchResult = expandDispatch(obj.d);
+    if (dispatchResult === INVALID || !dispatchResult)
+        return INVALID;
+    const entry = { pattern: path, priority: 0, dispatch: dispatchResult };
+    if (obj.v !== undefined) {
+        if (!isObj(obj.v))
+            return INVALID;
+        entry.variants = {};
+        for (const [key, variantRaw] of Object.entries(obj.v)) {
+            const variantResult = expandVariant(variantRaw);
+            if (variantResult === INVALID)
+                return INVALID;
+            const variant = variantResult;
+            variant.variantKey = key;
+            if (!variant.variantValues)
+                variant.variantValues = variantValuesFromKey(key);
+            entry.variants[key] = variant;
+        }
+    }
+    return entry;
+}
+export function projectClassificationData(data) {
+    const result = {};
+    if (data.audiences && Object.keys(data.audiences).length > 0) {
+        result.au = {};
+        for (const [key, def] of Object.entries(data.audiences)) {
+            const entry = {};
+            const rule = projectRule(def.rule);
+            if (rule)
+                entry.r = rule;
+            result.au[key] = entry;
+        }
+    }
+    if (data.segments && Object.keys(data.segments).length > 0) {
+        result.sg = {};
+        for (const [key, def] of Object.entries(data.segments)) {
+            const entry = {};
+            const rule = projectRule(def.rule);
+            if (rule)
+                entry.r = rule;
+            result.sg[key] = entry;
+        }
+    }
+    if (data.experiments && Object.keys(data.experiments).length > 0) {
+        result.x = {};
+        for (const [key, exp] of Object.entries(data.experiments))
+            result.x[key] = projectExperiment(exp);
+    }
+    return result;
+}
+function projectExperiment(exp) {
+    const result = { id: exp.id };
+    if (exp.status) {
+        const c = EXPERIMENT_STATUS_TO_COMPACT[exp.status];
+        if (c)
+            result.st = c;
+    }
+    if (exp.kind) {
+        const c = EXPERIMENT_KIND_TO_COMPACT[exp.kind];
+        if (c)
+            result.k = c;
+    }
+    if (exp.allocationVersion)
+        result.av = exp.allocationVersion;
+    if (exp.salt)
+        result.sl = exp.salt;
+    if (exp.priority)
+        result.pr = exp.priority;
+    if (exp.arms && exp.arms.length > 0) {
+        result.ar = exp.arms.map((arm) => {
+            const ca = { id: arm.id };
+            if (arm.allocationBasisPoints)
+                ca.ab = arm.allocationBasisPoints;
+            if (arm.variantKey)
+                ca.vk = arm.variantKey;
+            return ca;
+        });
+    }
+    return result;
+}
+export function expandClassificationData(raw) {
+    if (!isObj(raw))
+        return INVALID;
+    const obj = raw;
+    const data = { audiences: {}, segments: {}, experiments: {} };
+    if (obj.au !== undefined) {
+        if (!isObj(obj.au))
+            return INVALID;
+        for (const [key, defRaw] of Object.entries(obj.au)) {
+            if (!isObj(defRaw))
+                return INVALID;
+            const ruleResult = expandRule(defRaw.r);
+            if (ruleResult === INVALID)
+                return INVALID;
+            data.audiences[key] = { rule: ruleResult || { all: [] } };
+        }
+    }
+    if (obj.sg !== undefined) {
+        if (!isObj(obj.sg))
+            return INVALID;
+        for (const [key, defRaw] of Object.entries(obj.sg)) {
+            if (!isObj(defRaw))
+                return INVALID;
+            const ruleResult = expandRule(defRaw.r);
+            if (ruleResult === INVALID)
+                return INVALID;
+            data.segments[key] = { rule: ruleResult || { all: [] } };
+        }
+    }
+    if (obj.x !== undefined) {
+        if (!isObj(obj.x))
+            return INVALID;
+        for (const [key, expRaw] of Object.entries(obj.x)) {
+            const expResult = expandExperiment(expRaw);
+            if (expResult === INVALID)
+                return INVALID;
+            data.experiments[key] = expResult;
+        }
+    }
+    return data;
+}
+function expandExperiment(raw) {
+    if (!isObj(raw))
+        return INVALID;
+    const obj = raw;
+    const id = obj.id;
+    if (typeof id !== 'string')
+        return INVALID;
+    const exp = { id, status: 'running', kind: 'ab', arms: [] };
+    if (typeof obj.st === 'string') {
+        const expanded = EXPERIMENT_STATUS_FROM_COMPACT[obj.st];
+        if (!expanded)
+            return INVALID;
+        exp.status = expanded;
+    }
+    if (typeof obj.k === 'string') {
+        const expanded = EXPERIMENT_KIND_FROM_COMPACT[obj.k];
+        if (!expanded)
+            return INVALID;
+        exp.kind = expanded;
+    }
+    if (typeof obj.av === 'string')
+        exp.allocationVersion = obj.av;
+    if (typeof obj.sl === 'string')
+        exp.salt = obj.sl;
+    if (typeof obj.pr === 'number')
+        exp.priority = obj.pr;
+    if (Array.isArray(obj.ar)) {
+        exp.arms = [];
+        for (const armRaw of obj.ar) {
+            if (!isObj(armRaw))
+                return INVALID;
+            const armObj = armRaw;
+            if (typeof armObj.id !== 'string')
+                return INVALID;
+            exp.arms.push({
+                id: armObj.id,
+                allocationBasisPoints: typeof armObj.ab === 'number' ? armObj.ab : 0,
+                variantKey: typeof armObj.vk === 'string' ? armObj.vk : '',
+            });
+        }
+    }
+    return exp;
+}
+// ── Marker (tri-state: record | marker | absent) ─────────────────────
+export const MARKER = '{"s":1,"e":1}';
+export function isMarker(raw) {
+    return raw === MARKER;
+}
+// ── Serialization helpers ────────────────────────────────────────────
+export function canonicalSerialize(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    const sorted = {};
+    for (const key of Object.keys(value).sort())
+        sorted[key] = sortKeys(value[key]);
+    return sorted;
+}
+// ── VariantKey parsing ───────────────────────────────────────────────
+export function variantValuesFromKey(key) {
+    const values = {};
+    for (const part of String(key || '').replace(/&/g, ';').split(';')) {
+        const sep = part.indexOf('=');
+        if (sep > 0)
+            values[part.slice(0, sep).trim()] = part.slice(sep + 1).trim();
+    }
+    return values;
+}
+// ── Path hashing (FNV-1a-32, hex 16 chars) ───────────────────────────
+export function pathHash16(path) {
+    let hash = 0x811c9dc5;
+    for (const byte of te.encode(path)) {
+        hash ^= byte;
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0') + '00000000';
+}

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

@@ -0,0 +1,2 @@
+import type { PersonalizationHostConfig, PersonalizationResolution } from './types.js';
+export declare function resolvePersonalizationRequest(request: Request, config: PersonalizationHostConfig): Promise<PersonalizationResolution>;

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

@@ -0,0 +1,76 @@
+// resolvePersonalizationRequest — the edge decisioning entry point.
+//
+// Reads cookies for classification but never writes them (R25: consent-gated
+// identity model). Identity minting happens in the collect/consent endpoint,
+// not here. Public personalized responses may be private while providers cache
+// the selected immutable artifact by release and exact artifact path.
+import { resolvePersonalizationDecision, } from './personalization-core.js';
+import { consentSignals, verifyIdentityCookie, identityHashHex, verifyClaims, parseCookieHeader, } from './identity.js';
+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
+    // 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).
+    //
+    // GPC/DNT deny fully: no read, no identity, no experiment bucketing.
+    const rawIdentity = consent.privacyDenied
+        ? null
+        : await verifyIdentityCookie(cookies.get('aci_id') || '', config.identityKeys);
+    // The identity hash feeds experiment bucketing for identified visitors.
+    // Claims are a signed cookie written by /collect; the EdgeRouter
+    // never reads the customer object store to refresh or revoke them.
+    let signedClaims = cookies.get('aci_claims') || '';
+    let identityHash = '';
+    if (rawIdentity) {
+        identityHash = await identityHashHex('aci_id', rawIdentity);
+    }
+    if (rawIdentity && consent.allowsIdentityTier && signedClaims) {
+        if (!await verifyClaims(signedClaims, config.claimsKeys || {}, now)) {
+            signedClaims = '';
+        }
+    }
+    const matchedRoute = config.route;
+    let variantKey = '';
+    if (matchedRoute) {
+        const claims = consent.allowsIdentityTier
+            ? await verifyClaims(signedClaims, config.claimsKeys || {}, now)
+            : null;
+        const decision = resolvePersonalizationDecision(toPersonalizationRequestContext(request), matchedRoute, claims, config.experiments, identityHash
+            ? { usable: true, siteId: config.siteId, namespace: 'aci_id', identityHash }
+            : undefined);
+        if (decision.variant) {
+            variantKey = decision.variant.variantKey;
+        }
+        const experiment = decision.experiment
+            ? { id: decision.experiment.experimentId, arm: decision.experiment.armId, allocationVersion: decision.experiment.allocationVersion }
+            : undefined;
+        return { variantKey, experiment };
+    }
+    return { variantKey };
+}
+function toPersonalizationRequestContext(request) {
+    const url = new URL(request.url);
+    const cookies = parseCookieHeader(request.headers.get('cookie'));
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+        (query[key] ||= []).push(value);
+    });
+    const headers = Object.fromEntries(request.headers.entries());
+    return {
+        path: url.pathname,
+        query,
+        headers,
+        cookies: Object.fromEntries(cookies.entries()),
+        signals: {
+            geo: {
+                country: headers['x-vercel-ip-country'] || headers['cloudfront-viewer-country'] || '',
+                region: headers['x-vercel-ip-country-region'] || headers['cloudfront-viewer-country-region'] || '',
+                city: headers['x-vercel-ip-city'] || headers['cloudfront-viewer-city'] || '',
+            },
+        },
+    };
+}

package/dist/{next/personalization-host.d.ts → internal/domain/edge/types.d.ts}

@@ -1,13 +1,8 @@
-import { type PersonalizationExperiment } from '../edge/personalization-core.js';
-import { type PortableConsentSnapshot } from '../consent/portable-envelope.js';
-export declare const CONTENT_PATH_HEADER = "x-aci-content-path";
-export declare const CONTENT_PATH_CACHE_PARAM = "__aci_content_path";
-export declare const ROUTED_PATH_HEADER = "x-aci-routed-path";
-export declare const VARIANT_KEY_HEADER = "x-aci-variant-key";
 export interface EdgeDispatch {
-    kind: 'static-direct' | 'compose-origin' | 'framework-origin' | string;
-    artifactPath?: string;
-    contentPath?: string;
+    /** The only deterministic CMS delivery mode: an immutable HTML object. */
+    kind: 'static-direct';
+    /** Release-relative immutable HTML artifact selected for this route. */
+    artifactPath: string;
 }
 export interface EdgeRuleCondition {
     field: string;
@@ -45,31 +40,77 @@ export interface EdgeRouteManifest {
     notFoundPage?: string;
     errorPage?: string;
 }
-export interface PersonalizationEnvelopeWrite {
-    key: string;
-    envelopeId: string;
-    siteId: string;
-    identityNamespace: string;
-    identityHash: string;
-    records: readonly unknown[];
-    digest: string;
+export interface PersonalizationRequestContext {
+    path: string;
+    query: Record<string, string[]>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+    signals?: {
+        geo?: Record<string, string>;
+    };
+    identityHash?: string;
+    identityNamespace?: string;
+    siteId?: string;
+}
+export interface PersonalizationClaims {
+    aud?: string[];
+    seg?: string[];
+    iat: number;
+    exp: number;
+}
+export interface PersonalizationVariant {
+    variantKey: string;
+    variantValues?: Record<string, string>;
+    priority?: number;
+    rule?: EdgeRuleExpression;
+    dispatch: EdgeDispatch;
 }
-export declare class IdentityErasureFencedError extends Error {
-    readonly name = "IdentityErasureFencedError";
-    constructor();
+export interface PersonalizationRoute {
+    variants?: Record<string, PersonalizationVariant>;
 }
-/** Immutable release routing state read by an EdgeRouter. */
-export interface PersonalizationRouteStore {
-    readEdgeManifest(releaseId: string): Promise<EdgeRouteManifest | null>;
+export interface PersonalizationExperiment {
+    id: string;
+    status: string;
+    kind: string;
+    priority?: number;
+    allocationVersion?: string;
+    salt?: string;
+    arms: Array<{
+        id: string;
+        allocationBasisPoints?: number;
+        variantKey: string;
+    }>;
 }
-/** Customer-owned collection state. This is deliberately not an EdgeRouter dependency. */
-export interface PersonalizationCollectionStore {
-    readClaims(siteId: string, namespace: string, identityHash: string): Promise<string | null>;
-    appendEnvelope(write: PersonalizationEnvelopeWrite): Promise<void>;
-    putSuppression(key: string, record: unknown): Promise<void>;
+export interface PersonalizationIdentity {
+    usable: boolean;
+    siteId: string;
+    namespace: string;
+    identityHash: string;
 }
-/** @deprecated Use the narrower router or collection store at each boundary. */
-export interface PersonalizationBlobStore extends PersonalizationRouteStore, PersonalizationCollectionStore {
+export interface PersonalizationExperimentDecision {
+    experimentId: string;
+    armId: string;
+    allocationVersion: string;
+    variantKey: string;
+    bucket: number;
+}
+export interface PersonalizationDecision {
+    variant: PersonalizationVariant | null;
+    experiment: PersonalizationExperimentDecision | null;
+}
+export interface ClassificationData {
+    audiences: Record<string, {
+        rule: EdgeRuleExpression;
+    }>;
+    segments: Record<string, {
+        rule: EdgeRuleExpression;
+    }>;
+    experiments: Record<string, PersonalizationExperiment>;
+}
+export interface Classification {
+    matchedAudiences: string[];
+    matchedSegments: string[];
+    experimentArms: Record<string, PersonalizationExperimentDecision>;
 }
 export interface SigningKey {
     kid: string;
@@ -79,16 +120,6 @@ export interface IdentitySigningKeys {
     current: SigningKey;
     previous?: SigningKey;
 }
-export interface PersonalizationHostConfig {
-    siteId: string;
-    store: PersonalizationRouteStore;
-    identityKeys: IdentitySigningKeys;
-    claimsKeys?: Record<string, string>;
-    identityCookieTTLSeconds?: number;
-    secureCookies?: boolean;
-    now?: () => Date;
-    randomBytes?: (length: number) => Uint8Array;
-}
 export interface CookieMutation {
     name: string;
     value: string;
@@ -101,34 +132,50 @@ export interface CookieMutation {
         expires?: Date;
     };
 }
+export interface ConsentSnapshot {
+    version: number;
+    purposes: string[];
+    grantedAt: string;
+    source?: string;
+}
+export interface ConsentSignals {
+    hasConsent: boolean;
+    consentInvalid: boolean;
+    snapshot: ConsentSnapshot | null;
+    allowsIdentityTier: boolean;
+    privacyDenied: boolean;
+}
+export interface PersonalizationEnvelopeWrite {
+    key: string;
+    envelopeId: string;
+    siteId: string;
+    identityNamespace: string;
+    identityHash: string;
+    records: readonly unknown[];
+    digest: string;
+}
+export interface PersonalizationCollectionStore {
+    readClaims(siteId: string, namespace: string, identityHash: string, now?: Date): Promise<string | null>;
+    appendEnvelope(write: PersonalizationEnvelopeWrite): Promise<void>;
+    putSuppression(key: string, record: unknown): Promise<void>;
+}
+export interface PersonalizationHostConfig {
+    siteId: string;
+    route: EdgeRouteEntry | null;
+    experiments?: Record<string, PersonalizationExperiment>;
+    identityKeys: IdentitySigningKeys;
+    claimsKeys?: Record<string, string>;
+    identityCookieTTLSeconds?: number;
+    secureCookies?: boolean;
+    now?: () => Date;
+    randomBytes?: (length: number) => Uint8Array;
+}
 export interface PersonalizationResolution {
-    requestHeaders: Headers;
-    contentPath: string;
     variantKey: string;
     experiment?: {
         id: string;
         arm: string;
         allocationVersion: string;
     };
-    cookies: CookieMutation[];
 }
-export type ConsentSnapshot = PortableConsentSnapshot;
-interface ClaimsPayload {
-    aud?: string[];
-    seg?: string[];
-    iat: number;
-    exp: number;
-}
-export declare function resolvePersonalizationRequest(request: Request, releaseId: string, config: PersonalizationHostConfig): Promise<PersonalizationResolution>;
-export declare function consentSignals(request: Request, cookies: Map<string, string>): {
-    hasConsent: boolean;
-    snapshot: ConsentSnapshot | null;
-    allowsIdentityTier: boolean;
-    privacyDenied: boolean;
-};
-export declare function parseCookieHeader(value: string | null): Map<string, string>;
-export declare function verifyIdentityCookie(value: string, keys: IdentitySigningKeys): Promise<string | null>;
-export declare function sha256Hex(value: string): Promise<string>;
-export declare function identityHashHex(namespace: string, value: string): Promise<string>;
-export declare function verifyClaims(value: string, keys: Record<string, string>, now: Date): Promise<ClaimsPayload | null>;
-export {};
+export { IdentityErasureFencedError } from '../../platform/collectionstore/errors.js';