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

package/dist/next/collect-route.js

@@ -1,459 +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',
-    'deviceClass',
-]);
-const DEVICE_CLASSES = new Set(['desktop', 'mobile', 'tablet', 'unknown']);
-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 geo = collectGeo(request);
-            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 } : {}),
-                    // Server-stamped geo (country + region only, D-PDP-14) from the
-                    // platform-injected viewer headers; never from the event body.
-                    ...(geo ? { geo } : {}),
-                    deviceClass: normalized.deviceClass,
-                    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');
-    }
-    if (value.deviceClass !== undefined && typeof value.deviceClass !== 'string') {
-        throw new CollectValidationError('deviceClass must be a string');
-    }
-    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,
-        deviceClass: normalizeDeviceClass(event.deviceClass),
-        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),
-    };
-}
-// collectGeo stamps the request geo from the platform-injected viewer
-// headers (Vercel overwrites x-vercel-ip-* on every request, so they are
-// trusted). Country + region only — city is never captured (D-PDP-14).
-// Returns undefined when neither dimension normalizes, so the lake record
-// keeps its historical byte shape for no-source requests.
-function collectGeo(request) {
-    const country = normalizeGeoCountry(request.headers.get('x-vercel-ip-country'));
-    const region = normalizeGeoRegion(request.headers.get('x-vercel-ip-country-region'));
-    if (!country && !region)
-        return undefined;
-    return { ...(country ? { country } : {}), ...(region ? { region } : {}) };
-}
-function normalizeGeoCountry(value) {
-    const clean = (value ?? '').trim();
-    return /^[a-zA-Z]{2}$/.test(clean) ? clean.toUpperCase() : '';
-}
-function normalizeGeoRegion(value) {
-    const clean = (value ?? '').trim();
-    return /^[a-zA-Z0-9]{1,3}$/.test(clean) ? clean.toUpperCase() : '';
-}
-// normalizeDeviceClass floors any client value onto the closed enum —
-// never a free-form echo (the value joins a rollup primary key, D-PR-22).
-function normalizeDeviceClass(value) {
-    const clean = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    return DEVICE_CLASSES.has(clean) ? clean : 'unknown';
-}
-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/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;
-        }[];
-    })[];
-};