eval-quality 0.1.0 → 0.2.0

package/dist/core/compile/bindings.js

@@ -0,0 +1,317 @@
+/**
+ * Owed item 3's compile-time checks over captured input bindings:
+ * `binding-cycle` over the ordering graph, `captured-channel-undeclared` on a
+ * pointer naming any channel but `response-body`, and the typed residue that
+ * fires the shipped `unreachable-check-evidence`.
+ *
+ * The three run at two registry positions. `checkCapturedReachability` fires
+ * `unreachable-check-evidence`, whose rung is third, so it runs beside
+ * `checkEvidenceReachability`; the two new codes run at their own inserted
+ * position. Running captured reachability late would let a lower-ranked code
+ * win on a contract carrying both defects, which `compile.ts`'s own documented
+ * priority forbids.
+ *
+ * `evaluatePointerReachability` decides the step, operation, body-key, and
+ * scalar-descent half. The scalar determination, the one-segment tail rule, and
+ * type equality are this module's own.
+ */
+import { ARRAY_INDEX_PATTERN } from '../evaluate/evidence-resolution.js';
+import { StructuralFailure } from '../failure-codes.js';
+import { TRANSPORT_CHANNELS, } from '../schemas/pointer.js';
+import { JsonTypeName } from '../schemas/primitives.js';
+import { buildPlanIndex, parseEvidenceTarget, resolveOperation, resolveStep, } from '../seal/plan-index.js';
+import { evaluatePointerReachability } from './reachability.js';
+/**
+ * The one channel a captured pointer may name. `ResponseDescriptor` declares
+ * `requiredKeys`, `permittedKeys`, `types`, `successIndicator`, `channelRoles`,
+ * and `collectionLocations`, every one of them about the body, so the body is
+ * the one channel it declares and the criterion's "a channel the referenced
+ * operation's response descriptor does not declare" is literally true of the
+ * other six. Admitting `response-headers` and `response-status` was tried and
+ * dropped: their types would have to be invented by fiat, and
+ * `Observation.responseHeaders` admits objects, arrays, numbers, and `null`, so
+ * a header capture compiled as a `string` could resolve to an object at score
+ * time.
+ */
+const CAPTURABLE_CHANNEL = 'response-body';
+/**
+ * Every captured binding one step declares, in fixed transport-channel order
+ * then by key name, so which binding a check reports never depends on a
+ * caller-keyed map's insertion order. Exported because `score/binding-order.ts`
+ * and `score/bindings.ts` need the same reading of which bindings are captures.
+ */
+export function capturedBindings(step) {
+    const captures = [];
+    for (const transportChannel of TRANSPORT_CHANNELS) {
+        const map = step.inputBinding[transportChannel];
+        if (map === null)
+            continue;
+        for (const key of Object.keys(map).sort()) {
+            const value = map[key];
+            if (value === undefined || !('captured' in value))
+                continue;
+            captures.push({
+                transportChannel,
+                key,
+                pointer: value.captured,
+                target: parseEvidenceTarget(value.captured),
+            });
+        }
+    }
+    return captures;
+}
+// The one shipped precedent for addressing a caller-keyed binding entry
+// (`interface-inventory.ts`'s undeclared-key throw), reused so the two new
+// codes and the widened `undeclared-mandatory-input` agree on one spelling.
+function bindingPath(step, capture) {
+    return `EvalContract.interactionPlan[stepId=${step.stepId}].inputBinding.${capture.transportChannel}[${JSON.stringify(capture.key)}]`;
+}
+// ---- binding-cycle -------------------------------------------------------
+/**
+ * `binding-cycle`: a cycle over the union of the capture edges and AD-39's
+ * `after` edges that contains at least one capture edge.
+ *
+ * Both edge kinds assert that this step's observation comes after that one, so
+ * a capture B to A together with `A.after = B` is an unsatisfiable ordering
+ * while each graph alone stays acyclic. A cycle made only of `after` edges is
+ * left to `checkNestedTemporalClause`, which already catches every one of them,
+ * so requiring a capture edge in the cycle keeps the two codes disjoint.
+ *
+ * Decided by strongly connected components rather than by a depth-first walk
+ * that inspects each back edge. A cycle lies entirely inside one component, and
+ * a capture edge whose endpoints share a component is closed by a path back
+ * through that component, so "some cycle contains a capture edge" is exactly
+ * "some capture edge has both endpoints in one component". A self-capture is
+ * the singleton case and needs no rule of its own. The depth-first form was
+ * written first and rejected: settling a node after rejecting a pure-`after`
+ * back edge can hide a mixed cycle a later root would reach, and whether it
+ * does depends on the order edges happen to be enumerated in, which is an
+ * invariant nothing states.
+ *
+ * Nodes are the plan's declared step ids; an edge whose target no step declares
+ * is dropped, since a dangling reference is not a cycle and AD-39 makes a
+ * dangling `after` permissive besides. The binding reported is the first, in
+ * the plan's own declaration order, whose endpoints share a component.
+ */
+export function checkBindingCycle(contract) {
+    const declaredStepIds = new Set(contract.interactionPlan.map((step) => step.stepId));
+    const edgesFrom = new Map();
+    const addEdge = (from, to) => {
+        const list = edgesFrom.get(from);
+        if (list === undefined)
+            edgesFrom.set(from, [to]);
+        else
+            list.push(to);
+    };
+    for (const step of contract.interactionPlan) {
+        for (const capture of capturedBindings(step)) {
+            if (declaredStepIds.has(capture.target.stepId)) {
+                addEdge(step.stepId, capture.target.stepId);
+            }
+        }
+        if (step.after !== null && declaredStepIds.has(step.after)) {
+            addEdge(step.stepId, step.after);
+        }
+    }
+    const component = stronglyConnectedComponents(declaredStepIds, edgesFrom);
+    for (const step of contract.interactionPlan) {
+        for (const capture of capturedBindings(step)) {
+            const target = capture.target.stepId;
+            if (!declaredStepIds.has(target))
+                continue;
+            if (component.get(step.stepId) !== component.get(target))
+                continue;
+            throw new StructuralFailure('binding-cycle', bindingPath(step, capture), `captured pointer "${capture.pointer}" closes a cycle over the capture and temporal-clause edges; a captured value has no earlier step to resolve from (AD-39)`);
+        }
+    }
+}
+/** Tarjan's algorithm, returning each node's component identifier. */
+function stronglyConnectedComponents(nodes, edgesFrom) {
+    const order = new Map();
+    const lowLink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const component = new Map();
+    let nextOrder = 0;
+    let nextComponent = 0;
+    const connect = (node) => {
+        order.set(node, nextOrder);
+        lowLink.set(node, nextOrder);
+        nextOrder += 1;
+        stack.push(node);
+        onStack.add(node);
+        for (const next of edgesFrom.get(node) ?? []) {
+            if (!order.has(next)) {
+                connect(next);
+                lowLink.set(node, Math.min(lowLink.get(node) ?? 0, lowLink.get(next) ?? 0));
+            }
+            else if (onStack.has(next)) {
+                lowLink.set(node, Math.min(lowLink.get(node) ?? 0, order.get(next) ?? 0));
+            }
+        }
+        if (lowLink.get(node) !== order.get(node))
+            return;
+        const id = nextComponent;
+        nextComponent += 1;
+        for (;;) {
+            const member = stack.pop();
+            if (member === undefined)
+                break;
+            onStack.delete(member);
+            component.set(member, id);
+            if (member === node)
+                break;
+        }
+    };
+    for (const node of nodes) {
+        if (!order.has(node))
+            connect(node);
+    }
+    return component;
+}
+// ---- captured-channel-undeclared -----------------------------------------
+/**
+ * `captured-channel-undeclared`: a captured pointer naming any AD-26 channel
+ * but `response-body`. `call-inputs` addresses a step's own request,
+ * `stdout`, `stderr`, and `exit-code` are process channels no operation
+ * surviving `unsupported-interface-kind` produces, and `response-headers` and
+ * `response-status` have no declared structure to give a captured value a
+ * type.
+ */
+export function checkCapturedChannel(contract) {
+    for (const step of contract.interactionPlan) {
+        for (const capture of capturedBindings(step)) {
+            if (capture.target.channel === CAPTURABLE_CHANNEL)
+                continue;
+            throw new StructuralFailure('captured-channel-undeclared', bindingPath(step, capture), `captured pointer "${capture.pointer}" names the ${capture.target.channel} channel, which the referenced operation's response descriptor does not declare (AD-26)`);
+        }
+    }
+}
+// ---- the typed residue: unreachable-check-evidence -----------------------
+const SCALAR_TYPES = new Set(JsonTypeName.options.filter((name) => name !== 'object' && name !== 'array'));
+/**
+ * The type a captured pointer resolves to, or why nothing scalar is declared
+ * there. The tail must be exactly one segment: `ResponseDescriptor.types` is
+ * keyed by plain key name, so a nested segment has no declared type to compare
+ * against, and an array element has none either even where
+ * `evaluatePointerReachability` admits the index against a root collection.
+ */
+function capturedType(target, index) {
+    const segments = target.tail.length;
+    if (segments !== 1) {
+        return {
+            reason: `addresses ${segments === 0 ? 'the whole response body' : `a response-body path ${segments} segments deep`}, which declares no scalar to capture`,
+        };
+    }
+    const key = target.tail[0];
+    if (key === undefined) {
+        // Unreachable: the length check above guarantees one segment.
+        throw new TypeError('captured pointer tail is one segment but is empty');
+    }
+    if (ARRAY_INDEX_PATTERN.test(key)) {
+        return {
+            reason: `addresses response-body element ${key}, which no declaration gives a type`,
+        };
+    }
+    const step = resolveStep(index, target.stepId);
+    const operation = resolveOperation(index, step.operationId);
+    const declared = operation.responseDescriptor.types[key];
+    if (declared === undefined || declared === null) {
+        return {
+            reason: `addresses response-body field "${key}", whose type operation "${operation.operationId}" ${declared === undefined ? 'does not declare' : 'declares indeterminate'}`,
+        };
+    }
+    if (!SCALAR_TYPES.has(declared)) {
+        return {
+            reason: `addresses response-body field "${key}", which operation "${operation.operationId}" declares "${declared}" rather than a scalar`,
+        };
+    }
+    return { type: declared };
+}
+/**
+ * The type the bound parameter itself is declared as. An indeterminate
+ * declaration on either side is not equal to anything and fails closed, which
+ * is AD-31's disposition for an indeterminate descriptor. A step whose own
+ * operation does not resolve is skipped, matching
+ * `checkUndeclaredMandatoryInput`: that defect belongs to a separate
+ * cross-field rule.
+ */
+function boundParameterType(step, capture, index) {
+    const operation = index.operationOf(step.operationId);
+    if (operation === undefined)
+        return null;
+    const shape = operation.requestShape[capture.transportChannel];
+    // A key the operation declares in neither list is an input the contract did
+    // not declare, which is `undeclared-mandatory-input`'s and strict-only under
+    // AD-4. This check runs unconditionally, so claiming it here would reject a
+    // non-strict contract under a code that names a different defect, and would
+    // treat a captured binding more harshly than the same key bound to a literal.
+    if (!shape.requiredKeys.includes(capture.key) &&
+        !shape.permittedKeys.includes(capture.key)) {
+        return null;
+    }
+    const declared = shape.types[capture.key];
+    if (declared === undefined || declared === null) {
+        return {
+            reason: `binds ${capture.transportChannel} parameter "${capture.key}", whose type operation "${operation.operationId}" ${declared === undefined ? 'does not declare' : 'declares indeterminate'}, so no type equality is decidable`,
+        };
+    }
+    return { type: declared };
+}
+/**
+ * `unreachable-check-evidence` over the captured-pointer residue: an
+ * unresolvable step or operation, an undeclared body key, a tail that is not
+ * exactly one segment, an array index, an absent, indeterminate, or non-scalar
+ * declared type, and a declared type that does not equal the bound
+ * parameter's.
+ *
+ * A capture naming another channel is reported here only for the two conditions
+ * that are decidable without a response descriptor: an unresolvable step and an
+ * unresolvable operation. Everything else about such a pointer is
+ * `checkCapturedChannel`'s. That split is what lets this check run at the
+ * registry's third rung without shadowing the fifteenth, and it keeps the
+ * higher-ranked code first on a pointer that is unresolvable and off-body at
+ * once.
+ */
+export function checkCapturedReachability(contract) {
+    let index;
+    for (const step of contract.interactionPlan) {
+        for (const capture of capturedBindings(step)) {
+            const path = bindingPath(step, capture);
+            index ??= buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
+            // Resolved before the channel test, so a pointer that is both
+            // unresolvable and on a non-body channel reports the higher-ranked
+            // code. Deferring this to `checkCapturedChannel` would fire index 15
+            // where AD-5's order gives index 2, and would assert something about
+            // a response descriptor that no declared operation supplies. The
+            // wording matches `evaluatePointerReachability`'s own two reasons, so
+            // one defect reads the same however it is reached.
+            const referenced = index.stepOf(capture.target.stepId);
+            if (referenced === undefined) {
+                throw new StructuralFailure('unreachable-check-evidence', path, `captured pointer "${capture.pointer}" names a step the interaction plan does not declare`);
+            }
+            if (index.operationOf(referenced.operationId) === undefined) {
+                throw new StructuralFailure('unreachable-check-evidence', path, `captured pointer "${capture.pointer}" names step "${capture.target.stepId}", which names operation "${referenced.operationId}", not declared by any permitted interface`);
+            }
+            if (capture.target.channel !== CAPTURABLE_CHANNEL)
+                continue;
+            const reachability = evaluatePointerReachability(capture.pointer, index);
+            if (!reachability.reachable) {
+                throw new StructuralFailure('unreachable-check-evidence', path, `captured pointer "${capture.pointer}" ${reachability.reason}`);
+            }
+            const captured = capturedType(capture.target, index);
+            if (captured.type === undefined) {
+                throw new StructuralFailure('unreachable-check-evidence', path, `captured pointer "${capture.pointer}" ${captured.reason}`);
+            }
+            const bound = boundParameterType(step, capture, index);
+            if (bound === null)
+                continue;
+            if (bound.type === undefined) {
+                throw new StructuralFailure('unreachable-check-evidence', path, `captured pointer "${capture.pointer}" resolves to a declared "${captured.type}", but the step ${bound.reason}`);
+            }
+            if (bound.type !== captured.type) {
+                throw new StructuralFailure('unreachable-check-evidence', path, `captured pointer "${capture.pointer}" resolves to a declared "${captured.type}", which is not the "${bound.type}" the bound ${capture.transportChannel} parameter "${capture.key}" is declared as`);
+            }
+        }
+    }
+}

package/dist/core/compile/compile.d.ts

@@ -13,6 +13,11 @@
  * code; the other two witness checks fire different codes and run
  * unconditionally, after the registry order, since AD-5 names no rung for them.
  *
+ * `checkCapturedReachability` fires the shipped `unreachable-check-evidence`,
+ * so it runs at that code's own third rung, beside `checkEvidenceReachability`.
+ * Grouping it with the two codes owed item 3 added, at the inserted position
+ * below, would let a lower-ranked code win on a contract carrying both defects.
+ *
  * `checkRubricIdentifiers` fires `rubric-unanchored` but runs ahead of
  * `checkRubricReasoningProse`, which outranks it in the registry. A duplicated
  * rubric or criterion id makes every `rubrics[id=...]` path the other three

package/dist/core/compile/compile.js

@@ -13,12 +13,18 @@
  * code; the other two witness checks fire different codes and run
  * unconditionally, after the registry order, since AD-5 names no rung for them.
  *
+ * `checkCapturedReachability` fires the shipped `unreachable-check-evidence`,
+ * so it runs at that code's own third rung, beside `checkEvidenceReachability`.
+ * Grouping it with the two codes owed item 3 added, at the inserted position
+ * below, would let a lower-ranked code win on a contract carrying both defects.
+ *
  * `checkRubricIdentifiers` fires `rubric-unanchored` but runs ahead of
  * `checkRubricReasoningProse`, which outranks it in the registry. A duplicated
  * rubric or criterion id makes every `rubrics[id=...]` path the other three
  * rubric checks emit address two things, so identifiers are settled before any
  * of them reports.
  */
+import { checkBindingCycle, checkCapturedChannel, checkCapturedReachability, } from './bindings.js';
 import { checkObservableSuccessCriterion, checkRequirementLinkage, } from './declarations.js';
 import { checkOperandLegality, checkQuantifierNesting, checkQuantifierOverNonCollection, checkReferenceSetResolution, checkRegexConstructs, } from './expression-legality.js';
 import { checkForbiddenInputFloor, checkScopedResourceReferences, } from './forbidden-inputs.js';
@@ -33,6 +39,7 @@ export function compile(contract, options) {
     checkRequirementLinkage(contract);
     checkObservableSuccessCriterion(contract);
     checkEvidenceReachability(contract);
+    checkCapturedReachability(contract);
     checkBoundElementScope(contract);
     checkOperandLegality(contract);
     checkRegexConstructs(contract);
@@ -49,6 +56,8 @@ export function compile(contract, options) {
     checkInterfaceKind(contract);
     checkNestedTemporalClause(contract);
     checkScriptingBound(contract);
+    checkBindingCycle(contract);
+    checkCapturedChannel(contract);
     checkRubricIdentifiers(contract);
     checkRubricReasoningProse(contract);
     checkRubricAnchoring(contract);

package/dist/core/compile/expression-legality.d.ts

@@ -1,10 +1,58 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
+import type { Expression, Operand, SetOperand } from '../schemas/expression.ts';
+import type { Operation } from '../schemas/interface.ts';
+type OperandPosition = 0 | 1 | 'collection';
+type OperandBearingOp = Exclude<Expression['op'], 'not' | 'all' | 'any'>;
+type Visitor = {
+    onOperand?: (operand: Operand, op: OperandBearingOp, position: OperandPosition, path: string, quantifierDepth: number) => void;
+    onSetOperand?: (setOperand: SetOperand, path: string) => void;
+    onQuantifier?: (expr: {
+        op: 'for-all' | 'for-any';
+        collection: Operand;
+        predicate: Expression;
+    }, path: string, quantifierDepth: number) => void;
+    onCoversByKey?: (expr: Extract<Expression, {
+        op: 'covers-by-key';
+    }>, path: string, quantifierDepth: number) => void;
+    onRegex?: (pattern: string, path: string) => void;
+};
+/**
+ * The one expression walker in this package. Contract-free and a superset of
+ * the narrower walks the checks below need, so a probe-side legality pass
+ * reuses it rather than adding a fifth traversal that can drift from it.
+ */
+export declare function walkExpression(expr: Expression, quantifierDepth: number, path: string, visitor: Visitor): void;
+/**
+ * `checkOperandLegality` over one bare `Expression`, minus the `covers-by-key`
+ * `expectedKey` uniqueness rule, which reads the contract's declared reference
+ * sets and has no probe-side form: a probe-side condition may carry no
+ * `{ referenceSet }` operand at all.
+ */
+export declare function checkExpressionOperandLegality(expression: Expression, artifactPath: string): void;
+/** `checkRegexConstructs` over one bare `Expression`. */
+export declare function checkExpressionRegexConstructs(expression: Expression, artifactPath: string): void;
+/** `checkQuantifierNesting` over one bare `Expression`. */
+export declare function checkExpressionQuantifierNesting(expression: Expression, artifactPath: string): void;
 /** Checks each operator's operands against its position-specific constraints. */
 export declare function checkOperandLegality(contract: EvalContract): void;
 /** Rejects invalid regexes, partial anchors, backreferences, and lookbehind. */
 export declare function checkRegexConstructs(contract: EvalContract): void;
 /** Rejects nested quantifiers and covers-by-key inside a quantifier. */
 export declare function checkQuantifierNesting(contract: EvalContract): void;
+/**
+ * `checkQuantifierOverNonCollection` over one bare `Expression` rooted at a
+ * known set of step identifiers, all of which resolve to one operation. The
+ * `legIds` argument is load-bearing: omit it and the check silently no-ops on
+ * every expression, which is the trap the witness branch below already warns
+ * about. It reads the operation's declared response types, never its
+ * `collectionLocations`; a declared non-array type beats a contradictory
+ * collection location, and a re-derivation that read the other field would
+ * disagree with the compiler on a committed fixture.
+ */
+export declare function checkExpressionQuantifierOverNonCollection(expression: Expression, artifactPath: string, scope: {
+    readonly operation: Operation;
+    readonly legIds: readonly string[];
+}): void;
 /** Checks response-body collection pointers, after bound-element substitution. */
 export declare function checkQuantifierOverNonCollection(contract: EvalContract): void;
 /**
@@ -12,3 +60,4 @@ export declare function checkQuantifierOverNonCollection(contract: EvalContract)
  * This preserves legal identifiers such as `constructor`.
  */
 export declare function checkReferenceSetResolution(contract: EvalContract): void;
+export {};

package/dist/core/compile/expression-legality.js

@@ -7,7 +7,12 @@ import { StructuralFailure } from '../failure-codes.js';
 import { JsonTypeName } from '../schemas/primitives.js';
 import { buildPlanIndex, parseEvidenceTarget, } from '../seal/plan-index.js';
 import { substitutePointer } from './oracle-alignment.js';
-function walkExpression(expr, quantifierDepth, path, visitor) {
+/**
+ * The one expression walker in this package. Contract-free and a superset of
+ * the narrower walks the checks below need, so a probe-side legality pass
+ * reuses it rather than adding a fifth traversal that can drift from it.
+ */
+export function walkExpression(expr, quantifierDepth, path, visitor) {
     switch (expr.op) {
         case 'not':
             walkExpression(expr.operands[0], quantifierDepth, `${path}.operands[0]`, visitor);
@@ -116,24 +121,71 @@ const OPERAND_LEGALITY = {
 const artifactKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
     ? `.${key}`
     : `[${JSON.stringify(key)}]`;
+/**
+ * One operand's two position rules: the `OPERAND_LEGALITY` table, and the
+ * `ordering`-over-`call-inputs` rule that sits beside it. Both are decidable
+ * from the operand alone, so both cross over to a bare `Expression`.
+ */
+function checkOperandAtPosition(operand, op, position, artifactPath) {
+    const legal = OPERAND_LEGALITY[op]?.[String(position)];
+    if (legal === undefined)
+        return;
+    const kind = kindOf(operand);
+    if (!legal.has(kind)) {
+        throw new StructuralFailure('malformed-operator-expression', artifactPath, `"${op}" does not accept a ${kind} operand at position ${position} (AD-4, AD-26)`);
+    }
+    if (op === 'ordering' &&
+        'pointer' in operand &&
+        !operand.pointer.startsWith('@') &&
+        parseEvidenceTarget(operand.pointer).channel === 'call-inputs') {
+        throw new StructuralFailure('malformed-operator-expression', artifactPath, '"ordering" accepts observed output only, never call-inputs (AD-4)');
+    }
+}
+/**
+ * `checkOperandLegality` over one bare `Expression`, minus the `covers-by-key`
+ * `expectedKey` uniqueness rule, which reads the contract's declared reference
+ * sets and has no probe-side form: a probe-side condition may carry no
+ * `{ referenceSet }` operand at all.
+ */
+export function checkExpressionOperandLegality(expression, artifactPath) {
+    walkExpression(expression, 0, '', {
+        onOperand: (operand, op, position, path) => {
+            checkOperandAtPosition(operand, op, position, `${artifactPath}${path}`);
+        },
+    });
+}
+/** `checkRegexConstructs` over one bare `Expression`. */
+export function checkExpressionRegexConstructs(expression, artifactPath) {
+    walkExpression(expression, 0, '', {
+        onRegex: (pattern, path) => {
+            const rejection = regexRejection(pattern);
+            if (rejection !== null) {
+                throw new StructuralFailure('malformed-operator-expression', `${artifactPath}${path}.pattern`, `regex pattern "${pattern}" ${rejection}, a rejected construct (AD-4)`);
+            }
+        },
+    });
+}
+/** `checkQuantifierNesting` over one bare `Expression`. */
+export function checkExpressionQuantifierNesting(expression, artifactPath) {
+    walkExpression(expression, 0, '', {
+        onQuantifier: (_expr, path, quantifierDepth) => {
+            if (quantifierDepth >= 1) {
+                throw new StructuralFailure('quantifier-nesting-exceeded', `${artifactPath}${path}`, "a quantifier appears inside another quantifier's predicate; quantifiers may not nest more than one level (AD-4)");
+            }
+        },
+        onCoversByKey: (_expr, path, quantifierDepth) => {
+            if (quantifierDepth >= 1) {
+                throw new StructuralFailure('quantifier-nesting-exceeded', `${artifactPath}${path}`, "covers-by-key appears inside a quantifier's predicate, where it may never nest (AD-4)");
+            }
+        },
+    });
+}
 /** Checks each operator's operands against its position-specific constraints. */
 export function checkOperandLegality(contract) {
     forEachContractExpression(contract, (site) => {
         walkExpression(site.expression, 0, '', {
             onOperand: (operand, op, position, path) => {
-                const legal = OPERAND_LEGALITY[op]?.[String(position)];
-                if (legal === undefined)
-                    return;
-                const kind = kindOf(operand);
-                if (!legal.has(kind)) {
-                    throw new StructuralFailure('malformed-operator-expression', `${site.artifactPath}${path}`, `"${op}" does not accept a ${kind} operand at position ${position} (AD-4, AD-26)`);
-                }
-                if (op === 'ordering' &&
-                    'pointer' in operand &&
-                    !operand.pointer.startsWith('@') &&
-                    parseEvidenceTarget(operand.pointer).channel === 'call-inputs') {
-                    throw new StructuralFailure('malformed-operator-expression', `${site.artifactPath}${path}`, '"ordering" accepts observed output only, never call-inputs (AD-4)');
-                }
+                checkOperandAtPosition(operand, op, position, `${site.artifactPath}${path}`);
             },
             onCoversByKey: (expr) => {
                 const expected = expr.operands[0];
@@ -280,6 +332,44 @@ function forEachQuantifierCollection(expr, boundElementRoot, path, visit) {
             return;
     }
 }
+/**
+ * The check itself, against whatever resolves a step identifier to the
+ * operation that answers it. The contract path resolves through the plan index
+ * or the witness scope; a probe-side condition resolves the one reserved step
+ * identifier to the signature's home operation.
+ */
+function checkQuantifiersAgainst(expression, artifactPath, operationFor) {
+    forEachQuantifierCollection(expression, null, '', (pointer, path) => {
+        const target = parseEvidenceTarget(pointer);
+        if (target.channel !== 'response-body')
+            return;
+        const operation = operationFor(target.stepId);
+        if (operation === undefined)
+            return;
+        const firstToken = target.tail.length === 1 ? target.tail[0] : undefined;
+        const declaredType = firstToken === undefined
+            ? undefined
+            : operation.responseDescriptor.types[firstToken];
+        if (declaredType !== undefined &&
+            declaredType !== null &&
+            NON_COLLECTION_TYPES.has(declaredType)) {
+            throw new StructuralFailure('quantifier-over-non-collection', `${artifactPath}${path}`, `"${pointer}" is declared "${declaredType}" by operation "${operation.operationId}", not a collection (AD-4)`);
+        }
+    });
+}
+/**
+ * `checkQuantifierOverNonCollection` over one bare `Expression` rooted at a
+ * known set of step identifiers, all of which resolve to one operation. The
+ * `legIds` argument is load-bearing: omit it and the check silently no-ops on
+ * every expression, which is the trap the witness branch below already warns
+ * about. It reads the operation's declared response types, never its
+ * `collectionLocations`; a declared non-array type beats a contradictory
+ * collection location, and a re-derivation that read the other field would
+ * disagree with the compiler on a committed fixture.
+ */
+export function checkExpressionQuantifierOverNonCollection(expression, artifactPath, scope) {
+    checkQuantifiersAgainst(expression, artifactPath, (stepId) => scope.legIds.includes(stepId) ? scope.operation : undefined);
+}
 /** Checks response-body collection pointers, after bound-element substitution. */
 export function checkQuantifierOverNonCollection(contract) {
     const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
@@ -298,23 +388,7 @@ export function checkQuantifierOverNonCollection(contract) {
         return index.operationOf(step.operationId);
     };
     forEachContractExpression(contract, (site) => {
-        forEachQuantifierCollection(site.expression, null, '', (pointer, path) => {
-            const target = parseEvidenceTarget(pointer);
-            if (target.channel !== 'response-body')
-                return;
-            const operation = operationFor(site, target.stepId);
-            if (operation === undefined)
-                return;
-            const firstToken = target.tail.length === 1 ? target.tail[0] : undefined;
-            const declaredType = firstToken === undefined
-                ? undefined
-                : operation.responseDescriptor.types[firstToken];
-            if (declaredType !== undefined &&
-                declaredType !== null &&
-                NON_COLLECTION_TYPES.has(declaredType)) {
-                throw new StructuralFailure('quantifier-over-non-collection', `${site.artifactPath}${path}`, `"${pointer}" is declared "${declaredType}" by operation "${operation.operationId}", not a collection (AD-4)`);
-            }
-        });
+        checkQuantifiersAgainst(site.expression, site.artifactPath, (stepId) => operationFor(site, stepId));
     });
 }
 // Reference-set resolution.

package/dist/core/compile/forbidden-inputs.d.ts

@@ -1,5 +1,12 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
 /** `forbidden-input-floor-incomplete`: `forbiddenInputs` omits a floor member. */
 export declare function checkForbiddenInputFloor(contract: EvalContract): void;
-/** `scoped-reference-resolves-forbidden`: any scoped reference is forbidden. */
+/**
+ * `scoped-reference-resolves-forbidden`: any scoped reference is forbidden,
+ * wherever the contract writes it down. `scopedResources` is read first and
+ * `testData.resources` second, each with its own message and artifact path, so
+ * a contract carrying both reports the field AD-16 names by that word. The
+ * second address uses the caller-keyed form `interface-inventory.ts` already
+ * emits, since that list is keyed by name rather than indexed.
+ */
 export declare function checkScopedResourceReferences(contract: EvalContract): void;

package/dist/core/compile/forbidden-inputs.js

@@ -10,10 +10,23 @@ export function checkForbiddenInputFloor(contract) {
         }
     }
 }
-/** `scoped-reference-resolves-forbidden`: any scoped reference is forbidden. */
+/**
+ * `scoped-reference-resolves-forbidden`: any scoped reference is forbidden,
+ * wherever the contract writes it down. `scopedResources` is read first and
+ * `testData.resources` second, each with its own message and artifact path, so
+ * a contract carrying both reports the field AD-16 names by that word. The
+ * second address uses the caller-keyed form `interface-inventory.ts` already
+ * emits, since that list is keyed by name rather than indexed.
+ */
 export function checkScopedResourceReferences(contract) {
     const resource = contract.scopedResources?.[0];
-    if (resource === undefined)
+    if (resource !== undefined) {
+        throw new StructuralFailure('scoped-reference-resolves-forbidden', 'EvalContract.scopedResources[0].reference', `scoped resource reference "${resource.reference}" is forbidden (AD-16)`);
+    }
+    // Sorted, so which of several declared resources is reported never depends
+    // on the authored key order.
+    const declared = Object.keys(contract.testData.resources ?? {}).sort()[0];
+    if (declared === undefined)
         return;
-    throw new StructuralFailure('scoped-reference-resolves-forbidden', 'EvalContract.scopedResources[0].reference', `scoped resource reference "${resource.reference}" is forbidden (AD-16)`);
+    throw new StructuralFailure('scoped-reference-resolves-forbidden', `EvalContract.testData.resources[${JSON.stringify(declared)}]`, `declared test-data resource "${declared}" is a scoped resource reference and is forbidden (AD-16)`);
 }