eval-quality 0.1.0

package/dist/core/coverage/table.js

@@ -0,0 +1,222 @@
+import { evaluateCoverage } from './coverage.js';
+import { evaluateRelevance } from './relevance.js';
+import { DISCIPLINE_RULES, relevancePredicateId, satisfactionPredicateId, } from './rules.js';
+import { evaluateSatisfaction } from './satisfaction.js';
+/** AD-31's three declaration states, a populated one splitting in two. Column order. */
+export const DECLARATION_STATES = [
+    'absent',
+    'explicitly-empty',
+    'witnessed',
+    'unwitnessed',
+];
+/** The pair each state asserts. `absent` and `unwitnessed` share one; the reason separates them. */
+export const STATE_VERDICTS = {
+    absent: { relevant: true, satisfied: false },
+    'explicitly-empty': { relevant: false, satisfied: true },
+    witnessed: { relevant: true, satisfied: true },
+    unwitnessed: { relevant: true, satisfied: false },
+};
+/** `|` escaped: a reason is free text (fixture 229), and a broken table is still byte-stable, so the drift check would pass it. */
+const cell = (text) => text.replace(/\|/g, '\\|');
+const row = (cells) => `| ${cells.map(cell).join(' | ')} |`;
+const table = (headers, rows) => [
+    row(headers),
+    `| ${headers.map(() => '---').join(' | ')} |`,
+    ...rows.map(row),
+];
+const code = (text) => `\`${text}\``;
+const yesNo = (value) => (value ? 'yes' : 'no');
+/** `explicitly-empty` reads `Explicitly empty`, so a new state arrives with its header. */
+const heading = (state) => {
+    const words = state.replace(/-/g, ' ');
+    return `${words.slice(0, 1).toUpperCase()}${words.slice(1)}`;
+};
+const verdictsOf = (contract) => {
+    const relevance = evaluateRelevance(contract);
+    const satisfaction = evaluateSatisfaction(contract);
+    const paired = new Map();
+    for (const [index, rule] of DISCIPLINE_RULES.entries()) {
+        const relevant = relevance[index];
+        const satisfied = satisfaction[index];
+        if (relevant === undefined || satisfied === undefined)
+            continue;
+        paired.set(rule, {
+            relevant: relevant.relevant,
+            satisfied: satisfied.satisfied,
+            relevanceReason: relevant.reason,
+            satisfactionReason: satisfied.reason,
+        });
+    }
+    return paired;
+};
+const HEADER = [
+    '# AD-31 coverage predicates',
+    '',
+    'Generated by `npm run generate:ad31-table`. Do not edit: `npm run check:ad31-table` compares this',
+    'file byte for byte against the builder and fails on any difference.',
+    '',
+    "AD-20's seven discipline rules, each with a relevance predicate and a satisfaction predicate, run",
+    'over the hand-authored contract corpus AD-31 names as their publication target. The historical',
+    'worked example is not a publication target and appears nowhere below.',
+];
+const COVERAGE_NOTE = [
+    'Each cell names the corpus contract that occupies it. Relevance `false` with satisfaction `false`',
+    'occupies no cell and cannot: a rule that is relevant for no site is satisfied vacuously, so a',
+    'relevance predicate answering `false` forces its satisfaction twin to answer `true`.',
+];
+/** The whole document. Throws a worded diagnosis on an unoccupied cell, which would otherwise publish as coverage. */
+export function coveragePredicateTable(contracts, cells) {
+    // First, because every check after it resolves a `contractId` to a
+    // contract, and that resolution is ambiguous while two share one.
+    const byId = new Map();
+    for (const contract of contracts) {
+        if (byId.has(contract.contractId)) {
+            throw new Error(`coveragePredicateTable: two corpus contracts share the identifier ${contract.contractId}`);
+        }
+        byId.set(contract.contractId, contract);
+    }
+    const occupants = new Map();
+    for (const entry of cells) {
+        if (!byId.has(entry.contractId)) {
+            throw new Error(`coveragePredicateTable: cell ${entry.rule}/${entry.state} names contract ${entry.contractId}, which the corpus does not carry`);
+        }
+        const key = `${entry.rule}/${entry.state}`;
+        const named = occupants.get(key);
+        if (named === undefined)
+            occupants.set(key, [entry.contractId]);
+        else
+            named.push(entry.contractId);
+    }
+    const verdicts = new Map();
+    for (const contract of contracts) {
+        verdicts.set(contract.contractId, verdictsOf(contract));
+    }
+    const occupantOf = (rule, state) => {
+        const named = occupants.get(`${rule}/${state}`) ?? [];
+        if (named.length === 0) {
+            throw new Error(`coveragePredicateTable: no corpus contract occupies cell ${rule}/${state}`);
+        }
+        if (named.length > 1) {
+            throw new Error(`coveragePredicateTable: the corpus occupies cell ${rule}/${state} more than once (${named.join(', ')})`);
+        }
+        return named[0];
+    };
+    const coverageRows = DISCIPLINE_RULES.map((rule) => [
+        code(rule),
+        ...DECLARATION_STATES.map((state) => code(occupantOf(rule, state))),
+    ]);
+    // Both lookups are total: the check above put every cell's contract in
+    // `byId`, and `verdictsOf` keys by `DISCIPLINE_RULES`.
+    for (const entry of cells) {
+        const asserted = STATE_VERDICTS[entry.state];
+        const measured = verdicts.get(entry.contractId).get(entry.rule);
+        if (measured.relevant !== asserted.relevant ||
+            measured.satisfied !== asserted.satisfied) {
+            throw new Error(`coveragePredicateTable: ${entry.contractId} places ${entry.rule} at relevant=${measured.relevant}/satisfied=${measured.satisfied}, but cell ${entry.state} asserts relevant=${asserted.relevant}/satisfied=${asserted.satisfied}`);
+        }
+    }
+    // `absent` and `unwitnessed` share a verdict pair, so the check above passes
+    // with the two occupants swapped and the coverage table publishes each
+    // under the other's heading. The reason is what separates them.
+    for (const rule of DISCIPLINE_RULES) {
+        const absent = occupantOf(rule, 'absent');
+        const unwitnessed = occupantOf(rule, 'unwitnessed');
+        const absentReason = verdicts.get(absent).get(rule).satisfactionReason;
+        const unwitnessedReason = verdicts
+            .get(unwitnessed)
+            .get(rule).satisfactionReason;
+        if (absentReason === unwitnessedReason) {
+            throw new Error(`coveragePredicateTable: ${absent} and ${unwitnessed} both decide ${rule} on "${absentReason}", so the absent and unwitnessed cells are indistinguishable`);
+        }
+    }
+    // A contract occupying nothing still renders seven matrix rows, which reads
+    // as corpus coverage the cell index never claimed.
+    const occupying = new Set(cells.map((entry) => entry.contractId));
+    for (const contract of contracts) {
+        if (!occupying.has(contract.contractId)) {
+            throw new Error(`coveragePredicateTable: ${contract.contractId} occupies no cell, so nothing states what it is in the corpus for`);
+        }
+    }
+    const predicateRows = DISCIPLINE_RULES.map((rule) => [
+        code(rule),
+        code(relevancePredicateId(rule)),
+        code(satisfactionPredicateId(rule)),
+    ]);
+    const gapRows = [];
+    const matrixRows = [];
+    for (const contract of contracts) {
+        const paired = verdicts.get(contract.contractId);
+        // Joined on the rule: `CoverageGap` carries no diagnosis string, so the
+        // reasons come from the verdicts and the identifiers from the record.
+        // Spelling the identifiers as literals renders a document 231 fails.
+        const recorded = new Map(evaluateCoverage(contract).map((record) => [record.rule, record]));
+        for (const rule of DISCIPLINE_RULES) {
+            const measured = paired.get(rule);
+            const record = recorded.get(rule);
+            if (record !== undefined) {
+                gapRows.push([
+                    code(contract.contractId),
+                    code(rule),
+                    code(record.relevancePredicate),
+                    code(record.satisfactionPredicate),
+                    record.severity,
+                    measured.relevanceReason,
+                    measured.satisfactionReason,
+                ]);
+            }
+            matrixRows.push([
+                code(contract.contractId),
+                code(rule),
+                yesNo(measured.relevant),
+                yesNo(measured.satisfied),
+                // `measured.relevant &&` is unfalsifiable for the reason
+                // `coverage.ts` gives at `evaluateCoverage`: fixture 168.
+                yesNo(measured.relevant && !measured.satisfied),
+                measured.relevanceReason,
+                measured.satisfactionReason,
+            ]);
+        }
+    }
+    const lines = [
+        ...HEADER,
+        '',
+        '## The fourteen predicates',
+        '',
+        ...table(['Rule', 'Relevance predicate', 'Satisfaction predicate'], predicateRows),
+        '',
+        '## Declaration-state coverage',
+        '',
+        ...table(['Rule', ...DECLARATION_STATES.map(heading)], coverageRows),
+        '',
+        ...COVERAGE_NOTE,
+        '',
+        '## Coverage gaps',
+        '',
+        'One `CoverageGap` record per corpus contract per rule where relevance fired and satisfaction failed.',
+        '',
+        ...table([
+            'Contract',
+            'Rule',
+            'Relevance predicate',
+            'Satisfaction predicate',
+            'Severity',
+            'Why relevance fired',
+            'Why satisfaction failed',
+        ], gapRows),
+        '',
+        '## The full matrix',
+        '',
+        'Every corpus contract against every rule.',
+        '',
+        ...table([
+            'Contract',
+            'Rule',
+            'Relevant',
+            'Satisfied',
+            'Gap',
+            'Relevance reason',
+            'Satisfaction reason',
+        ], matrixRows),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/core/declared-inputs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What an operation declares it accepts, as predicates over `RequestShape`.
+ *
+ * At the `core/` root because `core/schemas/` holds Zod definitions only, and
+ * because AD-10's exemption is read by two modules: the compile check that
+ * enforces it and the reducer that records it.
+ */
+import type { Operation } from './schemas/interface.ts';
+/**
+ * AD-10's exemption predicate. Any of a channel's three lists naming a key
+ * counts: a permitted-only or types-only channel is still a surface a witness
+ * can vary.
+ */
+export declare function declaresNoRequestKeys(operation: Operation): boolean;
+/** Whether no channel declares a required key. */
+export declare function declaresNoRequiredKeys(operation: Operation): boolean;

package/dist/core/declared-inputs.js

@@ -0,0 +1,18 @@
+import { TRANSPORT_CHANNELS } from './schemas/pointer.js';
+/**
+ * AD-10's exemption predicate. Any of a channel's three lists naming a key
+ * counts: a permitted-only or types-only channel is still a surface a witness
+ * can vary.
+ */
+export function declaresNoRequestKeys(operation) {
+    return TRANSPORT_CHANNELS.every((channel) => {
+        const shape = operation.requestShape[channel];
+        return (shape.requiredKeys.length === 0 &&
+            shape.permittedKeys.length === 0 &&
+            Object.keys(shape.types).length === 0);
+    });
+}
+/** Whether no channel declares a required key. */
+export function declaresNoRequiredKeys(operation) {
+    return TRANSPORT_CHANNELS.every((channel) => operation.requestShape[channel].requiredKeys.length === 0);
+}

package/dist/core/evaluate/evidence-resolution.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `makeResolveOperand` and `makePointerDenotesCollection` satisfy the
+ * `ResolveOperand`/`PointerDenotesCollection` contract that `resolution.ts`
+ * depends on. They parse every pointer form AD-26 declares, including the
+ * bound-element `@/` form, and walk it into an already-selected
+ * `Observation`.
+ */
+import type { EvalContract } from '../schemas/eval-contract.ts';
+import type { JsonValue } from '../schemas/primitives.ts';
+import type { Observation } from '../schemas/sealed-run-record.ts';
+import { type PlanIndex } from '../seal/plan-index.ts';
+import type { PointerDenotesCollection, ResolveOperand } from './resolution.ts';
+import { type ResolvedValue } from './resolved-value.ts';
+/**
+ * A canonical RFC 6901 array-index token: no leading zero except "0" itself,
+ * no sign, digits only. Excludes "-" (RFC 6901's "nonexistent member after
+ * the last element"): this grammar only reads, so "-" resolves ABSENT like
+ * any other unmatched token. Exported so `reachability.ts` checks against
+ * the same grammar this resolver walks.
+ */
+export declare const ARRAY_INDEX_PATTERN: RegExp;
+/**
+ * Walks `tail` (already `~0`/`~1`-decoded tokens) into `root`. `Object.hasOwn`
+ * guards every object step, so an own property named `__proto__` or
+ * `constructor` still resolves correctly. Without that guard, the lookup
+ * falls through to `Object.prototype`. Any miss, type mismatch, or tail
+ * running past a scalar collapses to `ABSENT` uniformly (AD-26).
+ */
+export declare function walkTail(root: JsonValue, tail: readonly string[]): ResolvedValue;
+/**
+ * Decodes `BoundElementPointer`'s tail. "@/" is the shortest legal pointer
+ * form and denotes the element itself. `decodeTail` special-cases only a
+ * fully empty string, so this function handles the "/" case itself before
+ * calling it.
+ */
+export declare function decodeBoundElementTail(pointer: string): readonly string[];
+/**
+ * The `ResolveOperand`. `stepObservations` holds one already-selected
+ * `Observation` per interaction step; `referenceSets` mirrors the contract's
+ * declared reference sets by identifier. Both maps are looked up with
+ * `Object.hasOwn`: `Identifier`'s charset admits `constructor`, the same
+ * prototype-chain gotcha `walkTail` guards against.
+ */
+export declare function makeResolveOperand(stepObservations: Readonly<Record<string, Observation>>, referenceSets: Readonly<Record<string, JsonValue[]>>): ResolveOperand;
+/**
+ * Only `response-body` can ever answer `true` (AD-19: `collectionLocations`
+ * is the only declared-collection surface, scoped to the body alone). The
+ * `PlanIndex` builds lazily on first call unless the caller supplies one,
+ * since a schema-admitted duplicate step or operation id would make building
+ * it eagerly throw before this function ever runs. Uses `stepOf`/`operationOf`
+ * rather than `resolveStep`/`resolveOperation`: those throw on a miss, which
+ * would break this function's always-returns-a-boolean contract.
+ */
+export declare function makePointerDenotesCollection(contract: EvalContract, providedIndex?: PlanIndex): PointerDenotesCollection;

package/dist/core/evaluate/evidence-resolution.js

@@ -0,0 +1,153 @@
+/**
+ * `makeResolveOperand` and `makePointerDenotesCollection` satisfy the
+ * `ResolveOperand`/`PointerDenotesCollection` contract that `resolution.ts`
+ * depends on. They parse every pointer form AD-26 declares, including the
+ * bound-element `@/` form, and walk it into an already-selected
+ * `Observation`.
+ */
+import { buildPlanIndex, decodeTail, parseEvidenceTarget, } from '../seal/plan-index.js';
+import { ABSENT } from './resolved-value.js';
+/**
+ * A canonical RFC 6901 array-index token: no leading zero except "0" itself,
+ * no sign, digits only. Excludes "-" (RFC 6901's "nonexistent member after
+ * the last element"): this grammar only reads, so "-" resolves ABSENT like
+ * any other unmatched token. Exported so `reachability.ts` checks against
+ * the same grammar this resolver walks.
+ */
+export const ARRAY_INDEX_PATTERN = /^(?:0|[1-9][0-9]*)$/;
+/**
+ * Walks `tail` (already `~0`/`~1`-decoded tokens) into `root`. `Object.hasOwn`
+ * guards every object step, so an own property named `__proto__` or
+ * `constructor` still resolves correctly. Without that guard, the lookup
+ * falls through to `Object.prototype`. Any miss, type mismatch, or tail
+ * running past a scalar collapses to `ABSENT` uniformly (AD-26).
+ */
+export function walkTail(root, tail) {
+    let current = root;
+    for (const token of tail) {
+        if (current === null || typeof current !== 'object')
+            return ABSENT;
+        if (Array.isArray(current)) {
+            if (!ARRAY_INDEX_PATTERN.test(token))
+                return ABSENT;
+            const index = Number(token);
+            if (!Object.hasOwn(current, index))
+                return ABSENT;
+            current = current[index];
+            continue;
+        }
+        if (!Object.hasOwn(current, token))
+            return ABSENT;
+        current = current[token];
+    }
+    return current;
+}
+/**
+ * Decodes `BoundElementPointer`'s tail. "@/" is the shortest legal pointer
+ * form and denotes the element itself. `decodeTail` special-cases only a
+ * fully empty string, so this function handles the "/" case itself before
+ * calling it.
+ */
+export function decodeBoundElementTail(pointer) {
+    const tailSource = pointer.slice(1);
+    return tailSource === '/' ? [] : decodeTail(tailSource);
+}
+/**
+ * Selects the channel `target` names off one `Observation`. `stdout`/`stderr`
+ * can carry a tail even though they're bare strings; `walkTail` already
+ * resolves any non-empty tail against a string to `ABSENT`, so no special
+ * case is needed here.
+ */
+function channelRoot(observation, target) {
+    switch (target.channel) {
+        case 'response-body':
+            return observation.responseBody;
+        case 'response-headers':
+            return observation.responseHeaders;
+        case 'response-status':
+            return observation.responseStatus;
+        case 'stdout':
+            return observation.stdout;
+        case 'stderr':
+            return observation.stderr;
+        case 'exit-code':
+            return observation.exitCode;
+        case 'call-inputs': {
+            const { transportChannel } = target;
+            if (transportChannel === null) {
+                // parseEvidenceTarget sets transportChannel exactly when the
+                // channel is 'call-inputs', so this throw should never fire.
+                throw new TypeError('call-inputs evidence target carries no transport channel');
+            }
+            return observation.callInputs[transportChannel];
+        }
+    }
+}
+/**
+ * The `ResolveOperand`. `stepObservations` holds one already-selected
+ * `Observation` per interaction step; `referenceSets` mirrors the contract's
+ * declared reference sets by identifier. Both maps are looked up with
+ * `Object.hasOwn`: `Identifier`'s charset admits `constructor`, the same
+ * prototype-chain gotcha `walkTail` guards against.
+ */
+export function makeResolveOperand(stepObservations, referenceSets) {
+    return (operand, boundElement, _artifactPath) => {
+        if ('literal' in operand)
+            return operand.literal;
+        if ('referenceSet' in operand) {
+            if (!Object.hasOwn(referenceSets, operand.referenceSet))
+                return ABSENT;
+            return referenceSets[operand.referenceSet];
+        }
+        const { pointer } = operand;
+        if (pointer.startsWith('@')) {
+            // ABSENT means "no active binding." A correctly-compiled contract
+            // never hits this branch, but resolveOperand returns ABSENT here
+            // so it never has to throw.
+            if (boundElement === ABSENT)
+                return ABSENT;
+            return walkTail(boundElement, decodeBoundElementTail(pointer));
+        }
+        const target = parseEvidenceTarget(pointer);
+        if (!Object.hasOwn(stepObservations, target.stepId))
+            return ABSENT;
+        const observation = stepObservations[target.stepId];
+        return walkTail(channelRoot(observation, target), target.tail);
+    };
+}
+function tokensEqual(a, b) {
+    return a.length === b.length && a.every((token, index) => token === b[index]);
+}
+/**
+ * Only `response-body` can ever answer `true` (AD-19: `collectionLocations`
+ * is the only declared-collection surface, scoped to the body alone). The
+ * `PlanIndex` builds lazily on first call unless the caller supplies one,
+ * since a schema-admitted duplicate step or operation id would make building
+ * it eagerly throw before this function ever runs. Uses `stepOf`/`operationOf`
+ * rather than `resolveStep`/`resolveOperation`: those throw on a miss, which
+ * would break this function's always-returns-a-boolean contract.
+ */
+export function makePointerDenotesCollection(contract, providedIndex) {
+    let index = providedIndex;
+    const getIndex = () => {
+        index ??= buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces);
+        return index;
+    };
+    return (pointer) => {
+        if (pointer.startsWith('@'))
+            return false;
+        const target = parseEvidenceTarget(pointer);
+        if (target.channel !== 'response-body')
+            return false;
+        const step = getIndex().stepOf(target.stepId);
+        if (step === undefined)
+            return false;
+        const operation = getIndex().operationOf(step.operationId);
+        if (operation === undefined)
+            return false;
+        const { collectionLocations } = operation.responseDescriptor;
+        if (collectionLocations === null)
+            return false;
+        return collectionLocations.some((location) => tokensEqual(decodeTail(location.pointer), target.tail));
+    };
+}

package/dist/core/evaluate/operators.d.ts

@@ -0,0 +1,87 @@
+import type { JsonValue, KeyedShapeDescriptor } from '../schemas/primitives.ts';
+import { ABSENT, type ResolvedValue } from './resolved-value.ts';
+/** Reads only whether resolution happened; `null` counts as present (AD-26). */
+export declare function existence(value: ResolvedValue, _artifactPath: string): boolean;
+/** AD-26's exact complement of `existence`. */
+export declare function absence(value: ResolvedValue, _artifactPath: string): boolean;
+/**
+ * Cost-ordered: the `ABSENT` guard runs before any digest call, since
+ * `ABSENT` is a JS `symbol` and `digestArtifact` faults on symbols. Only a
+ * matching compound type reaches structural comparison, so a scalar operand
+ * never inherits the digest path's fault surface.
+ */
+export declare function equality(a: ResolvedValue, b: ResolvedValue, artifactPath: string): boolean;
+/**
+ * Unconditionally structural (AD-27): the whole point of deep comparison.
+ * `ABSENT` is guarded first, same reason as `equality`'s. A canonicalization
+ * fault propagates undecorated: an unevaluable operand, not a false match.
+ */
+export declare function deepEquality(a: ResolvedValue, b: ResolvedValue, artifactPath: string): boolean;
+/**
+ * `false` on `ABSENT` is correct only when `value`'s pointer is not itself
+ * collection-typed; the resolver in `resolution.ts` disambiguates the two
+ * cases before calling in here.
+ */
+export declare function setMembership(value: ResolvedValue, set: JsonValue[], artifactPath: string): boolean;
+/**
+ * `candidate: ResolvedValue | JsonValue[]` because `Containment`'s operand
+ * can resolve to either a single value or a `referenceSet`'s member array.
+ *
+ * An array-shaped `candidate` is always read as a subset check, never as a
+ * single element to search for: this function receives resolved values only,
+ * so it cannot tell a `{ literal }` array from a resolved `{ referenceSet }`.
+ * Known, accepted limitation.
+ */
+export declare function containment(container: ResolvedValue, candidate: ResolvedValue | JsonValue[], artifactPath: string): boolean;
+/**
+ * `false` if `value === ABSENT` or not a string. Pattern validity is checked
+ * here; the match-step budget is a two-tier static gate, structural
+ * nested-quantifier rejection then a linear estimate. The gate stays static
+ * because AD-1 keeps this function synchronous and pure, and native `RegExp`
+ * exposes no step counter to read.
+ */
+export declare function regexMatch(value: ResolvedValue, pattern: string, matchStepBudget: number, artifactPath: string): boolean;
+/**
+ * Comparison is non-strict: ties are allowed. String comparison is plain
+ * `<=`/`>=` (UTF-16 code-unit order), matching AD-27's key-sorting basis.
+ */
+export declare function ordering(collection: ResolvedValue, key: string, order: 'ascending' | 'descending', _artifactPath: string): boolean;
+/**
+ * An empty array is a legitimate zero count, never special-cased; the
+ * resolver in `resolution.ts` intercepts before this runs on a genuinely
+ * empty collection. The allowed deviation is compared unrounded: `actual` is
+ * an integer, so `<=` against a fractional deviation is already exact, and
+ * rounding either direction would move the declared boundary.
+ */
+export declare function countTolerance(collection: ResolvedValue, expected: number, tolerance: number, relative: boolean, _artifactPath: string): boolean;
+/**
+ * The closed set is `permittedKeys` alone, never unioned with `requiredKeys`:
+ * a self-contradictory descriptor is unsatisfiable rather than repaired.
+ * `requiredKeys ⊆ permittedKeys` is unrefined in
+ * `core/schemas/primitives.ts` and closed by no compile-time check, so a key
+ * that is required and not permitted reaches here and fails every value.
+ */
+export declare function shape(value: ResolvedValue, descriptor: KeyedShapeDescriptor, _artifactPath: string): boolean;
+/**
+ * AD-4's bijection: equal cardinality and a distinct `actual` match per
+ * `expected` element on the named keys. `ABSENT` on either side resolves
+ * `false`, including a fully-missing `actual` collection: AD-4 calls that "a
+ * detected defect, not an empty examination," overriding the general
+ * empty-collection invariant for this operator alone. A non-array `actual` is
+ * an operand type this operator does not accept, which AD-4 assigns to
+ * `malformed-operator-expression`; `core/compile/expression-legality.ts`
+ * checks the operand *form* under that code and leaves this position's
+ * declared type unchecked, so a non-array reaching here resolves `false`.
+ *
+ * Cardinality is never checked separately: `actualByKey` starts with one
+ * entry per `actual` element (a synthetic slot for a keyless one, so nothing
+ * goes uncounted), and the `expected` loop deletes one entry per match. A
+ * final `actualByKey.size === 0` is the bijection condition itself, since the
+ * map's starting size already equals `actual`'s cardinality. A duplicate
+ * `actualKey` fails immediately, at construction, because the second element
+ * finds its slot already occupied; a duplicate `expectedKey` is assumed
+ * prevented at compile time under `malformed-operator-expression`, but if it
+ * occurs it fails later, at lookup, because the second occurrence finds its
+ * slot already deleted by the first.
+ */
+export declare function coversByKey(expected: JsonValue[] | typeof ABSENT, actual: ResolvedValue, expectedKey: string, actualKey: string, artifactPath: string): boolean;