eval-quality 0.1.0 → 0.3.0

package/dist/core/schemas/interface.js

@@ -85,7 +85,8 @@ export const PathTemplate = z
     .string()
     .regex(PATH_TEMPLATE_PATTERN)
     .describe('A path template whose parameters are spelled `{name}` in braces. The `:name` spelling is rejected: AD-40 resolves a defect signature by comparing method and path template, and that comparison is not implementable against an unstated syntax.');
-export const Operation = z.strictObject({
+export const Operation = z
+    .strictObject({
     operationId: Identifier,
     method: HttpMethod,
     pathTemplate: PathTemplate,
@@ -96,6 +97,91 @@ export const Operation = z.strictObject({
     responseDescriptor: ResponseDescriptor,
     volatilePointers: z.array(DescriptorPointer),
     sensitivityWitness: SensitivityWitness.nullable().describe('AD-10, mandatory per declared operation rather than per interface. `null` is legal only for an operation declaring no keys in any request channel; AD-10 exempts that operation and requires the exemption to be recorded, which pre-flight does as an `exempt` check. An input-bearing operation declaring `null` fails a strict compilation under `undeclared-mandatory-input`, alongside the other declaration-completeness check that code already gates.'),
+})
+    .meta({
+    id: 'Operation',
+    description: "AD-19's per-operation declaration inventory for an interface that speaks HTTP. Carried by the `api`, `web`, and `mcp` branches alike, so the export names it once instead of inlining three copies that could drift apart.",
+});
+/**
+ * AD-35 applied to a command: the operation names a logical executable and the
+ * caller maps it to something runnable outside the contract. `Identifier`'s
+ * charset admits no slash, dot, or colon, so `/usr/local/bin/tool`, `./tool`,
+ * and `http://host/tool` are parse errors rather than compile findings. That is
+ * what makes AD-35 structural here instead of advisory.
+ *
+ * The subcommand path is a list of segments rather than one string for the
+ * reason `PathTemplate` spells parameters in braces and nothing else: AD-40
+ * compares identities as segments, and a single string would force two
+ * implementations to agree on a separator no field declares.
+ */
+export const CommandInvocation = z.strictObject({
+    executable: Identifier.describe('A logical executable name, never a filesystem path, a URL, a host, or a port (AD-35). The caller maps it to an authorized target through configuration outside the contract.'),
+    subcommandPath: z
+        .array(Identifier)
+        .describe('The subcommand segments after the executable, outermost first. Empty is legal and means the executable is invoked with no subcommand.'),
+});
+/**
+ * The command counterpart of `RequestShape`, built as a four-key strict object
+ * for the reason the comment above `RequestShape` gives: a record over a
+ * channel enum demands every member at parse time, and the partial spelling
+ * that would relax it is the one the Consistency Conventions ban.
+ */
+export const CommandRequestShape = z.strictObject({
+    argument: KeyedShapeDescriptor.describe("Positional arguments, keyed by the name the contract gives each position. The key is the author's own label; position is not encoded here, because no AD-31 predicate reads argument order."),
+    option: KeyedShapeDescriptor,
+    environment: KeyedShapeDescriptor.describe('AD-18: an environment channel declaration names a variable and its type and never carries a credential value. The same rule the header channel carries, for the channel that plays the same role off an HTTP interface.'),
+    stdin: KeyedShapeDescriptor,
+});
+/**
+ * Which output channel the operation's one response descriptor describes.
+ *
+ * Tagged on `kind` rather than spelled as a bare channel name because `stdout`
+ * is itself a legal `Identifier`: an untagged root could not tell the stream
+ * from an artifact genuinely named `stdout`, which is exactly the ambiguity the
+ * two members below would otherwise share.
+ */
+export const CommandDescriptorChannel = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('stream'),
+        channel: z.enum(['stdout', 'stderr']),
+    }),
+    z.strictObject({
+        kind: z.literal('artifact'),
+        artifactId: Identifier.describe('One of the identifiers this operation declares in `artifacts`. A name absent from that list fails compilation under `unresolved-artifact-reference` rather than resolving absent, because a dangling declaration is an authoring fault the compiler can see.'),
+    }),
+]);
+/**
+ * A command-kind operation. It carries exactly one `ResponseDescriptor`, the
+ * same shape an api operation carries, and `descriptorChannel` says which
+ * output channel that descriptor describes.
+ *
+ * One descriptor rather than one per output channel: AD-19 fixes the descriptor
+ * per operation so that `requiredKeys` has a truthful value, and AD-20 rule 2
+ * reads "the required keys of the response descriptor belonging to the
+ * operation that step invokes" as its denominator. Several descriptors leave
+ * that phrase with several referents, which is the defect AD-19 already records
+ * one level up for an interface-wide union. An operation whose stream and whose
+ * written file both need declared structure is two operations.
+ *
+ * There is no declared success value space for the exit code. AD-19 already
+ * declares one nominated success indicator per operation, and an exit-code
+ * assertion is an ordinary oracle over `/interactions/{stepId}/exit-code`,
+ * which the pointer grammar carries as a scalar channel.
+ */
+export const CommandOperation = z.strictObject({
+    operationId: Identifier,
+    invocation: CommandInvocation,
+    stateChangeMarker: z
+        .boolean()
+        .describe('AD-19: whether the operation is intended to change state. AD-20 rule 7 relevance reads it, and AD-10 selects the sensitivity channel by it. Both values are legal and neither is a default.'),
+    requestShape: CommandRequestShape,
+    artifacts: z
+        .array(Identifier)
+        .describe("The files the operation writes, as bare declared identifiers with existence semantics only. No descriptor and no keys of their own: an artifact pointer's identifier segment resolves against this list, and structure comes from the operation's one response descriptor when `descriptorChannel` nominates that artifact. A pointer naming an identifier absent here fails compilation under `unresolved-artifact-reference`."),
+    descriptorChannel: CommandDescriptorChannel,
+    responseDescriptor: ResponseDescriptor,
+    volatilePointers: z.array(DescriptorPointer),
+    sensitivityWitness: SensitivityWitness.nullable().describe("AD-10, mandatory per declared operation rather than per interface, on the api operation's own terms. `null` is legal only for an operation declaring no keys in any request channel, which for a command means no argument, no option, no environment variable, and no standard input. An input-bearing operation declaring `null` fails a strict compilation under `undeclared-mandatory-input`."),
 });
 /**
  * AD-19's four interface kinds, exported once so nothing else respells them:
@@ -106,10 +192,37 @@ export const Operation = z.strictObject({
  */
 export const INTERFACE_KINDS = ['api', 'web', 'cli', 'mcp'];
 export const InterfaceKind = z.enum(INTERFACE_KINDS);
-export const PermittedInterface = z.strictObject({
-    logicalId: Identifier.describe("AD-35: a logical identifier for the interface, never a URL, host, or port. Mapping it to a target is the caller's, outside the contract."),
-    kind: InterfaceKind.describe('All four kinds are admitted so `unsupported-interface-kind` stays fireable. v0 supports `api`; the other three fail compilation under that code rather than failing to parse.'),
-    operations: z
-        .array(Operation)
-        .describe('No uniqueness constraint: two operations colliding on method plus path template after parameter-name erasure is `duplicate-operation-signature`, a coded compile-time error, and a schema that deduped them would delete it.'),
+const LOGICAL_ID_DESCRIPTION = "AD-35: a logical identifier for the interface, never a URL, host, or port. Mapping it to a target is the caller's, outside the contract.";
+const OPERATIONS_DESCRIPTION = 'No uniqueness constraint: two operations colliding on their transport identity after parameter-name erasure is `duplicate-operation-signature`, a coded compile-time error, and a schema that deduped them would delete it.';
+// `web` and `mcp` carry the api operation shape unchanged. A two-member union
+// would make either one a parse failure, and a parse failure carries no AD-5
+// code, no artifact path, and no name for the kind that is unsupported, which
+// is the opposite of AD-10's "fails compilation honestly under
+// `unsupported-interface-kind`".
+const apiShapedInterface = (kind) => z.strictObject({
+    logicalId: Identifier.describe(LOGICAL_ID_DESCRIPTION),
+    kind: z.literal(kind),
+    operations: z.array(Operation).describe(OPERATIONS_DESCRIPTION),
 });
+/**
+ * Discriminated on `kind`, so an operation shape cannot be smuggled onto the
+ * wrong interface: a `cli` interface declaring `method` and an `api` interface
+ * declaring `invocation` are both parse errors.
+ */
+export const PermittedInterface = z.discriminatedUnion('kind', [
+    apiShapedInterface('api'),
+    apiShapedInterface('web'),
+    apiShapedInterface('mcp'),
+    z.strictObject({
+        logicalId: Identifier.describe(LOGICAL_ID_DESCRIPTION),
+        kind: z.literal('cli'),
+        operations: z.array(CommandOperation).describe(OPERATIONS_DESCRIPTION),
+    }),
+]);
+/**
+ * One interface's operations widened to the element union. TypeScript will not
+ * iterate `iface.operations` directly, because the union's branches give it a
+ * union of array types whose `map` signatures do not unify; this is the one
+ * place that widening is spelled, so no call site invents its own.
+ */
+export const operationsOf = (iface) => iface.operations;

package/dist/core/schemas/isolation-manifest.js

@@ -56,11 +56,17 @@ const accountingShape = Object.fromEntries(FORBIDDEN_INPUT_FLOOR.map((member) =>
  * reasoning behind `RequestShape`'s four-key object.
  */
 export const ForbiddenInputAccountingMap = z.strictObject(accountingShape);
+/**
+ * A label a reader has to be able to act on. Empty is not a mount, a network
+ * target, or a tool call, and an empty entry renders as a basis line with
+ * nothing after its colon.
+ */
+const NonEmptyLabel = z.string().min(1);
 export const IsolationManifest = z
     .strictObject({
     ...lineageFields,
     runId: z.string().min(1),
-    contractId: Identifier.describe('The prior art\'s `taskId`, renamed. "Task" is experiment vocabulary with no product meaning, and the manifest keeps an identifier because it is the artifact `core/ingest` matches against a run; the run record and the probe pin what they describe by digest instead.'),
+    contractId: Identifier.describe('The prior art\'s `taskId`, renamed. "Task" is experiment vocabulary with no product meaning, and the manifest keeps an identifier so a reader can say which contract the run was isolated for. It is a label and not a second operand for any check: `core/ingest` matches this artifact to a run on `runId`, `contractDigest`, and `evaluatorConfigurationDigest`, which is the whole of the agreement the two artifacts make. Nothing in the pipeline carries a contract identifier to compare this against, since the sealed run record pins its contract by digest and the eval contract is not among ingest\'s inputs.'),
     conditionArm: z
         .string()
         .min(1)
@@ -70,21 +76,22 @@ export const IsolationManifest = z
     contractDigest: Digest,
     evaluatorConfigurationDigest: Digest.describe('Added here and absent from the prior art. AD-32 requires this digest to agree between the manifest and the run record, which was previously an agreement rule asserted over two fields that did not exist. Required and non-nullable on both, which is what makes the substitution cost two contradictions rather than one omission. The agreement itself is a cross-artifact rule no schema can see.'),
     workspaceIdentity: z.string().min(1),
-    allowedMounts: z.array(z.string()),
+    allowedMounts: z.array(NonEmptyLabel),
     observedMounts: z
-        .array(z.string())
-        .describe('Observed mounts, network targets, and tool calls exceeding their allowlist is a violation AD-16 has `core/ingest` record; it is a cross-field rule with no AD-5 code and the schema admits it.'),
-    networkAllowlist: z.array(z.string()),
-    observedNetworkTargets: z.array(z.string()),
-    toolAllowlist: z.array(z.string()),
-    observedToolCalls: z.array(z.string()),
+        .array(NonEmptyLabel)
+        .describe('Observed mounts, network targets, and tool calls exceeding their allowlist is a violation AD-16 has `core/ingest` record; it is a cross-field rule with no AD-5 code and the schema admits it. Each entry is non-empty: an empty string is not a mount, and it renders as a basis line naming nothing after its colon.'),
+    networkAllowlist: z.array(NonEmptyLabel),
+    observedNetworkTargets: z.array(NonEmptyLabel),
+    toolAllowlist: z.array(NonEmptyLabel),
+    observedToolCalls: z.array(NonEmptyLabel),
     resourceCeilings: ResourceCeilings,
     actualResourceUse: ActualResourceUse,
     forbiddenInputAccounting: ForbiddenInputAccountingMap.describe('The field AD-16 adds and the prior art lacks: "the isolation manifest\'s required fields … account for each forbidden input by name". Seven keys, generated from `FORBIDDEN_INPUT_FLOOR` so the floor has one home.'),
     violation: z
         .string()
+        .min(1)
         .nullable()
-        .describe("The sixteenth of the prior art's sixteen required members, and the one that is not a description of the run: a non-null violation invalidates it. AD-16 says the schema is \"seeded from the prior art's fifteen\"; the prior art's `required` array has sixteen. Settled by construction: the fifteen are the fields describing the run and this is the invalidation outcome. All sixteen are carried."),
+        .describe("The sixteenth of the prior art's sixteen required members, and the one that is not a description of the run: a non-null violation invalidates it. Non-empty when present, on `QuotedEvidence.quote`'s precedent: `null` is the spelling for no violation, so an empty string is a violation that names nothing while still invalidating the run and rendering a blank basis entry. AD-16 says the schema is \"seeded from the prior art's fifteen\"; the prior art's `required` array has sixteen. Settled by construction: the fifteen are the fields describing the run and this is the invalidation outcome. All sixteen are carried."),
 })
     .meta({
     id: 'IsolationManifest',

package/dist/core/schemas/plan.d.ts

@@ -7,7 +7,52 @@ import { JsonValue } from './primitives.ts';
  * one implementation and the literal string to another, and flipped a witness
  * match between `caught` and `missed` on one record; that form is
  * unrepresentable here.
+ *
+ * Four members, one tag each. `{ literal }` writes the sent value down;
+ * `{ matcher: 'any' }` binds whatever was sent and `{ matcher: 'type-violating' }`
+ * binds a value whose JSON type differs from the operation's declared type for
+ * the key, which is how AD-31 rule 3's malformed-input behaviour is addressed.
+ *
+ * `{ captured }` addresses an earlier step's declared scalar output. Owed item
+ * 3: a `POST` returning a server-generated identifier followed by a `GET`
+ * proving persistence is unwritable with the first two, since a literal
+ * hard-codes a resource the evaluator never created and `any` matches
+ * unrelated reads. "Earlier" is earlier in the capture graph's own topological
+ * order, which `binding-cycle` makes exist. It is deliberately not AD-39's
+ * `after` clause: `nested-temporal-clause` already rejects every `after` cycle,
+ * so a capture forced to follow an `after` edge would leave `binding-cycle`
+ * unfireable. At score time the ordering is the record's `sequence`.
+ *
+ * `{ principal }` names a principal `testData.principals` declares. The two
+ * critical-severity cross-user behaviours (act as A, read as B, must be denied
+ * or absent) bind a step to an account that is neither a literal, since AD-19
+ * forbids credential values in declarations, nor an earlier step's output,
+ * since accounts are provisioned outside the observation stream. The name is
+ * an opaque label carrying no account identifier, credential, or subject data
+ * (AD-18). An undeclared name fires `undeclared-mandatory-input` in strict
+ * mode; a Zod refinement here would be a cross-subtree constraint the export
+ * cannot carry, and the published-schema differential sweep synthesises a
+ * union-branch witness that would expose the disagreement.
+ *
+ * A captured pointer resolves to a declared scalar with no transform applied,
+ * which keeps AD-4's ban on arithmetic, projection, and user-defined functions
+ * holding by construction: the grammar has no place to write one.
  */
+/**
+ * The first two members, named individually so the probe-side selector under
+ * AD-40 admits exactly these two and nothing else. Bare `export const` with no
+ * `.meta({ id })`: an id would collapse the branches to `$ref`s and mint new
+ * `$defs`, so the export stays byte-identical.
+ */
+export declare const LiteralBindingValue: z.ZodObject<{
+    literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strict>;
+export declare const MatcherBindingValue: z.ZodObject<{
+    matcher: z.ZodEnum<{
+        any: "any";
+        "type-violating": "type-violating";
+    }>;
+}, z.core.$strict>;
 export declare const BindingValue: z.ZodUnion<readonly [z.ZodObject<{
     literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
 }, z.core.$strict>, z.ZodObject<{
@@ -15,6 +60,10 @@ export declare const BindingValue: z.ZodUnion<readonly [z.ZodObject<{
         any: "any";
         "type-violating": "type-violating";
     }>;
+}, z.core.$strict>, z.ZodObject<{
+    captured: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    principal: z.ZodString;
 }, z.core.$strict>]>;
 /** the constraint identifier the ledger carries for the check below. */
 export declare const BINDING_CHANNEL_NON_EMPTY = "binding-channel-non-empty";
@@ -25,6 +74,10 @@ export declare const BindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString, z.Zo
         any: "any";
         "type-violating": "type-violating";
     }>;
+}, z.core.$strict>, z.ZodObject<{
+    captured: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    principal: z.ZodString;
 }, z.core.$strict>]>>>;
 /**
  * A four-key strict object with each channel nullable, not a record over the
@@ -32,7 +85,7 @@ export declare const BindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString, z.Zo
  * requires every member at parse time and fails five of the Gate C fixture's
  * six steps, all of which bind a subset of the channels.
  */
-export declare const InputBinding: z.ZodObject<{
+export declare const ApiInputBinding: z.ZodObject<{
     path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
     }, z.core.$strict>, z.ZodObject<{
@@ -40,6 +93,10 @@ export declare const InputBinding: z.ZodObject<{
             any: "any";
             "type-violating": "type-violating";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
     }, z.core.$strict>]>>>;
     query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -48,6 +105,10 @@ export declare const InputBinding: z.ZodObject<{
             any: "any";
             "type-violating": "type-violating";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
     }, z.core.$strict>]>>>;
     header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -56,6 +117,10 @@ export declare const InputBinding: z.ZodObject<{
             any: "any";
             "type-violating": "type-violating";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
     }, z.core.$strict>]>>>;
     body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -64,8 +129,199 @@ export declare const InputBinding: z.ZodObject<{
             any: "any";
             "type-violating": "type-violating";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+/** The same shape over the four channels a command-kind operation accepts. */
+export declare const CommandInputBinding: z.ZodObject<{
+    argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
     }, z.core.$strict>]>>>;
 }, z.core.$strict>;
+/**
+ * A plain union rather than a discriminated one, and the agreement between a
+ * step's bound channels and its operation's kind is a compile-time check
+ * rather than a schema refinement.
+ *
+ * A step names an `operationId` and nothing else; the kind of the interface
+ * declaring that operation lives in a different subtree of the same document.
+ * That is the cross-subtree constraint the `{ principal }` comment above
+ * already records as unrepresentable in the export. Adding a `kind` field to
+ * the step itself was the other option and duplicates a fact the operation
+ * already carries, which makes a disagreeing step a second inconsistency to
+ * check rather than one fewer.
+ */
+export declare const InputBinding: z.ZodUnion<readonly [z.ZodObject<{
+    path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>, z.ZodObject<{
+    argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>]>;
+export type InputBinding = z.infer<typeof InputBinding>;
+export type BindingChannel = z.infer<typeof BindingChannel>;
+/**
+ * AD-39's declared selector cardinality (owed item 2): what a step means when
+ * its selector matches more than one observation was not decided at the
+ * architecture layer, so a first-match scorer and a last-match scorer could
+ * bind different evidence. The contract now declares the rule per step.
+ * `several` under `exactly-one`/`at-most-one` is a named ambiguity condition;
+ * a reference function returns it as data. Routing that ambiguity to a
+ * verdict rung is later work. `any` is unrelated to
+ * `BindingValue`'s `{ matcher: 'any' }` above: same string, different field,
+ * no type-level collision. `ExpectedCardinality` (`interface.ts`) is a
+ * second, unrelated reuse of the word for AD-20's response-collection
+ * cardinality, and its `at-most` mode is a near-miss for `at-most-one` here;
+ * different type, different field, no collision, but easy to misread as the
+ * same declaration.
+ */
+export declare const SELECTOR_CARDINALITIES: readonly ['exactly-one', 'at-most-one', 'any'];
+export type SelectorCardinalityValue = (typeof SELECTOR_CARDINALITIES)[number];
+export declare const SelectorCardinality: z.ZodEnum<{
+    any: "any";
+    "at-most-one": "at-most-one";
+    "exactly-one": "exactly-one";
+}>;
 /**
  * AD-39: a step is a selector over observations the evaluator produced, never
  * an instruction. Its selection predicate is spelled as its two members, the
@@ -76,7 +332,7 @@ export declare const InputBinding: z.ZodObject<{
 export declare const InteractionStep: z.ZodObject<{
     stepId: z.ZodString;
     operationId: z.ZodString;
-    inputBinding: z.ZodObject<{
+    inputBinding: z.ZodUnion<readonly [z.ZodObject<{
         path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
             literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
         }, z.core.$strict>, z.ZodObject<{
@@ -84,6 +340,10 @@ export declare const InteractionStep: z.ZodObject<{
                 any: "any";
                 "type-violating": "type-violating";
             }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
         }, z.core.$strict>]>>>;
         query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
             literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -92,6 +352,10 @@ export declare const InteractionStep: z.ZodObject<{
                 any: "any";
                 "type-violating": "type-violating";
             }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
         }, z.core.$strict>]>>>;
         header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
             literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -100,6 +364,10 @@ export declare const InteractionStep: z.ZodObject<{
                 any: "any";
                 "type-violating": "type-violating";
             }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
         }, z.core.$strict>]>>>;
         body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
             literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -108,8 +376,66 @@ export declare const InteractionStep: z.ZodObject<{
                 any: "any";
                 "type-violating": "type-violating";
             }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+        option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+        environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
         }, z.core.$strict>]>>>;
-    }, z.core.$strict>;
+        stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>]>;
     after: z.ZodNullable<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        any: "any";
+        "at-most-one": "at-most-one";
+        "exactly-one": "exactly-one";
+    }>;
 }, z.core.$strict>;
 export type InteractionStep = z.infer<typeof InteractionStep>;