eval-quality 0.1.0 → 0.3.0

package/dist/core/schemas/sensitivity-witness.d.ts

@@ -11,7 +11,7 @@ import { Expression } from './expression.ts';
  * leg the plan could not map onto a `ProbeRequest` would declare work nothing
  * runs.
  */
-export declare const WitnessInputs: z.ZodObject<{
+export declare const ApiWitnessInputs: z.ZodObject<{
     path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
     query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
     header: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -22,6 +22,72 @@ export declare const WitnessInputs: z.ZodObject<{
         kind: z.ZodLiteral<"absent">;
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>;
+export type ApiWitnessInputs = z.infer<typeof ApiWitnessInputs>;
+/**
+ * The same, for a leg supplied to a command-kind operation. `stdin` is a
+ * tagged value rather than a key map for exactly the reason `body` is: one leg
+ * supplies a value and has to tell an absent standard input from one carrying
+ * JSON null, which a key map cannot express. The request shape's `stdin` stays
+ * a key map, because a declaration says which keys an operation accepts.
+ * `suppliedKeys` is the code that bridges the two spellings and it
+ * special-cases `stdin` alongside `body`.
+ *
+ * AD-18 applies to `environment` the way it applies to `header`, so an
+ * environment value carries no credential.
+ */
+export declare const CommandWitnessInputs: z.ZodObject<{
+    argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    environment: z.ZodRecord<z.ZodString, z.ZodString>;
+    stdin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        value: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type CommandWitnessInputs = z.infer<typeof CommandWitnessInputs>;
+/**
+ * Either spelling. A plain union rather than a discriminated one for the same
+ * reason `InputBinding` is: the leg names an operation and the kind of the
+ * interface declaring it lives in another subtree, so no discriminator is
+ * available to the schema and the agreement is a compile-time check.
+ *
+ * Only the sensitivity leg takes the union. `ManifestationWitness` and
+ * `FixtureReset` keep the transport spelling, which keeps the probe artifact
+ * byte-identical and keeps this shape's widening inside the eval contract's own
+ * version bump. That is truthful rather than merely convenient: both of those
+ * legs are issued through the environment-probe port, whose `ProbeRequest`
+ * carries a method, a path template, and the four transport channels, and
+ * pre-flight rejects a non-api interface for exactly that reason.
+ */
+export declare const WitnessInputs: z.ZodUnion<readonly [z.ZodObject<{
+    path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    header: z.ZodRecord<z.ZodString, z.ZodString>;
+    body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    environment: z.ZodRecord<z.ZodString, z.ZodString>;
+    stdin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        value: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>]>;
 export type WitnessInputs = z.infer<typeof WitnessInputs>;
 /**
  * Half a witness pair. `legId` roots the relation's pointers, which address this
@@ -30,7 +96,7 @@ export type WitnessInputs = z.infer<typeof WitnessInputs>;
  */
 export declare const SensitivityWitnessLeg: z.ZodObject<{
     legId: z.ZodString;
-    inputs: z.ZodObject<{
+    inputs: z.ZodUnion<readonly [z.ZodObject<{
         path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
         query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
         header: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -40,14 +106,33 @@ export declare const SensitivityWitnessLeg: z.ZodObject<{
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"absent">;
         }, z.core.$strict>], "kind">;
-    }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+        option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+        environment: z.ZodRecord<z.ZodString, z.ZodString>;
+        stdin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"json">;
+            value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"absent">;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>]>;
 }, z.core.$strict>;
 export type SensitivityWitnessLeg = z.infer<typeof SensitivityWitnessLeg>;
-export declare const WITNESS_CHANNELS: readonly ['path', 'query', 'body'];
+export declare const API_WITNESS_CHANNELS: readonly ['path', 'query', 'body'];
+export declare const COMMAND_WITNESS_CHANNELS: readonly ['argument', 'option', 'environment', 'stdin'];
+export declare const WITNESS_CHANNELS: readonly ["path", "query", "body", "argument", "option", "environment", "stdin"];
 export declare const WitnessChannel: z.ZodEnum<{
+    argument: "argument";
     body: "body";
+    environment: "environment";
+    option: "option";
     path: "path";
     query: "query";
+    stdin: "stdin";
 }>;
 export type WitnessChannel = z.infer<typeof WitnessChannel>;
 /**
@@ -67,13 +152,17 @@ export type WitnessChannel = z.infer<typeof WitnessChannel>;
 export declare const SensitivityWitness: z.ZodObject<{
     witnessId: z.ZodString;
     channel: z.ZodEnum<{
+        argument: "argument";
         body: "body";
+        environment: "environment";
+        option: "option";
         path: "path";
         query: "query";
+        stdin: "stdin";
     }>;
     legs: z.ZodArray<z.ZodObject<{
         legId: z.ZodString;
-        inputs: z.ZodObject<{
+        inputs: z.ZodUnion<readonly [z.ZodObject<{
             path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
             query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
             header: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -83,7 +172,20 @@ export declare const SensitivityWitness: z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"absent">;
             }, z.core.$strict>], "kind">;
-        }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            argument: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+            option: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+            environment: z.ZodRecord<z.ZodString, z.ZodString>;
+            stdin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"json">;
+                value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"absent">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>]>;
     }, z.core.$strict>>;
     relation: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
 }, z.core.$strict>;

package/dist/core/schemas/sensitivity-witness.js

@@ -2,7 +2,7 @@
 import { z } from 'zod';
 import { Expression } from './expression.js';
 import { Identifier, JsonObjectValue, KeyName } from './primitives.js';
-import { ProbeRequestBody } from './probe-body.js';
+import { ProbeRequestBody, ProbeRequestStdin } from './probe-body.js';
 /**
  * The four transport channels one probe leg supplies, as values. `RequestShape`
  * declares what an operation accepts; this declares what one leg sends. AD-18
@@ -13,7 +13,7 @@ import { ProbeRequestBody } from './probe-body.js';
  * leg the plan could not map onto a `ProbeRequest` would declare work nothing
  * runs.
  */
-export const WitnessInputs = z
+export const ApiWitnessInputs = z
     .strictObject({
     path: JsonObjectValue,
     query: JsonObjectValue,
@@ -24,6 +24,46 @@ export const WitnessInputs = z
     id: 'WitnessInputs',
     description: "One probe leg's supplied inputs, keyed by AD-19 transport channel, in the spelling the environment-probe port accepts. Shared by both witness kinds and by the fixture reset, so the export carries it once.",
 });
+/**
+ * The same, for a leg supplied to a command-kind operation. `stdin` is a
+ * tagged value rather than a key map for exactly the reason `body` is: one leg
+ * supplies a value and has to tell an absent standard input from one carrying
+ * JSON null, which a key map cannot express. The request shape's `stdin` stays
+ * a key map, because a declaration says which keys an operation accepts.
+ * `suppliedKeys` is the code that bridges the two spellings and it
+ * special-cases `stdin` alongside `body`.
+ *
+ * AD-18 applies to `environment` the way it applies to `header`, so an
+ * environment value carries no credential.
+ */
+// Bare, with no `.meta({ id })`, and the reason is a published-schema one
+// rather than a size one. A `$ref`'d definition's own errors reach ajv with a
+// schema path relative to that definition, so two definitions under one
+// `anyOf` report `#/required` and `#/additionalProperties` at the same
+// instance path and nothing tells them apart. AD-13's mutation sweep needs one
+// keyword deletion to be attributable to one occurrence, and the branch is
+// attributable only while it is spelled in place.
+export const CommandWitnessInputs = z.strictObject({
+    argument: JsonObjectValue,
+    option: JsonObjectValue,
+    environment: z.record(KeyName, z.string()),
+    stdin: ProbeRequestStdin,
+});
+/**
+ * Either spelling. A plain union rather than a discriminated one for the same
+ * reason `InputBinding` is: the leg names an operation and the kind of the
+ * interface declaring it lives in another subtree, so no discriminator is
+ * available to the schema and the agreement is a compile-time check.
+ *
+ * Only the sensitivity leg takes the union. `ManifestationWitness` and
+ * `FixtureReset` keep the transport spelling, which keeps the probe artifact
+ * byte-identical and keeps this shape's widening inside the eval contract's own
+ * version bump. That is truthful rather than merely convenient: both of those
+ * legs are issued through the environment-probe port, whose `ProbeRequest`
+ * carries a method, a path template, and the four transport channels, and
+ * pre-flight rejects a non-api interface for exactly that reason.
+ */
+export const WitnessInputs = z.union([ApiWitnessInputs, CommandWitnessInputs]);
 /**
  * Half a witness pair. `legId` roots the relation's pointers, which address this
  * leg's response as `/interactions/{legId}/response-body/...`, so it shares one
@@ -36,7 +76,23 @@ export const SensitivityWitnessLeg = z.strictObject({
 // AD-10 selects the differential channel by the operation's state-change
 // marker: `path` or `query` where the marker is false, `body` where it is true.
 // `header` is absent on purpose; no AD names a header differential.
-export const WITNESS_CHANNELS = ['path', 'query', 'body'];
+export const API_WITNESS_CHANNELS = ['path', 'query', 'body'];
+// A command operation's differential channel. All four are admitted rather
+// than two: AD-10's marker rule selects `path` or `query` against `body`
+// because an HTTP read carries its identifier in the URL and a write carries
+// it in the body, and a command carries its inputs the same way whether or not
+// it changes state, so the marker decides nothing here. Which channel a given
+// command witness may use is the contract author's choice.
+export const COMMAND_WITNESS_CHANNELS = [
+    'argument',
+    'option',
+    'environment',
+    'stdin',
+];
+export const WITNESS_CHANNELS = [
+    ...API_WITNESS_CHANNELS,
+    ...COMMAND_WITNESS_CHANNELS,
+];
 export const WitnessChannel = z.enum(WITNESS_CHANNELS);
 /**
  * AD-10's typed sensitivity witness: a pair of inputs and the AD-4 relation
@@ -70,7 +126,7 @@ export const ManifestationWitness = z.strictObject({
     legId: Identifier,
     interfaceId: Identifier,
     operationId: Identifier,
-    inputs: WitnessInputs,
+    inputs: ApiWitnessInputs,
     relation: Expression,
 });
 /**
@@ -82,5 +138,5 @@ export const FixtureReset = z.strictObject({
     legId: Identifier,
     interfaceId: Identifier,
     operationId: Identifier,
-    inputs: WitnessInputs,
+    inputs: ApiWitnessInputs,
 });

package/dist/core/score/binding-order.d.ts

@@ -0,0 +1,31 @@
+import type { InteractionStep } from '../schemas/plan.ts';
+export type BindingOrder = {
+    /** Ascending tiers; within each, steps in declaration order. Every declared id appears exactly once. */
+    readonly tiers: readonly (readonly string[])[];
+    /**
+     * Ids Kahn's algorithm left unplaced, in declaration order: the members of an
+     * ordering cycle and every step downstream of one, since a step whose
+     * dependency never gets a tier never gets one either.
+     */
+    readonly cyclic: readonly string[];
+};
+/**
+ * Cyclic steps come back as data instead of an exception, matching
+ * `selectObservations`'s own policy of reporting ambiguity rather than deciding
+ * it. A compiled contract whose step ids are unique never reaches that list:
+ * `binding-cycle` rejects every cycle carrying a capture edge and
+ * `nested-temporal-clause` every cycle made of `after` edges alone, so the
+ * union graph is acyclic by the time any record is scored.
+ *
+ * The uniqueness clause is load-bearing. `checkNestedTemporalClause` resolves
+ * `after` through a plan index built with `duplicateIds: 'unresolved'`, which
+ * deletes a duplicated id and reads any clause naming it as dangling, while
+ * this function and `checkBindingCycle` both test against the raw declared-id
+ * set, where it is present. So a plan declaring one id twice can carry an
+ * `after` cycle those two disagree about, and its steps land here. Nothing
+ * downstream sees it: `seal` builds its own index with the default throwing
+ * option and rejects a duplicate id outright. Changing how
+ * `checkNestedTemporalClause` reads a duplicate is deliberate shipped
+ * behaviour and belongs to whoever owns that check.
+ */
+export declare function bindingOrder(interactionPlan: readonly InteractionStep[]): BindingOrder;

package/dist/core/score/binding-order.js

@@ -0,0 +1,88 @@
+/**
+ * The order a plan's steps must be resolved in when one step's selection
+ * depends on another's. Kahn tiers over the union of the capture edges and
+ * AD-39's `after` edges, the same graph `checkBindingCycle` builds: every step
+ * in tier n depends only on steps in tiers below n, so a caller walking the
+ * tiers in order always has what it needs resolved by the time it reads it.
+ *
+ * The `after` edge is in the graph because `selectWithBindings` resolves a
+ * temporal anchor through the same binding filter as everything else, so a step
+ * can read an anchor whose own capture sites must already be written. Tiering
+ * captures alone made the answer depend on declaration order within a tier: two
+ * same-tier steps swapped flipped a verdict between `none` and one match.
+ *
+ * `{ literal }`, `{ matcher }`, and `{ principal }` bindings declare no
+ * dependency, so a step carrying only those and no clause is tier zero. So is a
+ * step whose captured pointer or `after` clause names an id the plan does not
+ * declare: a dangling capture is `unreachable-check-evidence`'s at compile time,
+ * AD-39 makes a dangling `after` permissive, and nothing here should invent an
+ * ordering for either.
+ *
+ * Within a tier the order is the order the steps are declared in
+ * `interactionPlan`, which is what "sequence order within a tier" can mean at
+ * compile time, where no observation `sequence` exists yet. ADR-006 bans
+ * reading order off array position in a run record, where the array is an
+ * ingest artifact nobody authored; a contract's `interactionPlan` is the
+ * author's own declaration, and permuting it yields a different contract with a
+ * different digest, so there is no permutation invariance to preserve.
+ */
+import { capturedBindings } from '../compile/bindings.js';
+/**
+ * Cyclic steps come back as data instead of an exception, matching
+ * `selectObservations`'s own policy of reporting ambiguity rather than deciding
+ * it. A compiled contract whose step ids are unique never reaches that list:
+ * `binding-cycle` rejects every cycle carrying a capture edge and
+ * `nested-temporal-clause` every cycle made of `after` edges alone, so the
+ * union graph is acyclic by the time any record is scored.
+ *
+ * The uniqueness clause is load-bearing. `checkNestedTemporalClause` resolves
+ * `after` through a plan index built with `duplicateIds: 'unresolved'`, which
+ * deletes a duplicated id and reads any clause naming it as dangling, while
+ * this function and `checkBindingCycle` both test against the raw declared-id
+ * set, where it is present. So a plan declaring one id twice can carry an
+ * `after` cycle those two disagree about, and its steps land here. Nothing
+ * downstream sees it: `seal` builds its own index with the default throwing
+ * option and rejects a duplicate id outright. Changing how
+ * `checkNestedTemporalClause` reads a duplicate is deliberate shipped
+ * behaviour and belongs to whoever owns that check.
+ */
+export function bindingOrder(interactionPlan) {
+    // A duplicated id collapses to one node: the plan declares one name, and
+    // which of two same-named steps a capture meant is undecidable here.
+    const declared = [];
+    const dependencies = new Map();
+    for (const step of interactionPlan) {
+        if (dependencies.has(step.stepId))
+            continue;
+        declared.push(step.stepId);
+        dependencies.set(step.stepId, new Set());
+    }
+    for (const step of interactionPlan) {
+        const own = dependencies.get(step.stepId);
+        if (own === undefined)
+            continue;
+        for (const capture of capturedBindings(step)) {
+            const { stepId } = capture.target;
+            // A self-reference is a cycle of one, so it stays in the graph and lands
+            // in `cyclic` rather than being filtered into tier zero.
+            if (dependencies.has(stepId))
+                own.add(stepId);
+        }
+        if (step.after !== null && dependencies.has(step.after)) {
+            own.add(step.after);
+        }
+    }
+    const tiers = [];
+    const placed = new Set();
+    while (placed.size < declared.length) {
+        const tier = declared.filter((stepId) => !placed.has(stepId) &&
+            [...(dependencies.get(stepId) ?? [])].every((id) => placed.has(id)));
+        // Every remaining step depends on another remaining step, which is a cycle.
+        if (tier.length === 0)
+            break;
+        tiers.push(tier);
+        for (const stepId of tier)
+            placed.add(stepId);
+    }
+    return { tiers, cyclic: declared.filter((stepId) => !placed.has(stepId)) };
+}

package/dist/core/score/bindings.d.ts

@@ -0,0 +1,93 @@
+import { type ResolvedValue } from '../evaluate/resolved-value.ts';
+import type { InteractionStep } from '../schemas/plan.ts';
+import type { InputChannelName } from '../schemas/pointer.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 StepSelection } from './selection.ts';
+/**
+ * One captured pointer's resolution. `ResolvedValue` alone cannot carry this:
+ * it is `JsonValue | ABSENT` with nowhere to put the observation the value came
+ * from, its `sequence`, or the referenced step's named ambiguity. `sequence` is
+ * what gives "earlier" a runtime meaning, since a capture graph that is acyclic
+ * still says nothing about which observation came first.
+ */
+export type CapturedResolution = {
+    readonly status: 'resolved';
+    readonly value: ResolvedValue;
+    readonly observationId: Observation['observationId'];
+    readonly sequence: number;
+} | {
+    readonly status: 'absent';
+} | {
+    readonly status: 'ambiguous';
+    readonly matchedObservationIds: readonly Observation['observationId'][];
+};
+/**
+ * The key one captured binding occupies in the resolution map. Keyed by
+ * binding site rather than by pointer: one step can carry several captured
+ * bindings, and two of them may name the same pointer in different channels.
+ * JSON-encoded rather than delimiter-joined, since a parameter key is arbitrary
+ * caller-supplied text and could contain any separator.
+ */
+export declare function bindingSiteKey(stepId: string, transportChannel: InputChannelName, key: string): string;
+/**
+ * Resolves one captured pointer against the record.
+ *
+ * The referenced step is selected through `selectWithBindings`, so its own
+ * selection predicate applies before a value is read off it. Selecting it with
+ * `selectObservations` alone would match on `operationId` and leave a step that
+ * only its own bindings separate reporting the named ambiguity, which would
+ * make a capture from either half of a literal-bound collision pair resolve
+ * nothing at all. `resolved` carries the referenced step's own captured values,
+ * already filled by the tier below it, which is what makes the tiering
+ * load-bearing.
+ *
+ * The three dispositions already settled hold unchanged over the filtered
+ * result: one match binds, several under a declared `any` binds the lowest
+ * `sequence`, and several under `exactly-one`/`at-most-one` is the named
+ * ambiguity, returned as data with no value resolved.
+ *
+ * A pointer whose step the plan does not declare, or whose referenced step
+ * matched nothing, resolves `absent`.
+ *
+ * `resolved` as a status means an observation was selected, which is a
+ * different fact from the pointer finding a value in it: a tail that walks off
+ * the observed body comes back `resolved` carrying `ABSENT`, with the source
+ * observation and its `sequence` intact. That is why `CapturedResolution.value`
+ * is `ResolvedValue`. AD-26 makes absent an observation rather than an error,
+ * and `deepEquals` is false against it, so the referencing step still selects
+ * `none`; keeping the source observation means the ordering floor stays
+ * computable either way.
+ */
+export declare function resolveCapturedValue(pointer: string, index: PlanIndex, observations: readonly Observation[], resolved: ReadonlyMap<string, CapturedResolution>): CapturedResolution;
+/**
+ * Every captured binding in the plan, resolved in `bindingOrder`'s tiers and
+ * keyed by binding site. Walking the tiers in order is what lets a step's
+ * captured values be resolved against a referenced step whose own captures are
+ * already in the map. Steps `bindingOrder` reports cyclic are left out, so
+ * their bindings resolve as unlisted and filter every candidate away.
+ */
+export declare function resolveCapturedBindings(interactionPlan: readonly InteractionStep[], index: PlanIndex, observations: readonly Observation[]): ReadonlyMap<string, CapturedResolution>;
+export declare function deepEquals(a: ResolvedValue, b: ResolvedValue): boolean;
+export declare function jsonTypeOf(value: JsonValue): string;
+/**
+ * `selectObservations`, then the step's own selection predicate as a filter
+ * over the matches, then the cardinality verdict over what survived.
+ *
+ * The order is temporal clause, then capture ordering, then the binding
+ * filters. Ordering is enforced at score time as well as at compile time: the
+ * persistence read-back this exists for is exactly a claim about order, and a
+ * record whose `GET` sits at `sequence` 2 and whose `POST` sits at `sequence` 9
+ * would otherwise satisfy the binding and pass an oracle proving the opposite.
+ *
+ * `resolved` is the map `resolveCapturedBindings` fills from `bindingOrder`'s
+ * tiers, keyed by binding site. An unlisted or unresolved site filters every
+ * candidate out, so a caller that skipped a tier gets `none` rather than a
+ * silently wrong match.
+ *
+ * A filter over zero bindings and no clause separates nothing, so two steps
+ * sharing an operation and declaring neither both still return `several`: the
+ * declared structure does not distinguish them.
+ */
+export declare function selectWithBindings(step: InteractionStep, observations: readonly Observation[], index: PlanIndex, resolved: ReadonlyMap<string, CapturedResolution>): StepSelection;