@gradial/aci 0.1.52-rc.3 → 0.1.52-rc.34-e2e.1

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

@@ -0,0 +1,17 @@
+import type { PersonalizationExperiment, PersonalizationRoute, PersonalizationVariant } from './types.js';
+export interface AuthoredCandidate {
+    readonly key: string;
+    readonly variant: PersonalizationVariant;
+    readonly values: Record<string, string>;
+    readonly experiments: readonly PersonalizationExperiment[];
+}
+export interface PersonalizationSelection {
+    readonly sourceExperiments: Record<string, PersonalizationExperiment> | undefined;
+    readonly authored: readonly AuthoredCandidate[];
+    readonly experiments: readonly PersonalizationExperiment[];
+    readonly arms: Readonly<Record<string, Readonly<Record<string, PersonalizationVariant>>>>;
+    readonly tuples: Readonly<Record<string, PersonalizationVariant>>;
+    readonly legacyExperimentExclusions: number;
+}
+export declare function preparePersonalizationRoute(route: PersonalizationRoute, experiments?: Record<string, PersonalizationExperiment>): PersonalizationRoute;
+export declare function personalizationSelection(route: PersonalizationRoute, experiments?: Record<string, PersonalizationExperiment>): PersonalizationSelection;

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

@@ -0,0 +1,56 @@
+import { variantValuesFromKey } from './record/codec.js';
+import { compareUTF8 } from './variant_key.js';
+const preparedSelection = Symbol('prepared personalization selection');
+// Call once when an immutable partition is decoded. The derived index is a
+// non-enumerable symbol property, so it cannot alter any serialized record.
+export function preparePersonalizationRoute(route, experiments) {
+    const existing = route[preparedSelection];
+    if (existing && existing.sourceExperiments === experiments)
+        return route;
+    return Object.freeze(Object.defineProperty({ ...route }, preparedSelection, { value: deriveSelection(route, experiments) }));
+}
+export function personalizationSelection(route, experiments) {
+    return preparePersonalizationRoute(route, experiments)[preparedSelection];
+}
+function deriveSelection(route, experiments) {
+    const authored = [];
+    const arms = Object.create(null);
+    const legacy = new Set();
+    const qualified = new Set();
+    for (const [key, variant] of Object.entries(route.variants || {})) {
+        const values = Object.freeze({ ...(variant.variantValues || variantValuesFromKey(key)) });
+        // DEBT(edge-functions): ADR-0045 bounded pair reader and counter. Remove
+        // only when every retained release in every tenant compiles under the
+        // post-removal compiler; pair entries then become malformed.
+        if (isPairVariant(key, values)) {
+            const id = values.experiment || key.split(';').find((part) => part.startsWith('experiment='))?.slice('experiment='.length);
+            if (id && experiments?.[id])
+                legacy.add(id);
+            continue;
+        }
+        const names = Object.keys(values);
+        const ids = names.filter((name) => name.startsWith('experiment.')).map((name) => name.slice('experiment.'.length));
+        for (const id of ids)
+            qualified.add(id);
+        if (ids.length === 1 && names.length === 1) {
+            const id = ids[0];
+            (arms[id] ||= Object.create(null))[values[`experiment.${id}`]] = variant;
+        }
+        const factors = ids.map((id) => experiments?.[id]);
+        if (factors.some((item) => !item || item.kind !== 'xt' || item.status !== 'running'))
+            continue;
+        authored.push(Object.freeze({ key, variant, values, experiments: Object.freeze(factors) }));
+    }
+    for (const id of qualified)
+        legacy.delete(id);
+    authored.sort((left, right) => (right.variant.priority || 0) - (left.variant.priority || 0) || compareUTF8(left.key, right.key));
+    const scoped = Object.keys(experiments || {}).sort(compareUTF8).map((id) => experiments[id])
+        .filter((item) => (item.kind === 'ab' || item.kind === 'abn') && item.status === 'running' && !legacy.has(item.id));
+    for (const entries of Object.values(arms))
+        Object.freeze(entries);
+    return Object.freeze({ sourceExperiments: experiments, authored: Object.freeze(authored), experiments: Object.freeze(scoped), arms: Object.freeze(arms), tuples: route.variants || {}, legacyExperimentExclusions: legacy.size });
+}
+function isPairVariant(key, values) {
+    const names = [...key.split(';').map((part) => part.split('=')[0]), ...Object.keys(values)];
+    return names.some((name) => name.toLowerCase() === 'experiment' || name.toLowerCase() === 'experimentarm');
+}

package/dist/internal/domain/edge/record/codec.d.ts

@@ -1,4 +1,4 @@
-import type { EdgeRouteEntry, ClassificationData } from '../types.js';
+import type { EdgeRouteEntry } from '../types.js';
 /**
  * Unique sentinel object returned by expand functions on failure.
  * Callers check `result === INVALID`. Never throws.
@@ -10,14 +10,17 @@ interface CompactDispatch {
     ap: string;
 }
 interface CompactCondition {
-    f: string;
-    o: string;
+    f?: string;
+    o?: string;
     w?: unknown;
+    a?: CompactCondition[];
+    n?: CompactCondition[];
 }
 interface CompactRule {
     a?: CompactCondition[];
     n?: CompactCondition[];
 }
+export declare const COMPACT_MAX_DEPTH = 32;
 interface CompactVariant {
     pr?: number;
     r?: CompactRule;
@@ -34,35 +37,6 @@ export interface CompactRouteRecord {
 }
 export declare function projectRouteRecord(entry: EdgeRouteEntry): CompactRouteRecord;
 export declare function expandRouteRecord(raw: unknown): EdgeRouteEntry | Invalid;
-export interface CompactClassificationData {
-    au?: Record<string, {
-        r?: CompactRule;
-    }>;
-    sg?: Record<string, {
-        r?: CompactRule;
-    }>;
-    x?: Record<string, CompactExperiment>;
-}
-interface CompactExperimentArm {
-    id: string;
-    ab?: number;
-    vk?: string;
-    ro?: string;
-}
-interface CompactExperiment {
-    id: string;
-    st?: string;
-    k?: string;
-    av?: string;
-    sl?: string;
-    pr?: number;
-    ar?: CompactExperimentArm[];
-    dn?: string;
-    pg?: string;
-    gl?: string[];
-}
-export declare function projectClassificationData(data: ClassificationData): CompactClassificationData;
-export declare function expandClassificationData(raw: unknown): ClassificationData | Invalid;
 export declare const MARKER = "{\"s\":1,\"e\":1}";
 export declare function isMarker(raw: string): boolean;
 export declare function canonicalSerialize(value: unknown): string;

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

@@ -1,4 +1,4 @@
-// Compact JSON codec for edge-decisioning route records and classification data.
+// Compact JSON codec for edge-decisioning route records.
 //
 // project(): canonical → compact (short field names via alias table, omit defaults)
 // expand():  compact → canonical (reverse, never throws — returns INVALID sentinel on failure)
@@ -41,21 +41,13 @@ const DISPATCH_KIND_FROM_COMPACT = {
 };
 const OPERATOR_TO_COMPACT = {
     equals: 'eq', contains: 'ct', startsWith: 'sw', exists: 'ex',
+    greaterThan: 'gt', greaterThanOrEqual: 'ge', lessThan: 'lt', lessThanOrEqual: 'le',
+    before: 'bf', after: 'af', between: 'bt', in: 'in',
 };
 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',
+    gt: 'greaterThan', ge: 'greaterThanOrEqual', lt: 'lessThan', le: 'lessThanOrEqual',
+    bf: 'before', af: 'after', bt: 'between', in: 'in',
 };
 // Compact type guard — reduces minified bytes vs repeated typeof+null+isArray checks
 function isObj(v) {
@@ -78,20 +70,89 @@ function expandDispatch(raw) {
         return INVALID;
     return { kind, artifactPath };
 }
-function projectCondition(cond) {
-    if (!cond || !cond.field || !cond.operator)
-        return null;
+// Structural recursion guard, deliberately looser than the authored MaxDepth
+// (5) the validators enforce. The codec's job is to bound adversarial
+// recursion in a byte-constrained runtime; the authored contract is
+// validation's. Keeping it looser is what lets an over-depth expression
+// round-trip and be rejected by validation identically in every runtime,
+// rather than being erased by the codec first (ADR 0040).
+export const COMPACT_MAX_DEPTH = 32;
+// A member carrying all/any is an envelope, not a condition — the same
+// presence rule the evaluators apply, so the codec cannot disagree with them
+// about what a member is.
+function isGroupMember(cond) {
+    return !!cond && (cond.all !== undefined || cond.any !== undefined);
+}
+function projectCondition(cond, depth) {
+    // Projection runs at publish time in a trusted context behind write-time
+    // validation: a malformed condition or an operator with no compact token is
+    // vocabulary/codec drift, and silently dropping the condition would ship a
+    // rule missing a leaf — MORE permissive than authored (ADR 0038). The same
+    // reasoning covers a group node: dropping one publishes a rule the author
+    // did not write. Expansion stays fail-closed for already-deployed bundles.
+    if (!cond) {
+        throw new Error('edge rule condition must name a field and operator');
+    }
+    if (isGroupMember(cond)) {
+        if (depth > COMPACT_MAX_DEPTH) {
+            throw new Error('edge rule nests deeper than the codec can project');
+        }
+        if (cond.field !== undefined || cond.operator !== undefined || cond.value !== undefined) {
+            throw new Error('edge rule member mixes group and leaf keys');
+        }
+        const group = {};
+        if (cond.all && cond.all.length > 0)
+            group.a = cond.all.map((member) => projectCondition(member, depth + 1));
+        if (cond.any && cond.any.length > 0)
+            group.n = cond.any.map((member) => projectCondition(member, depth + 1));
+        if (!group.a && !group.n) {
+            throw new Error('edge rule group must include at least one member');
+        }
+        return group;
+    }
+    if (!cond.field || !cond.operator) {
+        throw new Error('edge rule condition must name a field and operator');
+    }
     const compactOp = OPERATOR_TO_COMPACT[cond.operator];
-    if (!compactOp)
-        return null;
+    if (!compactOp) {
+        throw new Error(`edge rule operator has no compact token: ${cond.operator}`);
+    }
     const result = { f: cond.field, o: compactOp };
-    if (cond.operator !== 'exists' && cond.value !== undefined)
+    if (cond.value !== undefined)
         result.w = cond.value;
     return result;
 }
-function expandCondition(raw) {
+function expandCondition(raw, depth) {
     if (!isObj(raw))
         return INVALID;
+    if (raw.a !== undefined || raw.n !== undefined) {
+        if (depth > COMPACT_MAX_DEPTH)
+            return INVALID;
+        // A member cannot be both: expanding a mixed record would hand the
+        // evaluator something neither a group nor a condition.
+        if (raw.f !== undefined || raw.o !== undefined || raw.w !== undefined)
+            return INVALID;
+        const group = {};
+        for (const [compact, key] of [['a', 'all'], ['n', 'any']]) {
+            if (raw[compact] === undefined)
+                continue;
+            if (!Array.isArray(raw[compact]))
+                return INVALID;
+            const members = [];
+            for (const member of raw[compact]) {
+                const expanded = expandCondition(member, depth + 1);
+                if (expanded === INVALID)
+                    return INVALID;
+                members.push(expanded);
+            }
+            group[key] = members;
+        }
+        // Length, not truthiness: [] is truthy, so a group whose only list is
+        // empty would otherwise expand into a member with no predicate at all.
+        if ((group.all?.length || 0) + (group.any?.length || 0) === 0)
+            return INVALID;
+        return group;
+    }
     const f = raw.f;
     const co = raw.o;
     if (typeof f !== 'string')
@@ -100,7 +161,7 @@ function expandCondition(raw) {
     if (!op)
         return INVALID;
     const c = { field: f, operator: op };
-    if (op !== 'exists' && raw.w !== undefined)
+    if (raw.w !== undefined)
         c.value = raw.w;
     return c;
 }
@@ -109,9 +170,9 @@ function projectRule(rule) {
         return undefined;
     const result = {};
     if (rule.all && rule.all.length > 0)
-        result.a = rule.all.map(projectCondition).filter((c) => c !== null);
+        result.a = rule.all.map((cond) => projectCondition(cond, 1));
     if (rule.any && rule.any.length > 0)
-        result.n = rule.any.map(projectCondition).filter((c) => c !== null);
+        result.n = rule.any.map((cond) => projectCondition(cond, 1));
     if (!result.a && !result.n)
         return undefined;
     return result;
@@ -124,7 +185,7 @@ function expandRule(raw) {
     const rule = {};
     if (Array.isArray(raw.a))
         for (const c of raw.a) {
-            const r = expandCondition(c);
+            const r = expandCondition(c, 1);
             if (r === INVALID)
                 return INVALID;
             if (r)
@@ -132,7 +193,7 @@ function expandRule(raw) {
         }
     if (Array.isArray(raw.n))
         for (const c of raw.n) {
-            const r = expandCondition(c);
+            const r = expandCondition(c, 1);
             if (r === INVALID)
                 return INVALID;
             if (r)
@@ -218,149 +279,6 @@ export function expandRouteRecord(raw) {
     }
     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) {

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

@@ -1,58 +1,91 @@
 // 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.
+// Reads cookies for classification but never writes them. It may issue a
+// first-party identity in memory when the host permits (ADR 0048); persisting
+// that identity is the host's job. 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';
+import { consentSignals, verifyIdentityCookie, identityHashHex, randomIdentity, 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).
+    // Identity model (ADR 0016 as amended by ADR 0048): experiment bucketing is
+    // measurement, keyed by the first-party aci_id. A verified cookie (or the
+    // provider bootstrap's identity) is used as presented. With none usable, and
+    // only when the host's issuance rule permits it for this request, resolve
+    // issues a fresh identity so the request that issues it is also bucketed —
+    // an unverifiable cookie is replaced the same way. Persisting the issued
+    // identity is the host's decision (page responses only, never shared-cached).
+    // Claims and memberships stay gated on the personalization grant.
     //
-    // GPC/DNT deny fully: no read, no identity, no experiment bucketing.
-    const rawIdentity = consent.privacyDenied
+    // GPC/DNT deny fully: no read, no identity, no issuance, no bucketing.
+    //
+    // Mimic (specs/features/audience-mimic): a validated mimicClaims input
+    // bypasses identity resolution entirely — the session reads no aci_id and
+    // no aci_claims (D-2/D-7), so identityHash stays empty and the experiment
+    // tier is structurally skipped (D-5). An ARMS-bearing token is the D-17
+    // exception: the experiment tier runs in forced mode — the token's named
+    // arm replaces the dice for each experiment the request selects through
+    // the ordinary gate — and identity still never exists (I-17).
+    const mimic = config.mimicClaims;
+    const verifiedVisitor = mimic || consent.privacyDenied ? undefined : config.verifiedVisitor;
+    const presentedIdentity = mimic || consent.privacyDenied
         ? null
-        : await verifyIdentityCookie(cookies.get('aci_id') || '', config.identityKeys);
+        : verifiedVisitor
+            ? verifiedVisitor.rawIdentity
+            : await verifyIdentityCookie(cookies.get('aci_id') || '', config.identityKeys);
+    const issuedIdentity = !presentedIdentity && !mimic && !consent.privacyDenied && config.issueIdentity
+        ? randomIdentity(config.randomBytes)
+        : undefined;
+    const rawIdentity = presentedIdentity || issuedIdentity || null;
     // 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') || '';
+    // Claims are a signed cookie written by /collect or the provider identity
+    // bootstrap; the EdgeRouter never reads the customer object store to
+    // refresh or revoke them.
     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
+        const claims = mimic
+            ? { aud: mimic.aud, seg: mimic.seg, iat: 0, exp: 0 }
+            : consent.allowsIdentityTier
+                ? verifiedVisitor
+                    ? verifiedVisitor.claims
+                    : await verifyClaims(cookies.get('aci_claims') || '', config.claimsKeys || {}, now)
+                : null;
+        const decision = resolvePersonalizationDecision(toPersonalizationRequestContext(request, now, config.requestGeo, config.onRuleRejected), matchedRoute, claims, config.experiments, identityHash
             ? { usable: true, siteId: config.siteId, namespace: 'aci_id', identityHash }
-            : undefined);
+            : undefined, mimic?.arms);
         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 };
+        const experiments = decision.experiments.map((item) => ({
+            id: item.experimentId,
+            arm: item.armId,
+            allocationVersion: item.allocationVersion,
+            ...(item.forced ? { forced: true } : {}),
+        }));
+        return {
+            variantKey,
+            experiments,
+            ...(decision.legacyExperimentExclusions ? { legacyExperimentExclusions: decision.legacyExperimentExclusions } : {}),
+            ...(issuedIdentity ? { issuedIdentity } : {}),
+        };
     }
-    return { variantKey };
+    return { variantKey, experiments: [], ...(issuedIdentity ? { issuedIdentity } : {}) };
 }
-function toPersonalizationRequestContext(request) {
+// The return type is annotated rather than inferred so the contract is stated
+// at the construction site: a misspelled property would then silently never
+// fire at the sink, which is the exact failure mode this context exists to
+// make visible. No tsconfig covers internal/domain/** today (esbuild/tsx strip
+// types without checking), so the annotation is documentation now and becomes
+// real protection under any future typecheck of these trees.
+function toPersonalizationRequestContext(request, now, requestGeo, onRuleRejected) {
     const url = new URL(request.url);
     const cookies = parseCookieHeader(request.headers.get('cookie'));
     const query = {};
@@ -60,17 +93,21 @@ function toPersonalizationRequestContext(request) {
         (query[key] ||= []).push(value);
     });
     const headers = Object.fromEntries(request.headers.entries());
+    // geo.* facts come only from the host's trusted geo. Reading provider geo
+    // headers here trusted whatever the viewer sent on every lane whose
+    // provider does not stamp that exact header before the decision runs.
+    const geo = Object.fromEntries(Object.entries(requestGeo ?? {})
+        .filter((entry) => typeof entry[1] === 'string' && entry[1] !== ''));
     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'] || '',
-            },
-        },
+        // The host's pinned per-request clock resolves the time.now fact
+        // (ADR 0038), so claims verification and window evaluation read one
+        // instant — and config.now-injected tests are deterministic.
+        now: now.getTime(),
+        ...(Object.keys(geo).length > 0 ? { signals: { geo } } : {}),
+        ...(onRuleRejected ? { onRuleRejected } : {}),
     };
 }

package/dist/internal/domain/edge/testdata/flat_only_validator_v1.d.ts

@@ -0,0 +1,10 @@
+export interface FrozenExpressionDiagnostic {
+    code: string;
+    path: string;
+    scope: 'request';
+    message: string;
+}
+export declare function frozenValidateRequestExpression(rule: {
+    all?: unknown[];
+    any?: unknown[];
+}): FrozenExpressionDiagnostic[];