@gradial/aci 0.1.52-rc.9 → 0.1.52

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

@@ -1,401 +0,0 @@
-// 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/next/collect-route.d.ts

@@ -1,19 +0,0 @@
-import { type IdentitySigningKeys, type PersonalizationCollectionStore } from './personalization-host.js';
-export interface PersonalizationCollectRouteConfig {
-    siteId: string;
-    store: PersonalizationCollectionStore;
-    identityKeys: IdentitySigningKeys;
-    /**
-     * Claims verify keys (kid -> secret) for withdrawal EVIDENCE
-     * (anonymous-experiments REQ-6): suppression fires only when the request
-     * presents a signature-verified aci_claims cookie — presence alone is
-     * spoofable, and under universal minting an unverified trigger would
-     * suppress every reject-all visitor. Empty = evidence never verifies =
-     * suppression disabled (fails safe).
-     */
-    claimsKeys?: Record<string, string>;
-    retentionSeconds?: number;
-    secureCookies?: boolean;
-    now?: () => Date;
-}
-export declare function createPersonalizationCollectRoute(config: PersonalizationCollectRouteConfig): (request: Request) => Promise<Response>;