@gradial/aci 0.1.52-rc.16 → 0.1.52-rc.21

package/dist/edge/personalization-core.js

@@ -1,483 +0,0 @@
-// Runtime-neutral personalization selection. Vercel imports this module and
-// the CloudFront Terraform wrapper inlines the same source into its function.
-// Keep this file free of platform APIs and dependencies.
-export function selectPersonalizationVariant(request, route, claims, experiments, identity) {
-    return resolvePersonalizationDecision(request, route, claims, experiments, identity).variant;
-}
-export function resolvePersonalizationDecision(request, route, claims, experiments, identity) {
-    if (!route)
-        return { variant: null, experiment: null };
-    let variant = selectRuleVariant(request, route, claims, experiments);
-    let experiment = null;
-    if (identity && identity.usable && route.variants && experiments) {
-        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++) {
-            const item = candidates[index];
-            const assignment = assignExperiment(item, identity);
-            const candidate = assignment && route.variants[assignment.variantKey];
-            if (!candidate)
-                continue;
-            if (!variant || betterVariant(candidate.priority || 0, candidate.variantKey, variant.priority || 0, variant.variantKey)) {
-                variant = candidate;
-                experiment = assignment;
-            }
-            break;
-        }
-    }
-    return { variant: variant || null, experiment };
-}
-function selectRuleVariant(request, route, claims, experiments) {
-    if (!route.variants)
-        return null;
-    const matches = [];
-    for (const key in route.variants) {
-        const variant = route.variants[key];
-        const values = variant.variantValues || variantValuesFromKey(key);
-        const experimentID = String(values.experiment || '').trim();
-        if (experimentID && (!experiments || !experiments[experimentID]
-            || experiments[experimentID].status !== 'running'
-            || !experimentEligible(experiments[experimentID], claims)))
-            continue;
-        if (!requestDimensionsMatch(request, values))
-            continue;
-        const membershipMatch = (values.audience && claims && (claims.aud || []).includes(values.audience))
-            || (values.segment && claims && (claims.seg || []).includes(values.segment));
-        const ruleMatch = variant.rule ? evaluateRule(request, variant.rule) : false;
-        if (membershipMatch || ruleMatch)
-            matches.push(variant);
-    }
-    matches.sort((left, right) => (right.priority || 0) - (left.priority || 0)
-        || String(left.variantKey || '').localeCompare(String(right.variantKey || '')));
-    return matches[0] || null;
-}
-// CloudFront KVS values are capped at 1 KiB. The variant map key is the
-// canonical encoding of its dimensions, so compact route records omit the
-// duplicated variantValues object and recover it at the edge.
-function variantValuesFromKey(key) {
-    const values = {};
-    const parts = String(key || '').replace(/&/g, ';').split(';');
-    for (let index = 0; index < parts.length; index++) {
-        const separator = parts[index].indexOf('=');
-        if (separator > 0)
-            values[parts[index].slice(0, separator)] = parts[index].slice(separator + 1);
-    }
-    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);
-        if (values.experiment === experimentID)
-            return true;
-    }
-    return false;
-}
-function assignExperiment(experiment, identity) {
-    const version = String(experiment.allocationVersion || '').trim();
-    const salt = String(experiment.salt || '').trim();
-    const siteID = String(identity.siteId || '').trim();
-    const identityKey = `${String(identity.namespace || '').trim()}:${String(identity.identityHash || '').trim()}`;
-    if (!version || !salt || !siteID || identityKey === ':')
-        return null;
-    const input = [siteID, String(experiment.id || ''), version, identityKey, salt].join('\0');
-    const bucket = sha256Bucket(input);
-    let cumulative = 0;
-    const arms = experiment.arms || [];
-    for (let index = 0; index < arms.length; index++) {
-        const arm = arms[index];
-        if ((arm.allocationBasisPoints || 0) <= 0)
-            continue;
-        cumulative += arm.allocationBasisPoints;
-        if (bucket < cumulative) {
-            return {
-                experimentId: experiment.id,
-                armId: arm.id,
-                allocationVersion: version,
-                variantKey: arm.variantKey,
-                bucket,
-            };
-        }
-    }
-    return null;
-}
-function betterVariant(candidatePriority, candidateKey, bestPriority, bestKey) {
-    if (candidatePriority !== bestPriority)
-        return candidatePriority > bestPriority;
-    return String(candidateKey || '').localeCompare(String(bestKey || '')) < 0;
-}
-function requestDimensionsMatch(request, values) {
-    for (const rawKey in values) {
-        const rawWant = values[rawKey];
-        const key = String(rawKey).trim();
-        const normalized = key.toLowerCase();
-        const want = String(rawWant).trim();
-        if (!key || !want || ['audience', 'segment', 'experiment', 'experimentarm'].includes(normalized))
-            continue;
-        const candidates = (request.query[key] || []).concat(request.query['aci_' + key] || [], request.headers['x-aci-' + normalized] || '', request.headers['x-gradial-' + normalized] || '', request.cookies[key] || '', request.cookies['aci_' + key] || '');
-        if (normalized === 'locale') {
-            const locales = String(request.headers['accept-language'] || '')
-                .split(',').map((part) => part.split(';')[0].trim()).filter(Boolean);
-            for (let localeIndex = 0; localeIndex < locales.length; localeIndex++)
-                candidates.push(locales[localeIndex]);
-        }
-        if (!candidates.some((candidate) => normalized === 'locale'
-            ? String(candidate).toLowerCase() === want.toLowerCase()
-            : String(candidate) === want))
-            return false;
-    }
-    return true;
-}
-const MAX_EXPRESSION_CONDITIONS = 64;
-export function evaluateRequestExpression(rule, resolve) {
-    const all = rule.all || [];
-    const any = rule.any || [];
-    const empty = all.length + any.length === 0;
-    const diagnostics = validateRequestExpression(rule, all, any);
-    const trace = { scope: 'request', empty, groups: [], leaves: [] };
-    if (diagnostics.length > 0)
-        return { qualified: false, diagnostics, trace };
-    const qualified = qualifyRequestExpression(all, any, resolve, trace);
-    return { qualified, diagnostics, trace };
-}
-function evaluateRule(request, rule) {
-    const all = rule.all || [];
-    const any = rule.any || [];
-    if (validateRequestExpression(rule, all, any).length > 0)
-        return false;
-    return qualifyRequestExpression(all, any, (field) => signalFact(request, field));
-}
-function validateRequestExpression(rule, all, any) {
-    const diagnostics = [];
-    if (all.length + any.length === 0)
-        diagnostics.push({ code: 'expression.empty', path: 'expression', scope: 'request', message: 'expression must include at least one all or any condition' });
-    if (all.length + any.length > MAX_EXPRESSION_CONDITIONS)
-        diagnostics.push({ code: 'expression.conditions.too_many', path: 'expression', scope: 'request', message: `expression must contain at most ${MAX_EXPRESSION_CONDITIONS} conditions` });
-    Object.keys(rule).filter((group) => group !== 'all' && group !== 'any').sort().forEach((group) => {
-        diagnostics.push({ code: 'expression.group.unsupported', path: `expression.${group}`, scope: 'request', message: `expression.${group} is not a supported expression group` });
-    });
-    for (const [group, conditions] of [['all', all], ['any', any]]) {
-        conditions.forEach((condition, index) => validateRequestCondition(condition, `expression.${group}[${index}]`, diagnostics));
-    }
-    return diagnostics;
-}
-function qualifyRequestExpression(all, any, resolve, trace) {
-    let qualified = true;
-    for (const [group, conditions] of [['all', all], ['any', any]]) {
-        let matched = 0;
-        conditions.forEach((condition, index) => {
-            const fact = normalizeFact(resolve(String(condition.field || '')));
-            const outcome = matchRequestCondition(condition, fact);
-            if (outcome.matched)
-                matched++;
-            if (trace)
-                trace.leaves.push({
-                    path: `expression.${group}[${index}]`, group, index,
-                    field: String(condition.field || ''), operator: String(condition.operator || ''),
-                    status: fact.status, matched: outcome.matched, reason: outcome.reason,
-                });
-        });
-        const passed = group === 'all' ? matched === conditions.length : conditions.length === 0 || matched > 0;
-        if (trace)
-            trace.groups.push({ group, total: conditions.length, matched, passed });
-        qualified = qualified && passed;
-    }
-    return qualified;
-}
-function validateRequestCondition(condition, path, diagnostics) {
-    Object.keys(condition).filter((property) => !['field', 'operator', 'value'].includes(property)).sort().forEach((property) => {
-        diagnostics.push({ code: 'expression.property.unsupported', path: `${path}.${property}`, scope: 'request', message: `${path}.${property} is not a supported condition property` });
-    });
-    const field = String(condition.field || '');
-    if (field !== 'referrer' && field !== 'device.class' && !['query.', 'header.', 'cookie.', 'geo.', 'utm.'].some((prefix) => field.startsWith(prefix) && field.length > prefix.length)) {
-        diagnostics.push({ code: 'expression.field.unsupported', path: `${path}.field`, scope: 'request', message: `${path}.field ${JSON.stringify(field)} is not supported` });
-    }
-    const operator = String(condition.operator || '');
-    if (!['equals', 'contains', 'startsWith', 'exists'].includes(operator)) {
-        diagnostics.push({ code: 'expression.operator.unsupported', path: `${path}.operator`, scope: 'request', message: `${path}.operator ${JSON.stringify(operator)} is not supported` });
-        return;
-    }
-    // device.class compares against a closed four-value set, so substring
-    // operators express nothing the set cannot — and admitting them would
-    // re-create the user-agent-substring habit inside the safe field (ADR 0035).
-    if (field === 'device.class' && operator !== 'equals' && operator !== 'exists') {
-        diagnostics.push({ code: 'expression.operator.unsupported', path: `${path}.operator`, scope: 'request', message: `${path}.operator ${JSON.stringify(operator)} is not supported for field ${JSON.stringify(field)}, which compares against a closed value set` });
-        return;
-    }
-    const value = condition.value;
-    if (operator === 'exists') {
-        if (value !== undefined && value !== null && typeof value !== 'boolean') {
-            diagnostics.push({ code: 'expression.value.invalid', path: `${path}.value`, scope: 'request', message: `${path}.value must be a boolean for operator exists` });
-        }
-    }
-    else if (value === undefined || value === null) {
-        diagnostics.push({ code: 'expression.value.required', path: `${path}.value`, scope: 'request', message: `${path}.value is required for operator ${operator}` });
-    }
-    else if (!['string', 'number', 'boolean'].includes(typeof value)
-        || (typeof value === 'number' && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))))) {
-        diagnostics.push({ code: 'expression.value.invalid', path: `${path}.value`, scope: 'request', message: `${path}.value must be a string, boolean, or finite number using only safe integers` });
-    }
-    else if (field === 'device.class' && DEVICE_CLASSES.indexOf(canonicalScalar(value)) < 0) {
-        diagnostics.push({ code: 'expression.value.invalid', path: `${path}.value`, scope: 'request', message: `${path}.value must be one of ${DEVICE_CLASSES.join(', ')} for field ${JSON.stringify(field)}` });
-    }
-}
-function matchRequestCondition(condition, fact) {
-    if (fact.status === 'unavailable')
-        return { matched: false, reason: 'unavailable' };
-    if (condition.operator === 'exists') {
-        const expected = typeof condition.value === 'boolean' ? condition.value : true;
-        const matched = (fact.status === 'present') === expected;
-        return { matched, reason: matched ? 'matched' : fact.status === 'absent' ? 'absent' : 'not_matched' };
-    }
-    if (fact.status === 'absent')
-        return { matched: false, reason: 'absent' };
-    const expected = canonicalScalar(condition.value);
-    const matched = (fact.values || []).some((value) => condition.operator === 'equals' ? value === expected
-        : condition.operator === 'contains' ? value.includes(expected)
-            : condition.operator === 'startsWith' ? value.startsWith(expected) : false);
-    return { matched, reason: matched ? 'matched' : 'not_matched' };
-}
-function canonicalScalar(value) {
-    if (typeof value === 'number')
-        return Object.is(value, -0) ? '0' : JSON.stringify(value);
-    return String(value);
-}
-function normalizeFact(fact) {
-    if (!fact || !['present', 'absent', 'unavailable'].includes(fact.status))
-        return { status: 'unavailable' };
-    return fact;
-}
-function signalFact(request, field) {
-    const own = (record, key) => !!record && Object.prototype.hasOwnProperty.call(record, key);
-    const d = field.indexOf('.');
-    if (d < 0) {
-        if (field !== 'referrer')
-            return { status: 'absent' };
-        const key = own(request.headers, 'referer') ? 'referer' : 'referrer';
-        return own(request.headers, key) ? { status: 'present', values: [request.headers[key]] } : { status: 'absent' };
-    }
-    const p = field.slice(0, d), k = field.slice(d + 1);
-    if (p === 'query')
-        return own(request.query, k) ? { status: 'present', values: request.query[k] } : { status: 'absent' };
-    if (p === 'utm') {
-        const key = 'utm_' + k;
-        return own(request.query, key) ? { status: 'present', values: request.query[key] } : { status: 'absent' };
-    }
-    if (p === 'header') {
-        const key = k.toLowerCase();
-        return own(request.headers, key) ? { status: 'present', values: [request.headers[key]] } : { status: 'absent' };
-    }
-    if (p === 'cookie')
-        return own(request.cookies, k) ? { status: 'present', values: [request.cookies[k]] } : { status: 'absent' };
-    if (p === 'device') {
-        // Derived, not injected: no signals plumbing, so preview, edge, and SDK
-        // agree by construction. A request with no user-agent header is absent.
-        if (k !== 'class')
-            return { status: 'absent' };
-        const deviceClass = cachedDeviceClass(request);
-        return deviceClass ? { status: 'present', values: [deviceClass] } : { status: 'absent' };
-    }
-    if (p === 'geo') {
-        const record = request.signals && request.signals.geo;
-        if (!record)
-            return { status: 'unavailable' };
-        return own(record, k) ? { status: 'present', values: [record[k]] } : { status: 'absent' };
-    }
-    return { status: 'absent' };
-}
-// SHA-256 mirrors experiment.assignment.go: the first eight digest bytes are
-// interpreted big-endian and reduced modulo 10,000 basis points.
-// CLOUDFRONT_STRIP_START — the build script removes this block for CloudFront
-// Functions (experiment bucketing moves to the hosting Lambda to stay under
-// the 10 KiB function size limit).
-function sha256Bucket(value) {
-    const bytes = utf8(value);
-    const words = new Uint32Array(64);
-    const bitLength = bytes.length * 8;
-    const paddedLength = ((bytes.length + 9 + 63) >> 6) << 6;
-    const data = new Uint8Array(paddedLength);
-    data.set(bytes);
-    data[bytes.length] = 128;
-    // The message length is a 64-bit big-endian integer across the final
-    // eight bytes. The previous code wrote a single truncated byte into each
-    // word's most significant position, corrupting every digest (caught by
-    // the assignment parity vectors, spec experiment-variant-caching REQ-9).
-    const bitsHigh = Math.floor(bitLength / 0x100000000);
-    const bitsLow = bitLength >>> 0;
-    data[paddedLength - 8] = (bitsHigh >>> 24) & 255;
-    data[paddedLength - 7] = (bitsHigh >>> 16) & 255;
-    data[paddedLength - 6] = (bitsHigh >>> 8) & 255;
-    data[paddedLength - 5] = bitsHigh & 255;
-    data[paddedLength - 4] = (bitsLow >>> 24) & 255;
-    data[paddedLength - 3] = (bitsLow >>> 16) & 255;
-    data[paddedLength - 2] = (bitsLow >>> 8) & 255;
-    data[paddedLength - 1] = bitsLow & 255;
-    let a = 0x6a09e667, b = 0xbb67ae85, c = 0x3c6ef372, d = 0xa54ff53a;
-    let e = 0x510e527f, f = 0x9b05688c, g = 0x1f83d9ab, h = 0x5be0cd19;
-    const k = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
-    for (let offset = 0; offset < paddedLength; offset += 64) {
-        for (let i = 0; i < 16; i++) {
-            const p = offset + i * 4;
-            words[i] = (data[p] << 24) | (data[p + 1] << 16) | (data[p + 2] << 8) | data[p + 3];
-        }
-        for (let i = 16; i < 64; i++) {
-            const x = words[i - 15], y = words[i - 2];
-            words[i] = (words[i - 16] + (rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3)) + words[i - 7] + (rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10))) >>> 0;
-        }
-        let aa = a, bb = b, cc = c, dd = d, ee = e, ff = f, gg = g, hh = h;
-        for (let i = 0; i < 64; i++) {
-            const s1 = rotr(ee, 6) ^ rotr(ee, 11) ^ rotr(ee, 25);
-            const ch = (ee & ff) ^ (~ee & gg);
-            const t1 = (hh + s1 + ch + k[i] + words[i]) >>> 0;
-            const s0 = rotr(aa, 2) ^ rotr(aa, 13) ^ rotr(aa, 22);
-            const maj = (aa & bb) ^ (aa & cc) ^ (bb & cc);
-            const t2 = (s0 + maj) >>> 0;
-            hh = gg;
-            gg = ff;
-            ff = ee;
-            ee = (dd + t1) >>> 0;
-            dd = cc;
-            cc = bb;
-            bb = aa;
-            aa = (t1 + t2) >>> 0;
-        }
-        a = (a + aa) >>> 0;
-        b = (b + bb) >>> 0;
-        c = (c + cc) >>> 0;
-        d = (d + dd) >>> 0;
-        e = (e + ee) >>> 0;
-        f = (f + ff) >>> 0;
-        g = (g + gg) >>> 0;
-        h = (h + hh) >>> 0;
-    }
-    // Reduce the 64-bit big-endian value modulo 10000 in 32-bit halves:
-    // (hi*2^32 + lo) % 10000 == ((hi%10000) * (2^32 % 10000) + lo%10000) % 10000,
-    // and 2^32 % 10000 = 7296. Multiplying hi by 2^32 directly exceeds
-    // Number.MAX_SAFE_INTEGER and rounds away the low bits — that float error
-    // made most JS buckets diverge from assignment.go (caught by the
-    // assignment parity vectors, spec experiment-variant-caching REQ-9).
-    return (((a >>> 0) % 10000) * 7296 + ((b >>> 0) % 10000)) % 10000;
-}
-function rotr(value, amount) { return (value >>> amount) | (value << (32 - amount)); }
-function utf8(value) {
-    const out = [];
-    for (let i = 0; i < value.length; i++) {
-        let code = value.charCodeAt(i);
-        if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length) {
-            const next = value.charCodeAt(++i);
-            code = 0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00);
-        }
-        if (code < 0x80)
-            out.push(code);
-        else if (code < 0x800)
-            out.push(0xc0 | (code >> 6), 0x80 | (code & 63));
-        else if (code < 0x10000)
-            out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 63), 0x80 | (code & 63));
-        else
-            out.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 63), 0x80 | ((code >> 6) & 63), 0x80 | (code & 63));
-    }
-    return new Uint8Array(out);
-}
-// CLOUDFRONT_STRIP_END
-// ── Derived request device class (ADR 0035) ──────────────────────────
-//
-// device.class is the one request fact that is neither transcribed from the
-// request nor injected as a signal: it is classified here from headers the
-// request already carries, so this module, the released SDK copy, and the Go
-// preview evaluator agree without three separate plumbing points.
-//
-// The ORDER below is the contract, not an implementation detail. It is fixed
-// by internal/domain/audience/testdata/device-class.v1.json, which Go and both
-// TypeScript copies execute. Change the order only by changing that fixture.
-//
-// The result is approximate and derived from client-controlled input: a
-// personalization convenience, never an authorization or entitlement input.
-export const DEVICE_CLASSES = ['desktop', 'mobile', 'tablet', 'unknown'];
-// Mirrors MaxDeviceHeaderBytes in internal/domain/audience/device.go.
-const MAX_DEVICE_HEADER_BYTES = 512;
-// Tablet runs first because Android tablet agents contain "android" (mobile)
-// and every Android agent contains "linux" (desktop); iPad agents contain
-// neither. Sec-CH-UA-Mobile is a tiebreaker rather than the primary source
-// because UA-CH cannot express tablet at all.
-const DEVICE_TABLET_SIGNATURES = ['ipad', 'tablet', 'playbook', 'kindle', 'silk'];
-// 'iemobile' is deliberately absent: it contains 'mobi' and could never
-// match. Every signature must be reachable given the ones before it.
-const DEVICE_MOBILE_SIGNATURES = ['iphone', 'ipod', 'mobi', 'windows phone', 'blackberry', 'opera mini'];
-const DEVICE_DESKTOP_SIGNATURES = ['windows nt', 'macintosh', 'mac os x', 'x11', 'cros', 'linux'];
-/**
- * Classifies the request's device class from its own headers. Returns '' when
- * the request carried neither User-Agent nor Sec-CH-UA-Mobile, which the fact
- * resolver reports as ABSENT — the same status the missing header itself
- * resolves to, and deliberately distinct from the 'unknown' class, which means
- * classified and unrecognized.
- */
-export function deviceClassFromHeaders(headers) {
-    const userAgent = deviceHeader(headers, 'user-agent');
-    const uaMobile = deviceHeader(headers, 'sec-ch-ua-mobile');
-    if (!userAgent && !uaMobile)
-        return '';
-    const lower = userAgent.toLowerCase();
-    if (DEVICE_TABLET_SIGNATURES.some((token) => lower.indexOf(token) >= 0))
-        return 'tablet';
-    // An Android agent without a "mobi" token is a tablet: Chrome on Android
-    // phones appends "Mobile", Android tablets do not. The explicit !"mobi"
-    // guard is required, not redundant — the mobile pass runs AFTER this one.
-    if (lower.indexOf('android') >= 0 && lower.indexOf('mobi') < 0)
-        return 'tablet';
-    if (DEVICE_MOBILE_SIGNATURES.some((token) => lower.indexOf(token) >= 0))
-        return 'mobile';
-    if (uaMobile === '?1')
-        return 'mobile';
-    if (DEVICE_DESKTOP_SIGNATURES.some((token) => lower.indexOf(token) >= 0))
-        return 'desktop';
-    if (uaMobile === '?0')
-        return 'desktop';
-    return 'unknown';
-}
-// deviceHeader reads one header so that Go's audience.ClassifyDeviceClass
-// cannot disagree with this function about the same request.
-//
-// Keys are lowercase here: every context builder flattens through the Fetch
-// API, which lowercases. There is deliberately NO case-insensitive fallback —
-// the header.* branch above has none either, and adding one for this field
-// only would mean a device rule resolves where an equivalent header rule
-// silently does not.
-//
-// Trimming is ASCII-only on purpose. String.prototype.trim strips U+FEFF but
-// not U+0085; Go's strings.TrimSpace does the reverse. Neither is "right";
-// they only have to match, so both sides trim the same ASCII set. The length
-// bound matches MaxDeviceHeaderBytes in device.go — no signature lives past
-// it, and the header is attacker-sized on an unauthenticated path.
-function deviceHeader(headers, key) {
-    const raw = (headers && headers[key]) || '';
-    if (typeof raw !== 'string')
-        return '';
-    return raw.slice(0, MAX_DEVICE_HEADER_BYTES).replace(/^[ \t\r\n\f\v]+|[ \t\r\n\f\v]+$/g, '');
-}
-// The class describes the REQUEST, so it is identical for every leaf. An
-// envelope may carry up to 64 conditions and a route many candidate variants,
-// each building its own resolver — without this, one page view could lowercase
-// and scan the user agent hundreds of times. Keyed on the context object, so
-// classify()/decide() reuse it too.
-const DEVICE_CLASS_CACHE = new WeakMap();
-function cachedDeviceClass(request) {
-    const hit = DEVICE_CLASS_CACHE.get(request);
-    if (hit !== undefined)
-        return hit;
-    const deviceClass = deviceClassFromHeaders(request.headers);
-    DEVICE_CLASS_CACHE.set(request, deviceClass);
-    return deviceClass;
-}

package/dist/next/collect-route.d.ts

@@ -1,25 +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>;
-    /**
-     * Mimic sign key (audience-mimic design/05): a validly signed, unexpired
-     * aci_mimic cookie gets the uniform 202 with nothing stored and no claims
-     * rotation. An invalid cookie is ignored. Absent = no suppression.
-     */
-    mimicSignKey?: string;
-    retentionSeconds?: number;
-    secureCookies?: boolean;
-    now?: () => Date;
-}
-export declare function createPersonalizationCollectRoute(config: PersonalizationCollectRouteConfig): (request: Request) => Promise<Response>;