@gradial/aci 0.1.48 → 0.1.51-ssr.2

package/dist/next/collect-route.js

@@ -1,422 +0,0 @@
-import { MAX_BATCH_EVENTS } from '../collect/batcher.js';
-import { computeEnvelopeDigest } from './envelope-digest.js';
-import { consentSignals, IdentityErasureFencedError, identityHashHex, parseCookieHeader, verifyClaims, verifyIdentityCookie, } from './personalization-host.js';
-const MAX_COLLECT_BODY_BYTES = 64 * 1024;
-const DEFAULT_RETENTION_SECONDS = 13 * 30 * 24 * 60 * 60;
-const ULID = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i;
-const UTM_KEYS = ['source', 'medium', 'campaign', 'term', 'content', 'id'];
-const ENVELOPE_FIELDS = new Set(['envelopeId', 'events']);
-const EVENT_FIELDS = new Set([
-    'eventId',
-    'eventName',
-    'occurredAt',
-    'properties',
-    'url',
-    'referrer',
-    'title',
-    'path',
-    'utm',
-    'viewport',
-    'experiment',
-]);
-function identityHashShard(identityHash) {
-    const hash = identityHash.trim().toLowerCase();
-    if (hash.length < 2)
-        throw new Error('identity hash is too short');
-    return hash.slice(0, 2);
-}
-export function createPersonalizationCollectRoute(config) {
-    return async function collect(request) {
-        if (request.method === 'OPTIONS')
-            return new Response(null, { status: 204 });
-        if (request.method !== 'POST')
-            return new Response(null, { status: 405, headers: { allow: 'POST, OPTIONS' } });
-        const bytes = new Uint8Array(await request.arrayBuffer());
-        if (bytes.byteLength > MAX_COLLECT_BODY_BYTES)
-            return new Response(null, { status: 413 });
-        let envelopeId;
-        let events;
-        try {
-            const envelope = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
-            if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)) {
-                throw new CollectValidationError('collect envelope must be an object');
-            }
-            for (const key of Object.keys(envelope)) {
-                if (!ENVELOPE_FIELDS.has(key)) {
-                    throw new CollectValidationError(`field ${key} is not allowed on the collect envelope`);
-                }
-            }
-            if (typeof envelope.envelopeId !== 'string' || !ULID.test(envelope.envelopeId.trim())) {
-                throw new CollectValidationError('envelopeId must be a valid ULID');
-            }
-            envelopeId = envelope.envelopeId.trim().toUpperCase();
-            if (!Array.isArray(envelope.events))
-                throw new CollectValidationError('events must be an array');
-            // The TS runtime has no cross-instance quota checker (Go's REQ-14/
-            // REQ-20 guard); the 64KiB body cap plus this per-batch event cap and
-            // the platform WAF are the abuse bounds. The cap is the client
-            // batcher's MAX_BATCH_EVENTS — one constant, both sides of the wire.
-            if (envelope.events.length > MAX_BATCH_EVENTS)
-                throw new CollectValidationError('too many events in one batch');
-            events = envelope.events;
-            const eventIds = new Set();
-            for (const event of events) {
-                validateEvent(event);
-                const eventId = event.eventId.trim().toUpperCase();
-                if (eventId === envelopeId) {
-                    throw new CollectValidationError('envelopeId must be distinct from every eventId');
-                }
-                if (eventIds.has(eventId)) {
-                    throw new CollectValidationError('eventId must be unique within an envelope');
-                }
-                eventIds.add(eventId);
-            }
-        }
-        catch (error) {
-            return validationResponse(error);
-        }
-        const cookies = parseCookieHeader(request.headers.get('cookie'));
-        const signals = consentSignals(request, cookies);
-        const rawIdentity = await verifyIdentityCookie(cookies.get('aci_id') || '', config.identityKeys);
-        const now = (config.now ?? (() => new Date()))();
-        const secure = config.secureCookies ?? new URL(request.url).protocol === 'https:';
-        const responseHeaders = new Headers({ 'cache-control': 'no-store', 'content-type': 'application/json' });
-        try {
-            // Withdrawal EVIDENCE (anonymous-experiments REQ-6): a signature-
-            // verified aci_claims cookie proves prior identity-tier state exists
-            // to suppress. Never-consented visitors present no verifiable claims
-            // and stay measurement-only.
-            const evidence = rawIdentity
-                ? await verifyClaims(cookies.get('aci_claims') || '', config.claimsKeys || {}, now) !== null
-                : false;
-            const putSuppression = async (trigger) => {
-                const hash = await identityHashHex('aci_id', rawIdentity);
-                await config.store.putSuppression(`audience/suppression/${identityHashShard(hash)}/${config.siteId}/aci_id/${hash}/${trigger}.json`, { schemaVersion: 1, trigger, observedAt: now.toISOString() });
-            };
-            if (signals.privacyDenied) {
-                if (rawIdentity && evidence) {
-                    await putSuppression('gpc');
-                }
-                if (cookies.has('aci_claims'))
-                    appendCookie(responseHeaders, expiredClaimsCookie(secure));
-                return accepted(responseHeaders);
-            }
-            if (!rawIdentity)
-                return accepted(responseHeaders);
-            // Measurement tier (anonymous-experiments REQ-5): a verified aci_id
-            // stores events even without a personalization grant — the snapshot
-            // records what was (not) granted. An explicit denial with verified
-            // evidence is an observed withdrawal; measurement storage continues.
-            const personalization = signals.allowsIdentityTier;
-            if (!personalization && signals.hasConsent && evidence) {
-                await putSuppression('withdrawal');
-            }
-            const identityHash = await identityHashHex('aci_id', rawIdentity);
-            const collectedAt = now.toISOString();
-            const expiresAt = new Date(now.getTime() +
-                (config.retentionSeconds ?? DEFAULT_RETENTION_SECONDS) * 1000).toISOString();
-            const consent = signals.snapshot
-                ? {
-                    v: signals.snapshot.version,
-                    p: signals.snapshot.purposes,
-                    ...(signals.snapshot.grantedAt ? { t: signals.snapshot.grantedAt } : {}),
-                    ...(signals.snapshot.source ? { src: signals.snapshot.source } : {}),
-                }
-                : { v: 0, p: [] };
-            const records = events.map((event) => {
-                const normalized = normalizeEvent(event, now);
-                return {
-                    schemaVersion: 2,
-                    eventId: normalized.eventId,
-                    eventName: normalized.eventName,
-                    eventCategory: normalized.eventCategory,
-                    siteId: config.siteId,
-                    identity: { namespace: 'aci_id', hash: identityHash },
-                    // Go decodes `t` as time.Time and CANNOT parse an empty string —
-                    // an empty-t record permanently poisons that identity's
-                    // classification and DSAR reads. Omit t unless a real timestamp
-                    // was observed (legacy bare tokens have none).
-                    consent,
-                    ...(normalized.properties ? { properties: normalized.properties } : {}),
-                    page: normalized.page,
-                    ...(normalized.utm ? { utm: normalized.utm } : {}),
-                    ...(normalized.viewport ? { viewport: normalized.viewport } : {}),
-                    ...(normalized.experiment ? { experiment: normalized.experiment } : {}),
-                    occurredAt: normalized.occurredAt,
-                    collectedAt,
-                    expiresAt,
-                };
-            });
-            if (records.length > 0) {
-                const key = `audience/first-party/${identityHashShard(identityHash)}/${config.siteId}/aci_id/${identityHash}/${envelopeId}.json`;
-                const digest = await computeEnvelopeDigest({
-                    siteId: config.siteId,
-                    acceptedBody: bytes,
-                    identity: { namespace: 'aci_id', hash: identityHash },
-                    consent: {
-                        version: signals.snapshot?.version ?? 0,
-                        purposes: signals.snapshot?.purposes ?? [],
-                        grantedAt: signals.snapshot?.grantedAt,
-                        source: signals.snapshot?.source,
-                    },
-                });
-                try {
-                    await config.store.appendEnvelope({
-                        key,
-                        envelopeId,
-                        siteId: config.siteId,
-                        identityNamespace: 'aci_id',
-                        identityHash,
-                        records,
-                        digest,
-                    });
-                }
-                catch (error) {
-                    if (error instanceof IdentityErasureFencedError) {
-                        if (cookies.has('aci_claims'))
-                            appendCookie(responseHeaders, expiredClaimsCookie(secure));
-                        return accepted(responseHeaders);
-                    }
-                    throw error;
-                }
-            }
-            if (personalization) {
-                const claims = await config.store.readClaims(config.siteId, 'aci_id', identityHash);
-                if (claims)
-                    appendCookie(responseHeaders, claimsCookie(claims, secure));
-                else if (cookies.has('aci_claims'))
-                    appendCookie(responseHeaders, expiredClaimsCookie(secure));
-            }
-            else if (cookies.has('aci_claims')) {
-                // Claims are personalization; a non-granting touch expires them.
-                appendCookie(responseHeaders, expiredClaimsCookie(secure));
-            }
-            return accepted(responseHeaders);
-        }
-        catch {
-            return Response.json({ error: 'internal error', status: 500 }, { status: 500, headers: { 'cache-control': 'no-store' } });
-        }
-    };
-}
-function validateEvent(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new CollectValidationError('event must be an object');
-    for (const key of Object.keys(value)) {
-        if (!EVENT_FIELDS.has(key))
-            throw new CollectValidationError(`field ${key} is not allowed on the public collect route`);
-    }
-    if (typeof value.eventId !== 'string' || !ULID.test(value.eventId.trim()))
-        throw new CollectValidationError('eventId must be a valid ULID');
-    if (typeof value.eventName !== 'string')
-        throw new CollectValidationError('event name is required');
-    normalizeEventName(value.eventName);
-    for (const field of ['url', 'referrer', 'title', 'path']) {
-        if (value[field] !== undefined && typeof value[field] !== 'string')
-            throw new CollectValidationError(`${field} must be a string`);
-    }
-    if (value.properties !== undefined && (!value.properties || typeof value.properties !== 'object' || Array.isArray(value.properties))) {
-        throw new CollectValidationError('properties must be an object');
-    }
-    if (value.properties !== undefined)
-        sanitizeProperties(value.properties, 'properties', 0);
-    if (value.occurredAt !== undefined && (typeof value.occurredAt !== 'string' || Number.isNaN(Date.parse(value.occurredAt)))) {
-        throw new CollectValidationError('occurredAt must be an RFC3339 timestamp');
-    }
-    if (value.utm !== undefined && (!value.utm || typeof value.utm !== 'object' || Array.isArray(value.utm))) {
-        throw new CollectValidationError('utm must be an object');
-    }
-    normalizeViewport(value.viewport);
-    normalizeExperiment(value.experiment);
-}
-function normalizeEvent(event, now) {
-    const [eventName, eventCategory] = normalizeEventName(String(event.eventName));
-    const rawURL = typeof event.url === 'string' ? event.url.trim() : '';
-    const pageURL = sanitizeURL(rawURL, 'url');
-    const referrer = sanitizeURL(typeof event.referrer === 'string' ? event.referrer.trim() : '', 'referrer');
-    const parsedURL = rawURL ? new URL(rawURL, 'https://aci.invalid') : null;
-    let path = typeof event.path === 'string' ? event.path.trim() : parsedURL?.pathname || '';
-    if (path && !path.startsWith('/'))
-        path = `/${path}`;
-    const utm = normalizeUTM(event.utm, parsedURL);
-    const occurredAt = typeof event.occurredAt === 'string' && !Number.isNaN(Date.parse(event.occurredAt))
-        ? new Date(event.occurredAt).toISOString()
-        : now.toISOString();
-    return {
-        eventId: String(event.eventId).trim().toUpperCase(),
-        eventName,
-        eventCategory,
-        occurredAt,
-        properties: event.properties === undefined ? undefined : sanitizeProperties(event.properties, 'properties', 0),
-        page: {
-            ...(pageURL ? { url: pageURL } : {}),
-            ...(referrer ? { referrer } : {}),
-            ...(typeof event.title === 'string' && event.title.trim() ? { title: event.title.trim() } : {}),
-            ...(path ? { path } : {}),
-        },
-        utm,
-        viewport: normalizeViewport(event.viewport),
-        experiment: normalizeExperiment(event.experiment),
-    };
-}
-function normalizeEventName(value) {
-    const name = value.trim().toLowerCase();
-    if (!name || name.length > 128 || /[\s/\\]/.test(name))
-        throw new CollectValidationError('event name must be dot-delimited');
-    const rum = new Set(['rum.page_view', 'rum.link_click', 'rum.variation_view', 'rum.web_vital']);
-    const experiment = new Set(['experiment.exposure', 'experiment.conversion', 'experiment.engagement']);
-    if (rum.has(name))
-        return [name, 'rum'];
-    if (experiment.has(name))
-        return [name, 'experiment'];
-    if (name.startsWith('custom.') && name.length > 'custom.'.length)
-        return [name, 'custom'];
-    throw new CollectValidationError('event name must be one of the supported rum.* or experiment.* events, or use the custom.* namespace');
-}
-function sanitizeURL(value, field) {
-    if (!value)
-        return '';
-    if (value.length > 2048)
-        throw new CollectValidationError(`${field} is too long`);
-    let parsed;
-    try {
-        parsed = new URL(value, 'https://aci.invalid');
-    }
-    catch {
-        throw new CollectValidationError(`${field} is invalid`);
-    }
-    if (!['http:', 'https:'].includes(parsed.protocol))
-        throw new CollectValidationError(`${field} scheme is not allowed`);
-    parsed.search = '';
-    parsed.hash = '';
-    if (parsed.origin === 'https://aci.invalid')
-        return parsed.pathname;
-    return parsed.toString().replace(/\/$/, parsed.pathname === '/' ? '/' : '');
-}
-function normalizeUTM(value, url) {
-    const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-    const out = {};
-    for (const key of UTM_KEYS) {
-        const raw = source[key] ?? source[`utm_${key}`] ?? url?.searchParams.get(`utm_${key}`);
-        if (typeof raw === 'string' && raw.trim())
-            out[key] = raw.trim();
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-function sanitizeProperties(value, field, depth) {
-    if (depth > 4)
-        throw new CollectValidationError(`${field} is nested too deeply`);
-    if (value === null || typeof value === 'boolean' || typeof value === 'number')
-        return value;
-    if (typeof value === 'string')
-        return sanitizeString(value, field, 2048);
-    if (Array.isArray(value)) {
-        if (value.length > 32)
-            throw new CollectValidationError(`${field} has too many values`);
-        return value.map((item, index) => sanitizeProperties(item, `${field}[${index}]`, depth + 1));
-    }
-    if (typeof value !== 'object')
-        throw new CollectValidationError(`${field} has unsupported value type`);
-    const entries = Object.entries(value);
-    if (entries.length > 64)
-        throw new CollectValidationError(`${field} has too many keys`);
-    const sanitized = {};
-    for (const [rawKey, item] of entries) {
-        const key = sanitizeString(rawKey, `${field} key`, 256);
-        if (!key)
-            throw new CollectValidationError(`${field} contains an empty key`);
-        if (secretLikeKey(key))
-            throw new CollectValidationError(`${field} contains a sensitive key`);
-        sanitized[key] = sanitizeProperties(item, `${field}.${key}`, depth + 1);
-    }
-    return sanitized;
-}
-function secretLikeKey(key) {
-    const normalized = key.toLowerCase().replace(/[-. ]/g, '_');
-    const compact = normalized.replace(/_/g, '');
-    const normalizedMarkers = [
-        'authorization', 'access_token', 'refresh_token', 'id_token', 'api_key',
-        'private_key', 'secret', 'password', 'passwd', 'credential', 'cookie', 'set_cookie',
-    ];
-    const compactMarkers = [
-        'authorization', 'accesstoken', 'refreshtoken', 'idtoken', 'apikey',
-        'privatekey', 'secret', 'password', 'passwd', 'credential', 'cookie', 'setcookie',
-    ];
-    return normalizedMarkers.some((marker) => normalized.includes(marker))
-        || compactMarkers.some((marker) => compact.includes(marker));
-}
-function sanitizeString(value, field, limit) {
-    const clean = value.trim();
-    if (clean.length > limit)
-        throw new CollectValidationError(`${field} is too long`);
-    if (/[\u0000-\u001F\u007F-\u009F]/u.test(clean))
-        throw new CollectValidationError(`${field} contains control characters`);
-    return clean;
-}
-function normalizeViewport(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== 'object' || Array.isArray(value))
-        throw new CollectValidationError('viewport is invalid');
-    const viewport = value;
-    const width = viewport.width ?? 0;
-    const height = viewport.height ?? 0;
-    if (!Number.isInteger(width) || !Number.isInteger(height) || Number(width) < 0 || Number(height) < 0 || Number(width) > 20_000 || Number(height) > 20_000) {
-        throw new CollectValidationError('viewport is invalid');
-    }
-    if (width === 0 && height === 0)
-        return undefined;
-    return { width: Number(width), height: Number(height) };
-}
-function normalizeExperiment(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== 'object' || Array.isArray(value))
-        throw new CollectValidationError('experiment is invalid');
-    const source = value;
-    const experimentId = shortOptionalString(source.experimentId, 'experiment.experimentId');
-    const armId = shortOptionalString(source.armId, 'experiment.armId');
-    const allocationVersion = shortOptionalString(source.allocationVersion, 'experiment.allocationVersion');
-    const goalId = shortOptionalString(source.goalId, 'experiment.goalId');
-    const bucket = source.assignmentBucket;
-    if (!experimentId && !armId && !allocationVersion && !goalId && bucket === undefined)
-        return undefined;
-    if (!experimentId)
-        throw new CollectValidationError('experiment.experimentId is required when experiment context is present');
-    if (!armId)
-        throw new CollectValidationError('experiment.armId is required when experiment context is present');
-    if (bucket !== undefined && (!Number.isInteger(bucket) || Number(bucket) < 0 || Number(bucket) > 9999)) {
-        throw new CollectValidationError('experiment.assignmentBucket must be between 0 and 9999');
-    }
-    return {
-        experimentId,
-        armId,
-        ...(allocationVersion ? { allocationVersion } : {}),
-        ...(goalId ? { goalId } : {}),
-        ...(bucket !== undefined ? { assignmentBucket: bucket } : {}),
-    };
-}
-function shortOptionalString(value, field) {
-    if (value === undefined || value === null)
-        return '';
-    if (typeof value !== 'string')
-        throw new CollectValidationError(`${field} must be a string`);
-    return sanitizeString(value, field, 128);
-}
-function accepted(headers) {
-    return new Response('{"accepted":true}', { status: 202, headers });
-}
-function validationResponse(error) {
-    const message = error instanceof CollectValidationError ? error.message : 'invalid JSON body';
-    return Response.json({ error: message, status: 400 }, { status: 400, headers: { 'cache-control': 'no-store' } });
-}
-function claimsCookie(value, secure) {
-    return `aci_claims=${value}; Path=/; HttpOnly; SameSite=Lax; Max-Age=86400${secure ? '; Secure' : ''}`;
-}
-function expiredClaimsCookie(secure) {
-    return `aci_claims=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT${secure ? '; Secure' : ''}`;
-}
-function appendCookie(headers, cookie) {
-    headers.append('set-cookie', cookie);
-}
-class CollectValidationError extends Error {
-}

package/dist/next/edge-config.d.ts

@@ -1 +0,0 @@
-export declare function getUncachedEdgeConfigValue(edgeConfig: string, key: string): Promise<unknown>;

package/dist/next/edge-config.js

@@ -1,92 +0,0 @@
-export async function getUncachedEdgeConfigValue(edgeConfig, key) {
-    const connection = parseEdgeConfigConnection(edgeConfig);
-    if (!connection) {
-        throw new Error('Invalid Edge Config connection string');
-    }
-    const headers = new Headers({
-        authorization: `Bearer ${connection.token}`,
-        'x-edge-config-min-updated-at': `${Number.MAX_SAFE_INTEGER}`,
-    });
-    if (process.env.VERCEL_ENV) {
-        headers.set('x-edge-config-vercel-env', process.env.VERCEL_ENV);
-    }
-    const url = `${connection.baseUrl}/item/${encodeURIComponent(key)}?version=${encodeURIComponent(connection.version)}`;
-    const response = await fetch(url, {
-        headers,
-        cache: 'no-store',
-    });
-    if (response.ok) {
-        return response.json();
-    }
-    if (response.status === 404 && response.headers.has('x-edge-config-digest')) {
-        return undefined;
-    }
-    const body = await response.text().catch(() => '');
-    throw new Error(`Edge Config read ${key} returned ${response.status}: ${body.slice(0, 500)}`);
-}
-function parseEdgeConfigConnection(value) {
-    const text = value.trim();
-    if (!text)
-        return null;
-    return parseEdgeConfigQueryConnection(text)
-        || parseVercelEdgeConfigURL(text)
-        || parseExternalEdgeConfigURL(text);
-}
-function parseEdgeConfigQueryConnection(value) {
-    if (!value.startsWith('edge-config:'))
-        return null;
-    const params = new URLSearchParams(value.slice('edge-config:'.length));
-    const id = params.get('id') || '';
-    const token = params.get('token') || '';
-    if (!id || !token)
-        return null;
-    return {
-        baseUrl: `https://edge-config.vercel.com/${id}`,
-        token,
-        version: params.get('version') || '1',
-    };
-}
-function parseVercelEdgeConfigURL(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        return null;
-    }
-    if (url.protocol !== 'https:' || url.host !== 'edge-config.vercel.com')
-        return null;
-    const id = url.pathname.split('/').filter(Boolean)[0] || '';
-    const token = url.searchParams.get('token') || '';
-    if (!id || !id.startsWith('ecfg') || !token)
-        return null;
-    return {
-        baseUrl: `https://edge-config.vercel.com/${id}`,
-        token,
-        version: url.searchParams.get('version') || '1',
-    };
-}
-function parseExternalEdgeConfigURL(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        return null;
-    }
-    let id = url.searchParams.get('id') || '';
-    const token = url.searchParams.get('token') || '';
-    const version = url.searchParams.get('version') || '1';
-    if (!id || url.pathname.startsWith('/ecfg_')) {
-        id = url.pathname.split('/').filter(Boolean)[0] || '';
-    }
-    if (!id || !token)
-        return null;
-    url.search = '';
-    const base = url.toString().replace(/\/+$/, '');
-    return {
-        baseUrl: base,
-        token,
-        version,
-    };
-}

package/dist/next/envelope-digest.d.ts

@@ -1,21 +0,0 @@
-export interface EnvelopeDigestInput {
-    siteId: string;
-    acceptedBody: Uint8Array;
-    identity: {
-        namespace: string;
-        hash: string;
-    };
-    consent: {
-        version: number;
-        purposes: readonly string[];
-        grantedAt?: string;
-        source?: string;
-    };
-}
-/**
- * Computes the cross-runtime digest used to distinguish an identical
- * envelope retry from reuse of the same envelope ID with different accepted
- * inputs. Every field is framed with an unsigned 8-byte big-endian length so
- * concatenation cannot create ambiguous inputs.
- */
-export declare function computeEnvelopeDigest(input: EnvelopeDigestInput): Promise<string>;

package/dist/next/envelope-digest.js

@@ -1,58 +0,0 @@
-const ENVELOPE_DIGEST_ALGORITHM = 'aci-envelope-digest-v1';
-const RFC3339 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})$/;
-const encoder = new TextEncoder();
-const CONSENT_EDGE_WHITESPACE = /^[\t\n\v\f\r ]+|[\t\n\v\f\r ]+$/g;
-/**
- * Computes the cross-runtime digest used to distinguish an identical
- * envelope retry from reuse of the same envelope ID with different accepted
- * inputs. Every field is framed with an unsigned 8-byte big-endian length so
- * concatenation cannot create ambiguous inputs.
- */
-export async function computeEnvelopeDigest(input) {
-    if (!Number.isInteger(input.consent.version)) {
-        throw new Error('consent version must be an integer');
-    }
-    const purposes = input.consent.purposes
-        .map((purpose) => trimConsentWhitespace(purpose).toLowerCase())
-        .sort();
-    const fields = [
-        encoder.encode(ENVELOPE_DIGEST_ALGORITHM),
-        encoder.encode(input.siteId.trim()),
-        input.acceptedBody,
-        encoder.encode(input.identity.namespace.trim()),
-        encoder.encode(input.identity.hash.trim()),
-        encoder.encode(String(input.consent.version)),
-        encoder.encode(String(purposes.length)),
-        ...purposes.map((purpose) => encoder.encode(purpose)),
-        encoder.encode(canonicalGrantedAt(input.consent.grantedAt || '')),
-        encoder.encode(trimConsentWhitespace(input.consent.source || '')),
-    ];
-    const byteLength = fields.reduce((total, field) => total + 8 + field.byteLength, 0);
-    const framed = new Uint8Array(byteLength);
-    const view = new DataView(framed.buffer);
-    let offset = 0;
-    for (const field of fields) {
-        view.setBigUint64(offset, BigInt(field.byteLength), false);
-        offset += 8;
-        framed.set(field, offset);
-        offset += field.byteLength;
-    }
-    const digest = await globalThis.crypto.subtle.digest('SHA-256', framed);
-    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
-}
-function canonicalGrantedAt(value) {
-    const clean = trimConsentWhitespace(value);
-    if (!clean)
-        return '';
-    const match = RFC3339.exec(clean);
-    const epochMillis = Date.parse(clean);
-    if (!match || Number.isNaN(epochMillis)) {
-        throw new Error('consent grantedAt must be an RFC3339 timestamp');
-    }
-    const fraction = (match[7] || '').replace(/0+$/, '');
-    const seconds = new Date(epochMillis).toISOString().slice(0, 19);
-    return `${seconds}${fraction ? `.${fraction}` : ''}Z`;
-}
-function trimConsentWhitespace(value) {
-    return value.replace(CONSENT_EDGE_WHITESPACE, '');
-}

package/dist/next/middleware.d.ts

@@ -1,40 +0,0 @@
-import { NextResponse, type NextRequest } from 'next/server.js';
-import { type PersonalizationHostConfig } from './personalization-host.js';
-export interface GradialMiddlewareConfig {
-    siteId?: string;
-    edgeConfig?: string;
-    previewSignKey?: string;
-    deploymentId?: string;
-    deploymentProtectionBypass?: string;
-    /** Site-scoped token shared only with the outer ACI framework proxy. */
-    frameworkOriginAuthToken?: string;
-    personalization?: Omit<PersonalizationHostConfig, 'siteId'> & {
-        siteId?: string;
-    };
-}
-export declare function createGradialMiddleware(config?: GradialMiddlewareConfig): (request: NextRequest) => Promise<Response>;
-/**
- * Any response that writes a cookie is per-visitor and must never enter a
- * shared cache (anonymous-experiments REQ-3(a)): a CDN-cached Set-Cookie
- * replays one visitor's identity/claims to everyone under that cache key.
- * Per-variant CACHING itself stays legitimate — the variant travels in the
- * cache-keyed query parameter, not in cookies.
- */
-export declare function enforceCookieCacheRule(response: NextResponse): void;
-export declare const aciMiddlewareMatcher: (string | {
-    source: string;
-    has: {
-        type: string;
-        key: string;
-    }[];
-})[];
-export declare const config: {
-    runtime: string;
-    matcher: (string | {
-        source: string;
-        has: {
-            type: string;
-            key: string;
-        }[];
-    })[];
-};