eval-quality 0.1.0

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

@@ -0,0 +1,346 @@
+/**
+ * Checks expression operands, regex constructs, quantifier use, and
+ * reference-set resolution. Each check reports the first structural failure.
+ */
+import { digestArtifact } from '../canonical/digest.js';
+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) {
+    switch (expr.op) {
+        case 'not':
+            walkExpression(expr.operands[0], quantifierDepth, `${path}.operands[0]`, visitor);
+            return;
+        case 'all':
+        case 'any':
+            expr.operands.forEach((child, index) => {
+                walkExpression(child, quantifierDepth, `${path}.operands[${index}]`, visitor);
+            });
+            return;
+        case 'for-all':
+        case 'for-any':
+            visitor.onOperand?.(expr.collection, expr.op, 'collection', `${path}.collection`, quantifierDepth);
+            visitor.onQuantifier?.(expr, path, quantifierDepth);
+            walkExpression(expr.predicate, quantifierDepth + 1, `${path}.predicate`, visitor);
+            return;
+        case 'set-membership':
+            visitor.onOperand?.(expr.operands[0], expr.op, 0, `${path}.operands[0]`, quantifierDepth);
+            visitor.onSetOperand?.(expr.operands[1], `${path}.operands[1]`);
+            return;
+        case 'covers-by-key':
+            visitor.onCoversByKey?.(expr, path, quantifierDepth);
+            expr.operands.forEach((operand, index) => {
+                visitor.onOperand?.(operand, expr.op, index, `${path}.operands[${index}]`, quantifierDepth);
+            });
+            return;
+        case 'regex':
+            visitor.onRegex?.(expr.pattern, path);
+            expr.operands.forEach((operand, index) => {
+                visitor.onOperand?.(operand, expr.op, index, `${path}.operands[${index}]`, quantifierDepth);
+            });
+            return;
+        default:
+            expr.operands.forEach((operand, index) => {
+                visitor.onOperand?.(operand, expr.op, index, `${path}.operands[${index}]`, quantifierDepth);
+            });
+    }
+}
+/**
+ * Every expression the contract declares, oracle checks first and then each
+ * operation's sensitivity witness. Generalized from an oracle-only enumerator:
+ * a witness relation that escaped these five checks would be a declaration that
+ * looks checked and is not, which is the defect class AD-10 exists to catch.
+ */
+function forEachContractExpression(contract, visit) {
+    contract.oracles.forEach((oracle) => {
+        if (oracle.check === null)
+            return;
+        visit({
+            expression: oracle.check,
+            artifactPath: `EvalContract.oracles[id=${oracle.id}].check`,
+            witnessScope: null,
+        });
+    });
+    contract.permittedInterfaces.forEach((iface, interfaceIndex) => {
+        iface.operations.forEach((operation, operationIndex) => {
+            const witness = operation.sensitivityWitness;
+            if (witness === null)
+                return;
+            visit({
+                expression: witness.relation,
+                artifactPath: `EvalContract.permittedInterfaces[${interfaceIndex}].operations[${operationIndex}].sensitivityWitness.relation`,
+                witnessScope: {
+                    operation,
+                    legIds: witness.legs.map((leg) => leg.legId),
+                },
+            });
+        });
+    });
+}
+function kindOf(operand) {
+    if ('pointer' in operand)
+        return 'pointer';
+    if ('literal' in operand)
+        return 'literal';
+    return 'referenceSet';
+}
+/**
+ * The schema accepts a common operand union, so position constraints live here.
+ * Set membership narrows its second operand in the schema.
+ */
+const OPERAND_LEGALITY = {
+    equality: {
+        0: new Set(['pointer', 'literal']),
+        1: new Set(['pointer', 'literal']),
+    },
+    'deep-equality': {
+        0: new Set(['pointer', 'literal']),
+        1: new Set(['pointer', 'literal']),
+    },
+    containment: {
+        0: new Set(['pointer']),
+        1: new Set(['pointer', 'literal', 'referenceSet']),
+    },
+    existence: { 0: new Set(['pointer']) },
+    absence: { 0: new Set(['pointer']) },
+    regex: { 0: new Set(['pointer']) },
+    'set-membership': { 0: new Set(['pointer']) },
+    ordering: { 0: new Set(['pointer']) },
+    'count-tolerance': { 0: new Set(['pointer']) },
+    shape: { 0: new Set(['pointer']) },
+    'covers-by-key': { 0: new Set(['referenceSet']), 1: new Set(['pointer']) },
+    'for-all': { collection: new Set(['pointer']) },
+    'for-any': { collection: new Set(['pointer']) },
+};
+const artifactKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+    ? `.${key}`
+    : `[${JSON.stringify(key)}]`;
+/** 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)');
+                }
+            },
+            onCoversByKey: (expr) => {
+                const expected = expr.operands[0];
+                if (!('referenceSet' in expected))
+                    return;
+                const declarations = contract.referenceSets;
+                if (declarations === null ||
+                    !Object.hasOwn(declarations, expected.referenceSet))
+                    return;
+                const declaration = declarations[expected.referenceSet];
+                if (declaration === undefined)
+                    return;
+                const seen = new Set();
+                for (const [index, member] of declaration.members.entries()) {
+                    if (!Object.hasOwn(member, expr.expectedKey))
+                        continue;
+                    const memberPath = `EvalContract.referenceSets[id=${expected.referenceSet}].members[${index}]${artifactKey(expr.expectedKey)}`;
+                    const digest = digestArtifact(member[expr.expectedKey], memberPath);
+                    if (seen.has(digest)) {
+                        throw new StructuralFailure('malformed-operator-expression', memberPath, `referenceSet "${expected.referenceSet}" repeats expectedKey "${expr.expectedKey}" for covers-by-key (AD-4)`);
+                    }
+                    seen.add(digest);
+                }
+            },
+        });
+    });
+}
+// Rejected regex constructs.
+const BACKREFERENCE_PATTERN = /\\(?:[1-9][0-9]*|k<[^>]+>)/;
+const LOOKBEHIND_PATTERN = /\(\?<[=!]/;
+function isEscaped(pattern, index) {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && pattern[cursor] === '\\'; cursor--)
+        backslashes++;
+    return backslashes % 2 === 1;
+}
+function hasTopLevelAlternation(pattern) {
+    let depth = 0;
+    let inCharacterClass = false;
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern[index];
+        if (character === undefined || isEscaped(pattern, index))
+            continue;
+        if (character === '[') {
+            inCharacterClass = true;
+            continue;
+        }
+        if (character === ']') {
+            inCharacterClass = false;
+            continue;
+        }
+        if (inCharacterClass)
+            continue;
+        if (character === '(')
+            depth++;
+        else if (character === ')')
+            depth--;
+        else if (character === '|' && depth === 0)
+            return true;
+    }
+    return false;
+}
+function regexRejection(pattern) {
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        return 'is not a syntactically valid ECMA-262 pattern';
+    }
+    if (pattern[0] !== '^' ||
+        pattern.at(-1) !== '$' ||
+        isEscaped(pattern, pattern.length - 1) ||
+        hasTopLevelAlternation(pattern)) {
+        return 'is not anchored over the whole expression';
+    }
+    if (BACKREFERENCE_PATTERN.test(pattern))
+        return 'carries a backreference';
+    if (LOOKBEHIND_PATTERN.test(pattern))
+        return 'carries a lookbehind';
+    return null;
+}
+/** Rejects invalid regexes, partial anchors, backreferences, and lookbehind. */
+export function checkRegexConstructs(contract) {
+    forEachContractExpression(contract, (site) => {
+        walkExpression(site.expression, 0, '', {
+            onRegex: (pattern, path) => {
+                const rejection = regexRejection(pattern);
+                if (rejection !== null) {
+                    throw new StructuralFailure('malformed-operator-expression', `${site.artifactPath}${path}.pattern`, `regex pattern "${pattern}" ${rejection}, a rejected construct (AD-4)`);
+                }
+            },
+        });
+    });
+}
+// Quantifier nesting.
+/** Rejects nested quantifiers and covers-by-key inside a quantifier. */
+export function checkQuantifierNesting(contract) {
+    forEachContractExpression(contract, (site) => {
+        walkExpression(site.expression, 0, '', {
+            onQuantifier: (_expr, path, quantifierDepth) => {
+                if (quantifierDepth >= 1) {
+                    throw new StructuralFailure('quantifier-nesting-exceeded', `${site.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', `${site.artifactPath}${path}`, "covers-by-key appears inside a quantifier's predicate, where it may never nest (AD-4)");
+                }
+            },
+        });
+    });
+}
+// Quantifiers over non-collections.
+const NON_COLLECTION_TYPES = new Set(JsonTypeName.options.filter((name) => name !== 'array'));
+/**
+ * Substitutes a quantifier's `@`-prefixed `collection` pointer against the
+ * bound element its enclosing quantifier already opened, so a nested
+ * quantifier's own collection resolves to an absolute pointer rather than
+ * being skipped. Mirrors `oracle-alignment.ts`'s `collectTargets`.
+ */
+function forEachQuantifierCollection(expr, boundElementRoot, path, visit) {
+    switch (expr.op) {
+        case 'not':
+            forEachQuantifierCollection(expr.operands[0], boundElementRoot, `${path}.operands[0]`, visit);
+            return;
+        case 'all':
+        case 'any':
+            expr.operands.forEach((child, index) => {
+                forEachQuantifierCollection(child, boundElementRoot, `${path}.operands[${index}]`, visit);
+            });
+            return;
+        case 'for-all':
+        case 'for-any': {
+            const { collection } = expr;
+            const collectionPointer = 'pointer' in collection
+                ? substitutePointer(collection.pointer, boundElementRoot)
+                : null;
+            if (collectionPointer !== null && !collectionPointer.startsWith('@'))
+                visit(collectionPointer, `${path}.collection`);
+            forEachQuantifierCollection(expr.predicate, collectionPointer, `${path}.predicate`, visit);
+            return;
+        }
+        default:
+            return;
+    }
+}
+/** Checks response-body collection pointers, after bound-element substitution. */
+export function checkQuantifierOverNonCollection(contract) {
+    const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
+    // A leg-rooted pointer cannot resolve through the plan index: a leg id
+    // colliding with a step id is itself a compile failure. Without the
+    // witness-scoped lookup below, this check silently no-ops on every legal
+    // witness, and the generalized enumerator buys four checks out of five.
+    const operationFor = (site, stepId) => {
+        const scope = site.witnessScope;
+        if (scope !== null) {
+            return scope.legIds.includes(stepId) ? scope.operation : undefined;
+        }
+        const step = index.stepOf(stepId);
+        if (step === undefined)
+            return undefined;
+        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)`);
+            }
+        });
+    });
+}
+// Reference-set resolution.
+/**
+ * Checks every reference-set operand with an own-property lookup.
+ * This preserves legal identifiers such as `constructor`.
+ */
+export function checkReferenceSetResolution(contract) {
+    const declared = contract.referenceSets ?? {};
+    const isDeclared = (id) => Object.hasOwn(declared, id);
+    forEachContractExpression(contract, (site) => {
+        const reject = (id, path) => {
+            throw new StructuralFailure('unresolved-reference-set', `${site.artifactPath}${path}`, `referenceSet "${id}" is not declared on the contract (AD-26)`);
+        };
+        walkExpression(site.expression, 0, '', {
+            onOperand: (operand, _op, _position, path) => {
+                if ('referenceSet' in operand && !isDeclared(operand.referenceSet)) {
+                    reject(operand.referenceSet, path);
+                }
+            },
+            onSetOperand: (setOperand, path) => {
+                if ('referenceSet' in setOperand &&
+                    !isDeclared(setOperand.referenceSet)) {
+                    reject(setOperand.referenceSet, path);
+                }
+            },
+        });
+    });
+}

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

@@ -0,0 +1,5 @@
+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. */
+export declare function checkScopedResourceReferences(contract: EvalContract): void;

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

@@ -0,0 +1,19 @@
+/** AD-16 checks for forbidden inputs and scoped resource references. */
+import { StructuralFailure } from '../failure-codes.js';
+import { FORBIDDEN_INPUT_FLOOR } from '../schemas/eval-contract.js';
+/** `forbidden-input-floor-incomplete`: `forbiddenInputs` omits a floor member. */
+export function checkForbiddenInputFloor(contract) {
+    const declared = new Set(contract.forbiddenInputs);
+    for (const member of FORBIDDEN_INPUT_FLOOR) {
+        if (!declared.has(member)) {
+            throw new StructuralFailure('forbidden-input-floor-incomplete', 'EvalContract.forbiddenInputs', `omits mandatory floor member "${member}" (AD-16)`);
+        }
+    }
+}
+/** `scoped-reference-resolves-forbidden`: any scoped reference is forbidden. */
+export function checkScopedResourceReferences(contract) {
+    const resource = contract.scopedResources?.[0];
+    if (resource === undefined)
+        return;
+    throw new StructuralFailure('scoped-reference-resolves-forbidden', 'EvalContract.scopedResources[0].reference', `scoped resource reference "${resource.reference}" is forbidden (AD-16)`);
+}

package/dist/core/compile/interface-inventory.d.ts

@@ -0,0 +1,10 @@
+import type { EvalContract } from '../schemas/eval-contract.ts';
+/** Rejects permitted interface kinds that this contract version cannot run. */
+export declare function checkInterfaceKind(contract: EvalContract): void;
+/** Finds duplicate method and path signatures across the full inventory. */
+export declare function checkDuplicateOperationSignature(contract: EvalContract): void;
+/**
+ * Checks each binding key against its operation's request shape.
+ * Steps with unresolved operation IDs belong to a separate cross-field rule.
+ */
+export declare function checkUndeclaredMandatoryInput(contract: EvalContract): void;

package/dist/core/compile/interface-inventory.js

@@ -0,0 +1,55 @@
+/**
+ * Checks interface kinds, inventory-wide operation signatures, and step input
+ * bindings against each operation's request shape.
+ */
+import { StructuralFailure } from '../failure-codes.js';
+import { TRANSPORT_CHANNELS } from '../schemas/pointer.js';
+import { buildPlanIndex } from '../seal/plan-index.js';
+/** Rejects permitted interface kinds that this contract version cannot run. */
+export function checkInterfaceKind(contract) {
+    for (const iface of contract.permittedInterfaces) {
+        if (iface.kind !== 'api') {
+            throw new StructuralFailure('unsupported-interface-kind', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].kind`, `"${iface.kind}" is not supported in v0; only "api" is (AD-10)`);
+        }
+    }
+}
+/** Erases parameter names so equivalent path templates share a signature. */
+const PARAMETER_SEGMENT_PATTERN = /\{[A-Za-z0-9_-]+\}/g;
+const erase = (pathTemplate) => pathTemplate.replace(PARAMETER_SEGMENT_PATTERN, '{}');
+/** Finds duplicate method and path signatures across the full inventory. */
+export function checkDuplicateOperationSignature(contract) {
+    const seen = new Map();
+    for (const iface of contract.permittedInterfaces) {
+        for (const operation of iface.operations) {
+            const signature = `${operation.method} ${erase(operation.pathTemplate)}`;
+            const collision = seen.get(signature);
+            if (collision !== undefined) {
+                throw new StructuralFailure('duplicate-operation-signature', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].operations[operationId=${operation.operationId}]`, `collides with permittedInterfaces[logicalId=${collision.logicalId}].operations[operationId=${collision.operation.operationId}] after parameter-name erasure ("${signature}") (AD-19, AD-40)`);
+            }
+            seen.set(signature, { logicalId: iface.logicalId, operation });
+        }
+    }
+}
+/**
+ * Checks each binding key against its operation's request shape.
+ * Steps with unresolved operation IDs belong to a separate cross-field rule.
+ */
+export function checkUndeclaredMandatoryInput(contract) {
+    const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
+    for (const step of contract.interactionPlan) {
+        const operation = index.operationOf(step.operationId);
+        if (operation === undefined)
+            continue;
+        for (const channel of TRANSPORT_CHANNELS) {
+            const binding = step.inputBinding[channel];
+            if (binding === null)
+                continue;
+            const { requiredKeys, permittedKeys } = operation.requestShape[channel];
+            for (const key of Object.keys(binding)) {
+                if (!requiredKeys.includes(key) && !permittedKeys.includes(key)) {
+                    throw new StructuralFailure('undeclared-mandatory-input', `EvalContract.interactionPlan[stepId=${step.stepId}].inputBinding.${channel}[${JSON.stringify(key)}]`, `operation "${operation.operationId}" declares "${key}" in neither requiredKeys nor permittedKeys of its ${channel} channel (AD-4)`);
+                }
+            }
+        }
+    }
+}

package/dist/core/compile/oracle-alignment.d.ts

@@ -0,0 +1,14 @@
+import type { EvalContract } from '../schemas/eval-contract.ts';
+/** Rejects the first oracle missing its direction or check channel. */
+export declare function checkOracleChannel(contract: EvalContract): void;
+/**
+ * Bare `@/` refers to the bound element; the RFC 6901 tail stays encoded.
+ * Exported for `checkQuantifierOverNonCollection` in expression-legality.ts,
+ * which reuses it for a nested quantifier's own substitution.
+ */
+export declare function substitutePointer(pointer: string, boundElementRoot: string | null): string;
+/**
+ * Checks direction targets and relation against the check, then compares
+ * direction polarity with the oracle.
+ */
+export declare function checkOracleAlignment(contract: EvalContract): void;

package/dist/core/compile/oracle-alignment.js

@@ -0,0 +1,93 @@
+/**
+ * Checks AD-3 oracle channels and structural alignment. Alignment covers
+ * evidence targets, relation, and polarity after bound-element resolution.
+ */
+import { StructuralFailure } from '../failure-codes.js';
+/** Rejects the first oracle missing its direction or check channel. */
+export function checkOracleChannel(contract) {
+    for (const oracle of contract.oracles) {
+        if (oracle.direction === null || oracle.check === null) {
+            const missingField = oracle.direction === null ? 'direction' : 'check';
+            throw new StructuralFailure('oracle-missing-channel', `EvalContract.oracles[id=${oracle.id}].${missingField}`, `omits its ${missingField} (AD-3)`);
+        }
+    }
+}
+/**
+ * Bare `@/` refers to the bound element; the RFC 6901 tail stays encoded.
+ * Exported for `checkQuantifierOverNonCollection` in expression-legality.ts,
+ * which reuses it for a nested quantifier's own substitution.
+ */
+export function substitutePointer(pointer, boundElementRoot) {
+    if (!pointer.startsWith('@'))
+        return pointer;
+    if (boundElementRoot === null)
+        return pointer;
+    const tailSource = pointer.slice(1);
+    return tailSource === '/'
+        ? boundElementRoot
+        : `${boundElementRoot}${tailSource}`;
+}
+function operandPointer(operand, boundElementRoot) {
+    if (!('pointer' in operand))
+        return null;
+    return substitutePointer(operand.pointer, boundElementRoot);
+}
+/** Collects operators and resolved evidence targets across nested quantifiers. */
+function collectTargets(expr, boundElementRoot, targets, ops) {
+    ops.add(expr.op);
+    switch (expr.op) {
+        case 'not':
+            collectTargets(expr.operands[0], boundElementRoot, targets, ops);
+            return;
+        case 'all':
+        case 'any':
+            for (const child of expr.operands)
+                collectTargets(child, boundElementRoot, targets, ops);
+            return;
+        case 'for-all':
+        case 'for-any': {
+            const collectionPointer = operandPointer(expr.collection, boundElementRoot);
+            if (collectionPointer !== null)
+                targets.add(collectionPointer);
+            collectTargets(expr.predicate, collectionPointer, targets, ops);
+            return;
+        }
+        case 'set-membership': {
+            const value = operandPointer(expr.operands[0], boundElementRoot);
+            if (value !== null)
+                targets.add(value);
+            return;
+        }
+        default:
+            for (const operand of expr.operands) {
+                const pointer = operandPointer(operand, boundElementRoot);
+                if (pointer !== null)
+                    targets.add(pointer);
+            }
+    }
+}
+/**
+ * Checks direction targets and relation against the check, then compares
+ * direction polarity with the oracle.
+ */
+export function checkOracleAlignment(contract) {
+    for (const oracle of contract.oracles) {
+        const { direction, check } = oracle;
+        if (direction === null || check === null)
+            continue;
+        const targets = new Set();
+        const ops = new Set();
+        collectTargets(check, null, targets, ops);
+        for (const target of direction.evidenceTargets) {
+            if (!targets.has(target)) {
+                throw new StructuralFailure('direction-check-misaligned', `EvalContract.oracles[id=${oracle.id}].direction.evidenceTargets`, `"${target}" is not contained in check, even after quantifier substitution (AD-3)`);
+            }
+        }
+        if (!ops.has(direction.relation)) {
+            throw new StructuralFailure('direction-check-misaligned', `EvalContract.oracles[id=${oracle.id}].direction.relation`, `"${direction.relation}" does not appear anywhere in check (AD-3)`);
+        }
+        if (direction.polarity !== oracle.polarity) {
+            throw new StructuralFailure('direction-check-misaligned', `EvalContract.oracles[id=${oracle.id}].direction.polarity`, `"${direction.polarity}" disagrees with the oracle's own polarity "${oracle.polarity}" (AD-3, AD-33)`);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { EvalContract } from '../schemas/eval-contract.ts';
+import { type PlanIndex } from '../seal/plan-index.ts';
+export declare function checkBoundElementScope(contract: EvalContract): void;
+type ReachabilityResult = {
+    readonly reachable: true;
+} | {
+    readonly reachable: false;
+    readonly reason: string;
+};
+/**
+ * Non-throwing core that `checkEvidenceReachability` wraps; also called
+ * directly by tests.
+ */
+export declare function evaluatePointerReachability(pointer: string, index: PlanIndex): ReachabilityResult;
+/** `unreachable-check-evidence`: an interaction-rooted pointer the declared interfaces cannot produce. */
+export declare function checkEvidenceReachability(contract: EvalContract): void;
+export {};