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

package/dist/internal/domain/edge/personalization-core.js

@@ -1,89 +1,182 @@
 // Runtime-neutral personalization selection. The backend owns this logic
-// and pushes compiled artifacts to each host (CloudFront Function, Vercel
+// and pushes compiled artifacts to each host (Lambda@Edge, Vercel
 // middleware, Cloudflare Worker). Keep this file free of platform APIs.
 //
 // This is the pure decision algorithm — no I/O, no cookies, no identity
 // minting. The caller resolves identity and claims, then calls this.
 import { variantValuesFromKey } from './record/codec.js';
-export function resolvePersonalizationDecision(request, route, claims, experiments, identity) {
+import { canonicalVariantKey } from './variant_key.js';
+import { personalizationSelection } from './personalization_index.js';
+export { preparePersonalizationRoute } from './personalization_index.js';
+export class PersonalizationResolutionError extends Error {
+    variantKey;
+    code = 'personalization.tuple_missing';
+    constructor(variantKey) {
+        super(`materialized personalization tuple ${variantKey} is absent from the route projection`);
+        this.variantKey = variantKey;
+        this.name = 'PersonalizationResolutionError';
+    }
+}
+export function resolvePersonalizationDecision(request, route, claims, experiments, identity, forcedArms) {
     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] : undefined;
-            if (!candidate)
+        return { variant: null, experiments: [] };
+    const selection = personalizationSelection(route, experiments);
+    const legacyExperimentExclusions = selection.legacyExperimentExclusions;
+    const authored = selectRuleVariant(request, selection, claims);
+    const values = { ...(authored ? authored.variantValues || variantValuesFromKey(authored.variantKey) : {}) };
+    // The leg selectRuleVariant chose is the selected-mode predicate's only
+    // input (ADR 0050, edge-functions I-16): "" when no leg won — an organic
+    // visit admits no selected-mode experiment.
+    const selectedLegAudienceId = String(values.audience || '');
+    const assignments = [];
+    const rejected = [];
+    const attempted = { ...values };
+    // Experiment-arm forcing (audience-mimic design/09, edge-functions I-17):
+    // an arms-bearing mimic token runs the experiment tier with the token's
+    // assertion replacing the dice for each experiment the request selects
+    // through the ordinary gate. Selection, eligibility, and arm-rule
+    // evaluation are the ordinary path — only allocation is replaced. No
+    // identity exists under mimic, so experiments the token does not name are
+    // skipped, and unselected experiments' forces are inert.
+    const forcing = !!forcedArms && Object.keys(forcedArms).length > 0;
+    if ((identity?.usable || forcing) && experiments) {
+        // The immutable route projection is the authority for scope. Missing
+        // qualified entries are corruption, never evidence to omit an experiment.
+        for (const item of selection.experiments) {
+            const id = item.id;
+            if (!experimentEligible(item, claims, selectedLegAudienceId))
                 continue;
-            if (assignment && !candidate.variantKey)
-                candidate.variantKey = assignment.variantKey;
-            // A bucket assignment is candidacy, not entitlement: an arm variant
-            // carrying a rule must pass the same serve-time evaluation the rule
-            // leg applies (ADR 0040). A rejection fires the onRuleRejected sink
-            // inside evaluateRule; the candidate is skipped — never served, and
-            // never left behind as a stale experiment decision.
-            if (candidate.rule && !evaluateRule(request, candidate.rule, claims, candidate.variantKey))
+            const assignment = forcing
+                ? forceExperimentArm(item, forcedArms)
+                : assignExperiment(item, identity);
+            if (!assignment)
                 continue;
-            if (!variant || betterVariant(candidate.priority || 0, candidate.variantKey, variant.priority || 0, variant.variantKey)) {
-                variant = candidate;
-                experiment = assignment;
+            attempted[`experiment.${id}`] = assignment.armId;
+            if (item.eligibilityMode !== 'selected') {
+                const candidate = selection.arms[id]?.[assignment.armId];
+                // Under forcing an absent single-factor entry is publish/mint skew,
+                // not corruption (D-12 forbids the error page on the live origin):
+                // the factor degrades to absent and the plain mimic view renders.
+                if (!candidate) {
+                    if (!forcing)
+                        throw new PersonalizationResolutionError(assignment.variantKey);
+                    continue;
+                }
+                const factorEvents = [];
+                const factorRequest = { ...request, onRuleRejected: (event) => factorEvents.push(event) };
+                if (candidate.rule && !evaluateRule(factorRequest, candidate.rule, claims, assignment.variantKey)) {
+                    if (!factorEvents.length)
+                        factorEvents.push({ variantKey: assignment.variantKey, diagnosticCode: 'expression.not_matched', diagnosticPath: 'expression', diagnosticCount: 1 });
+                    for (const event of factorEvents)
+                        rejected.push({ ...event, experimentId: id, armId: assignment.armId });
+                    continue;
+                }
+            }
+            // A selected-mode experiment carries no arm rules (experiment I-18) and
+            // its arms materialize only composed with the selected leg, so there is
+            // no single-factor arm entry to look up; the composed-tuple resolution
+            // below stays the fail-closed corruption guard.
+            assignments.push(assignment);
+            values[`experiment.${id}`] = assignment.armId;
+        }
+    }
+    const attemptedKey = canonicalVariantKey(attempted);
+    for (const event of rejected)
+        request.onRuleRejected?.({ ...event, variantKey: attemptedKey });
+    let variant = authored;
+    if (assignments.length) {
+        const key = canonicalVariantKey(values);
+        const selected = selection.tuples[key];
+        // Under forcing a forced tuple absent from the projection (publish/mint
+        // skew) degrades every forced factor to absent — the plain mimic view.
+        // The fail-closed named error applies only to non-mimic traffic (I-17).
+        if (!selected && !forcing)
+            throw new PersonalizationResolutionError(key);
+        if (selected) {
+            variant = { ...selected, variantKey: key };
+        }
+        else {
+            assignments.length = 0;
+            for (const name of Object.keys(values)) {
+                if (name.startsWith('experiment.'))
+                    delete values[name];
             }
-            break;
         }
     }
-    return { variant: variant || null, experiment };
+    return { variant, experiments: assignments, ...(legacyExperimentExclusions ? { legacyExperimentExclusions } : {}) };
 }
-function selectRuleVariant(request, route, claims, experiments) {
-    if (!route.variants)
+// forceExperimentArm resolves the token's named arm for one selected
+// experiment instead of bucketing (design/09). Null when the token does not
+// name this experiment (unforced experiments never run under mimic — no
+// identity exists) or names an arm the active projection does not carry
+// (skew degrades to the plain mimic view, never an error).
+function forceExperimentArm(experiment, forcedArms) {
+    const armId = forcedArms[experiment.id];
+    if (armId === undefined)
         return null;
-    const matches = [];
-    for (const key in route.variants) {
-        const variant = route.variants[key];
-        if (!variant.variantKey)
-            variant.variantKey = 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)))
+    const arm = (experiment.arms || []).find((candidate) => candidate.id === armId);
+    if (!arm)
+        return null;
+    return {
+        experimentId: experiment.id,
+        armId,
+        allocationVersion: String(experiment.allocationVersion || ''),
+        variantKey: `experiment.${experiment.id}=${armId}`,
+        // The dice never rolled; -1 marks the forced origin in the decision
+        // record where a bucket would otherwise sit.
+        bucket: -1,
+        forced: true,
+    };
+}
+function selectRuleVariant(request, selection, claims) {
+    let best = null;
+    for (const candidate of selection.authored) {
+        const { variant, values, key } = candidate;
+        if (candidate.experiments.some((item) => !experimentEligible(item, claims, String(values.audience || ''))))
             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, claims, variant.variantKey) : false;
-        if (membershipMatch || ruleMatch)
-            matches.push(variant);
+        const ruleMatch = variant.rule ? evaluateRule(request, variant.rule, claims, key) : false;
+        if (!best && (membershipMatch || ruleMatch))
+            best = { ...variant, variantKey: key, variantValues: values };
     }
-    matches.sort((left, right) => (right.priority || 0) - (left.priority || 0)
-        || String(left.variantKey || '').localeCompare(String(right.variantKey || '')));
-    return matches[0] || null;
+    return best;
 }
 // The eligibility gate (audience-scoped-experiments ASE-F4/F5): an
 // experiment declaring eligibilityAudienceId is skipped entirely — before
 // bucketing or arm candidacy — unless the verified claims carry the ID.
 // Ungated experiments return true, preserving byte-identical behavior.
-function experimentEligible(item, claims) {
+//
+// ADR 0050 (edge-functions I-16): an experiment whose projection carries
+// eligibilityMode "selected" is gated by the selected-leg predicate INSTEAD
+// of the claims gate — it is a factor only when the leg the request selected
+// carries audience=<eligibilityAudienceId>. Claims are never consulted for
+// it: a rule-backed audience cannot enter claims, so the claims gate would
+// hold the experiment dormant, and the selected leg is the fact the
+// planner's sum built this route's tuples for. Out of selection there is no
+// bucket, assignment, exposure, or rule-rejection record.
+function experimentEligible(item, claims, selectedLegAudienceId) {
+    if (item.eligibilityMode === 'selected')
+        return selectedModeFactorOf(item, selectedLegAudienceId);
     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;
+// selectedModeFactorOf is the decision core's spelling of the planner's
+// leg-membership predicate (ADR 0050) — one name, one rule, two runtimes:
+// experiment.SelectedModeFactorOf in Go, applied by Assign and by the
+// contentbuild planner's leg factors, candidates, and Lookup. A
+// selected-mode experiment with an unresolved eligibility audience is a
+// factor of no leg, base included. Both inputs are canonical by variant-key
+// construction (the record codec and the strict document decode pre-trim
+// them), so this comparison needs no normalization — the Go twin's TrimSpace
+// is defensive only and never changes the outcome.
+function selectedModeFactorOf(item, legAudienceId) {
+    const audienceID = String(item.eligibilityAudienceId || '').trim();
+    return audienceID !== '' && audienceID === legAudienceId;
 }
 function assignExperiment(experiment, identity) {
     const version = String(experiment.allocationVersion || '').trim();
@@ -106,25 +199,20 @@ function assignExperiment(experiment, identity) {
                 experimentId: experiment.id,
                 armId: arm.id,
                 allocationVersion: version,
-                variantKey: arm.variantKey,
+                variantKey: `experiment.${experiment.id}=${arm.id}`,
                 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))
+        if (!key || !want || ['audience', 'segment'].includes(normalized) || normalized.startsWith('experiment.'))
             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') {
@@ -783,137 +871,6 @@ function utf8(value) {
     }
     return new Uint8Array(out);
 }
-// ── Normalized two-phase model: classify → decide ─────────────────────
-//
-// Phase 1 (classify): evaluate all audience/segment rules page-agnostically
-// and assign experiment arms. Returns a Classification that is used by
-// Phase 2 for cheap set-membership lookups per route.
-//
-// Phase 2 (decide): for a given route record, check which variants match
-// the classification (set membership + priority). Audience/segment rules
-// were evaluated in Phase 1; an experiment arm variant's own rule is
-// evaluated here at commit time, because a bucket assignment is candidacy,
-// not entitlement (ADR 0040).
-//
-// The per-route record stays small: just variant keys (e.g.
-// "audience=trade") + priorities. Rules live in the classification data,
-// evaluated once per request.
-//
-/**
- * Phase 1: Classify the visitor against all release-level rules.
- *
- * @param ctx     The request context (cookies, headers, geo, query)
- * @param data    Release-level classification data (audiences, segments, experiments)
- * @param identity Visitor identity (for experiment bucketing). Pass undefined
- *                 if no identity or privacy denied.
- * @param claims  The verified claims the caller already holds (eligibility
- *                gate input, ASE-F4). Undefined/null means "no claims" —
- *                gated experiments are skipped.
- * @returns Classification — matched audiences, segments, and experiment arm assignments
- */
-export function classify(ctx, data, identity, claims) {
-    // Evaluate audience rules. Claims feed the audience.memberships fact
-    // (ADR 0039) exactly as they do in the request-scoped resolver path.
-    const matchedAudiences = [];
-    for (const key in data.audiences) {
-        const def = data.audiences[key];
-        if (def.rule && evaluateRule(ctx, def.rule, claims, key)) {
-            matchedAudiences.push(key);
-        }
-    }
-    // Evaluate segment rules
-    const matchedSegments = [];
-    for (const key in data.segments) {
-        const def = data.segments[key];
-        if (def.rule && evaluateRule(ctx, def.rule, claims, key)) {
-            matchedSegments.push(key);
-        }
-    }
-    // Assign experiment arms (only for identified visitors)
-    const experimentArms = {};
-    if (identity && identity.usable) {
-        for (const expId in data.experiments) {
-            const exp = data.experiments[expId];
-            if (exp.status !== 'running')
-                continue;
-            if (exp.kind !== 'ab' && exp.kind !== 'abn')
-                continue;
-            if (!experimentEligible(exp, claims))
-                continue;
-            const assignment = assignExperiment(exp, identity);
-            if (assignment) {
-                experimentArms[expId] = assignment;
-            }
-        }
-    }
-    return { matchedAudiences, matchedSegments, experimentArms };
-}
-/**
- * Phase 2: Decide the winning variant for a specific route.
- *
- * Uses the classification from Phase 1 for cheap set-membership lookups.
- * Audience/segment rules were already evaluated in Phase 1; the one rule
- * evaluated here is an experiment arm variant's own rule, because the arm
- * assignment is candidacy, not entitlement (ADR 0040).
- *
- * @param record        The route entry (path, dispatch, variants)
- * @param classification The visitor's classification from Phase 1
- * @param ctx           The request context (signal facts + rejection sink)
- * @param claims        The verified claims the caller already holds — the
- *                      same object passed to classify() — so an arm variant's
- *                      audience.memberships rule resolves identically to the
- *                      resolver path and fails closed without it (ADR 0039).
- * @returns The decision — winning variant + experiment assignment, or nulls
- */
-export function decide(record, classification, ctx, claims) {
-    if (!record.variants)
-        return { variant: null, experiment: null };
-    let bestVariant = null;
-    let bestExperiment = null;
-    for (const key in record.variants) {
-        const variant = record.variants[key];
-        if (!variant.variantKey)
-            variant.variantKey = key;
-        const values = variant.variantValues || variantValuesFromKey(key);
-        // Check if this variant references a paused experiment — skip if so
-        const experimentID = String(values.experiment || '').trim();
-        if (experimentID && !classification.experimentArms[experimentID])
-            continue;
-        let matched = false;
-        // Audience membership
-        if (values.audience && classification.matchedAudiences.includes(values.audience)) {
-            matched = true;
-        }
-        // Segment membership
-        if (!matched && values.segment && classification.matchedSegments.includes(values.segment)) {
-            matched = true;
-        }
-        // Experiment arm assignment. The arm is a candidate only — committing it
-        // inside the win block prevents a losing arm variant from leaving a
-        // stale experiment decision behind when another variant wins.
-        let armMatch = null;
-        if (!matched && experimentID) {
-            const arm = classification.experimentArms[experimentID];
-            if (arm && arm.variantKey === variant.variantKey) {
-                // Same ADR 0040 posture as the resolver's experiment leg: the arm
-                // assignment is candidacy only. A rule rejected at serve time (or
-                // unmatched) fires the onRuleRejected sink inside evaluateRule and
-                // skips the variant — never served, no stale experiment decision.
-                if (!variant.rule || evaluateRule(ctx, variant.rule, claims, variant.variantKey)) {
-                    matched = true;
-                    armMatch = arm;
-                }
-            }
-        }
-        if (matched) {
-            if (!bestVariant || betterVariant(variant.priority || 0, variant.variantKey, bestVariant.priority || 0, bestVariant.variantKey)) {
-                bestVariant = variant;
-                bestExperiment = armMatch;
-            }
-        }
-    }
-    return { variant: bestVariant, experiment: bestExperiment };
-}
 // ── Derived request device class (ADR 0037) ──────────────────────────
 //
 // device.class is the one request fact that is neither transcribed from the
@@ -993,7 +950,6 @@ function deviceHeader(headers, key) {
 // 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);

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

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

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

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

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

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