eval-quality 0.1.0 → 0.3.0

package/dist/core/schemas/defect-signature.d.ts

@@ -0,0 +1,695 @@
+/** AD-40's machine-readable defect signature and its probe-side selector. */
+import { z } from 'zod';
+import { Expression } from './expression.ts';
+/**
+ * The reserved step identifier every pointer in a discriminating condition is
+ * rooted at. AD-40 requires the predicate to be rooted at the selected
+ * observation rather than at a step identifier, and the shipped `Expression`
+ * addresses evidence only through an interaction-rooted pointer, so the
+ * signature spends one fixed word instead of minting a fourth pointer grammar:
+ *
+ *     /interactions/observed/response-status
+ *     /interactions/observed/response-body/error/code
+ *
+ * A fixed word, so no contract-local choice reaches the corpus, and the gate
+ * checks contract-independence instead of asserting it. Evaluation is the
+ * shipped path with no adapter: build the resolver map with exactly this one
+ * key, and resolve.
+ *
+ * `observed` is a legal `Identifier` and nothing reserves it, so a contract may
+ * declare a step by that name. The design is safe because the resolver map is
+ * built fresh with exactly one key and is never merged with a plan's
+ * observations. That is a stated invariant of this module;
+ * `compile/sensitivity-witness.ts` guards the same collision one level in.
+ */
+export declare const OBSERVED_STEP_ID = "observed";
+/**
+ * The probe-side binding value: `{ literal }` and `{ matcher }` only.
+ *
+ * Deliberately its own union rather than a reuse of `BindingValue`, which also
+ * admits `{ captured }` and `{ principal }`. A captured pointer names an
+ * earlier step of a contract's plan, and a principal names an entry of a
+ * contract's `testData`; both are contract-local vocabulary, and a corpus
+ * signature that carried either would resolve nothing against a second
+ * contract. The rejection is structural, so a probe carrying one fails to parse
+ * rather than qualifying and then matching nothing.
+ */
+export declare const ProbeBindingValue: z.ZodUnion<readonly [z.ZodObject<{
+    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    matcher: z.ZodEnum<{
+        any: "any";
+        "type-violating": "type-violating";
+    }>;
+}, z.core.$strict>]>;
+/** the constraint identifier the ledger carries for the check below. */
+export declare const PROBE_BINDING_CHANNEL_NON_EMPTY = "probe-binding-channel-non-empty";
+export declare const ProbeBindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    matcher: z.ZodEnum<{
+        any: "any";
+        "type-violating": "type-violating";
+    }>;
+}, z.core.$strict>]>>>;
+/**
+ * Every input channel of either kind, spelled exactly as `ObservedCallInputs`
+ * spells them. The two shapes agree on channel names, on the eight-key strict
+ * form, and on flatness, so the selector filters recorded call inputs with no
+ * shape to bridge.
+ *
+ * One object over both kinds rather than a union, on `ObservedCallInputs`'s own
+ * reasoning: `null` already means "binds nothing here", so a selector that
+ * binds only command channels writes `null` in the transport four and nothing
+ * is ambiguous. `InputBinding` on the contract side is a union instead, because
+ * a request-shape channel's "declared, no keys" state is not the same as
+ * unused and the two spellings had to stay apart.
+ */
+export declare const ProbeInputBinding: z.ZodObject<{
+    path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+/**
+ * AD-39's selector grammar, duplicated on the corpus side, minus the two
+ * members a corpus cannot fill. The operation is the signature's own home
+ * operation and is not repeated here; the temporal clause is dropped because no
+ * corpus signature needs it. A state-corruption defect that only fires on a
+ * second call is already expressible as a predicate over any single
+ * observation, and AD-40's mapping is per probe rather than per call sequence.
+ * What would reopen the question is pair-defect signatures across the monotonic
+ * observation sequence, a future need `preflight/witness-evidence.ts` already
+ * records.
+ */
+export declare const ProbeStepSelector: z.ZodObject<{
+    inputBinding: z.ZodObject<{
+        path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * AD-40's discriminating condition: a selector over observations paired with a
+ * predicate over the selected observation's response.
+ *
+ * The predicate is the shipped `Expression` in AD-4's closed operator
+ * vocabulary, never a second relation language. A second vocabulary is a second
+ * set of degenerate cases to fix, and AD-4's are already fixed and fixtured.
+ * Every pointer in the predicate is rooted at `OBSERVED_STEP_ID`; that rule,
+ * the response-channel rule, and AD-4's own legality rules are checked at
+ * corpus qualification time rather than here, because each of them is a
+ * cross-field or cross-artifact rule the published export cannot carry.
+ */
+export declare const DiscriminatingCondition: z.ZodObject<{
+    selector: z.ZodObject<{
+        inputBinding: z.ZodObject<{
+            path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+}, z.core.$strict>;
+/**
+ * A signature against an interface that speaks HTTP. `web` and `mcp` share the
+ * shape and are still rejected by the qualification gate, which is what keeps
+ * `signature-interface-kind-unsupported` fireable on the kinds whose probe
+ * semantics are undeclared.
+ *
+ * One branch over the three kinds rather than three identical branches. Three
+ * would publish three byte-identical subschemas, and AD-13's mutation sweep
+ * cannot attribute a keyword deletion to one of several identical branches:
+ * deleting `pathTemplate`'s pattern from the second still leaves the first
+ * accepting everything the corpus carries, so nothing flips.
+ */
+export declare const ApiDefectSignature: z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodEnum<{
+        api: "api";
+        mcp: "mcp";
+        web: "web";
+    }>;
+    method: z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+        PATCH: "PATCH";
+        POST: "POST";
+        PUT: "PUT";
+    }>;
+    pathTemplate: z.ZodString;
+}, z.core.$strict>;
+/**
+ * A signature against an interface that runs behind a command. It declares the
+ * transport identity a command operation declares, for the reason AD-40 gives
+ * for method and path template: the identity has to be contract-independent so
+ * a signature authored against a corpus binds a second contract's operation.
+ * An operation identifier is contract-local and would bind nothing.
+ */
+export declare const CommandDefectSignature: z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodLiteral<"cli">;
+    invocation: z.ZodObject<{
+        executable: z.ZodString;
+        subcommandPath: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * A plain union rather than a discriminated one: the discriminator would have
+ * to be `interfaceKind`, and the api-shaped branch carries three values for it.
+ * The two branches are told apart by the identity they declare, exactly as
+ * `InputBinding`'s two are told apart by the channels they name.
+ */
+export declare const DefectSignature: z.ZodUnion<readonly [z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodEnum<{
+        api: "api";
+        mcp: "mcp";
+        web: "web";
+    }>;
+    method: z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+        PATCH: "PATCH";
+        POST: "POST";
+        PUT: "PUT";
+    }>;
+    pathTemplate: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    observableChannel: z.ZodEnum<{
+        artifact: "artifact";
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+    condition: z.ZodObject<{
+        selector: z.ZodObject<{
+            inputBinding: z.ZodObject<{
+                path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+                stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                    literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    matcher: z.ZodEnum<{
+                        any: "any";
+                        "type-violating": "type-violating";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        predicate: z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>;
+    }, z.core.$strict>;
+    interfaceKind: z.ZodLiteral<"cli">;
+    invocation: z.ZodObject<{
+        executable: z.ZodString;
+        subcommandPath: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type ApiDefectSignature = z.infer<typeof ApiDefectSignature>;
+export type CommandDefectSignature = z.infer<typeof CommandDefectSignature>;
+export type DefectSignature = z.infer<typeof DefectSignature>;
+export type ProbeInputBinding = z.infer<typeof ProbeInputBinding>;