eval-quality 0.2.0 → 0.3.0

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

@@ -75,6 +75,7 @@ export declare const ResponseDescriptor: z.ZodObject<{
         referenceSet: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
+export type ResponseDescriptor = z.infer<typeof ResponseDescriptor>;
 /**
  * AD-19's four transport channels, spelled as a four-key strict object rather
  * than a record over a channel enum: a record over an enum key demands every
@@ -248,13 +249,17 @@ export declare const Operation: z.ZodObject<{
     sensitivityWitness: z.ZodNullable<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>;
@@ -264,12 +269,282 @@ export declare const Operation: 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<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type Operation = z.infer<typeof Operation>;
+/**
+ * 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 declare const CommandInvocation: z.ZodObject<{
+    executable: z.ZodString;
+    subcommandPath: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type CommandInvocation = z.infer<typeof CommandInvocation>;
+/**
+ * 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 declare const CommandRequestShape: z.ZodObject<{
+    argument: z.ZodObject<{
+        requiredKeys: z.ZodArray<z.ZodString>;
+        permittedKeys: z.ZodArray<z.ZodString>;
+        types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+            array: "array";
+            boolean: "boolean";
+            null: "null";
+            number: "number";
+            object: "object";
+            string: "string";
+        }>>>;
+    }, z.core.$strict>;
+    option: z.ZodObject<{
+        requiredKeys: z.ZodArray<z.ZodString>;
+        permittedKeys: z.ZodArray<z.ZodString>;
+        types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+            array: "array";
+            boolean: "boolean";
+            null: "null";
+            number: "number";
+            object: "object";
+            string: "string";
+        }>>>;
+    }, z.core.$strict>;
+    environment: z.ZodObject<{
+        requiredKeys: z.ZodArray<z.ZodString>;
+        permittedKeys: z.ZodArray<z.ZodString>;
+        types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+            array: "array";
+            boolean: "boolean";
+            null: "null";
+            number: "number";
+            object: "object";
+            string: "string";
+        }>>>;
+    }, z.core.$strict>;
+    stdin: z.ZodObject<{
+        requiredKeys: z.ZodArray<z.ZodString>;
+        permittedKeys: z.ZodArray<z.ZodString>;
+        types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+            array: "array";
+            boolean: "boolean";
+            null: "null";
+            number: "number";
+            object: "object";
+            string: "string";
+        }>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CommandRequestShape = z.infer<typeof CommandRequestShape>;
+/**
+ * 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 declare const CommandDescriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"stream">;
+    channel: z.ZodEnum<{
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"artifact">;
+    artifactId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type CommandDescriptorChannel = z.infer<typeof CommandDescriptorChannel>;
+/**
+ * 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 declare const CommandOperation: z.ZodObject<{
+    operationId: z.ZodString;
+    invocation: z.ZodObject<{
+        executable: z.ZodString;
+        subcommandPath: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    stateChangeMarker: z.ZodBoolean;
+    requestShape: z.ZodObject<{
+        argument: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+        }, z.core.$strict>;
+        option: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+        }, z.core.$strict>;
+        stdin: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    artifacts: z.ZodArray<z.ZodString>;
+    descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"stream">;
+        channel: z.ZodEnum<{
+            stderr: "stderr";
+            stdout: "stdout";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"artifact">;
+        artifactId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    responseDescriptor: z.ZodObject<{
+        requiredKeys: z.ZodArray<z.ZodString>;
+        permittedKeys: z.ZodArray<z.ZodString>;
+        types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+            array: "array";
+            boolean: "boolean";
+            null: "null";
+            number: "number";
+            object: "object";
+            string: "string";
+        }>>>;
+        successIndicator: z.ZodNullable<z.ZodString>;
+        channelRoles: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            collection: "collection";
+            diagnostic: "diagnostic";
+            payload: "payload";
+            "success-indicator": "success-indicator";
+        }>>>;
+        collectionLocations: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            pointer: z.ZodString;
+            expectedCardinality: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"exact">;
+                count: z.ZodInt;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"at-most">;
+                max: z.ZodInt;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"page-bounded">;
+                max: z.ZodInt;
+            }, z.core.$strict>], "mode">;
+            referenceSet: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    volatilePointers: z.ZodArray<z.ZodString>;
+    sensitivityWitness: z.ZodNullable<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.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>]>;
+        }, z.core.$strict>>;
+        relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CommandOperation = z.infer<typeof CommandOperation>;
+/** Either operation shape, for the consumers that read only kind-neutral fields. */
+export type AnyOperation = Operation | CommandOperation;
 /**
  * AD-19's four interface kinds, exported once so nothing else respells them:
  * the sealed evaluator brief carries interface identity without the operation
@@ -278,20 +553,21 @@ export type Operation = z.infer<typeof Operation>;
  * site exactly as the literal did.
  */
 export declare const INTERFACE_KINDS: readonly ['api', 'web', 'cli', 'mcp'];
+export type InterfaceKindName = (typeof INTERFACE_KINDS)[number];
 export declare const InterfaceKind: z.ZodEnum<{
     api: "api";
     cli: "cli";
     mcp: "mcp";
     web: "web";
 }>;
-export declare const PermittedInterface: z.ZodObject<{
+/**
+ * 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 declare const PermittedInterface: z.ZodDiscriminatedUnion<[z.ZodObject<{
     logicalId: z.ZodString;
-    kind: z.ZodEnum<{
-        api: "api";
-        cli: "cli";
-        mcp: "mcp";
-        web: "web";
-    }>;
+    kind: z.ZodLiteral<"api">;
     operations: z.ZodArray<z.ZodObject<{
         operationId: z.ZodString;
         method: z.ZodEnum<{
@@ -392,13 +668,17 @@ export declare const PermittedInterface: z.ZodObject<{
         sensitivityWitness: z.ZodNullable<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>;
@@ -408,10 +688,458 @@ export declare const PermittedInterface: 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<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-}, z.core.$strict>;
-export type PermittedInterface = z.infer<typeof PermittedInterface>;
+}, z.core.$strict>, z.ZodObject<{
+    logicalId: z.ZodString;
+    kind: z.ZodLiteral<"web">;
+    operations: z.ZodArray<z.ZodObject<{
+        operationId: z.ZodString;
+        method: z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            HEAD: "HEAD";
+            OPTIONS: "OPTIONS";
+            PATCH: "PATCH";
+            POST: "POST";
+            PUT: "PUT";
+        }>;
+        pathTemplate: z.ZodString;
+        stateChangeMarker: z.ZodBoolean;
+        requestShape: z.ZodObject<{
+            path: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            query: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            header: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            body: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        responseDescriptor: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+            successIndicator: z.ZodNullable<z.ZodString>;
+            channelRoles: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                collection: "collection";
+                diagnostic: "diagnostic";
+                payload: "payload";
+                "success-indicator": "success-indicator";
+            }>>>;
+            collectionLocations: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                pointer: z.ZodString;
+                expectedCardinality: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"exact">;
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"at-most">;
+                    max: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"page-bounded">;
+                    max: z.ZodInt;
+                }, z.core.$strict>], "mode">;
+                referenceSet: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        volatilePointers: z.ZodArray<z.ZodString>;
+        sensitivityWitness: z.ZodNullable<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.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>]>;
+            }, z.core.$strict>>;
+            relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    logicalId: z.ZodString;
+    kind: z.ZodLiteral<"mcp">;
+    operations: z.ZodArray<z.ZodObject<{
+        operationId: z.ZodString;
+        method: z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            HEAD: "HEAD";
+            OPTIONS: "OPTIONS";
+            PATCH: "PATCH";
+            POST: "POST";
+            PUT: "PUT";
+        }>;
+        pathTemplate: z.ZodString;
+        stateChangeMarker: z.ZodBoolean;
+        requestShape: z.ZodObject<{
+            path: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            query: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            header: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            body: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        responseDescriptor: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+            successIndicator: z.ZodNullable<z.ZodString>;
+            channelRoles: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                collection: "collection";
+                diagnostic: "diagnostic";
+                payload: "payload";
+                "success-indicator": "success-indicator";
+            }>>>;
+            collectionLocations: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                pointer: z.ZodString;
+                expectedCardinality: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"exact">;
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"at-most">;
+                    max: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"page-bounded">;
+                    max: z.ZodInt;
+                }, z.core.$strict>], "mode">;
+                referenceSet: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        volatilePointers: z.ZodArray<z.ZodString>;
+        sensitivityWitness: z.ZodNullable<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.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>]>;
+            }, z.core.$strict>>;
+            relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    logicalId: z.ZodString;
+    kind: z.ZodLiteral<"cli">;
+    operations: z.ZodArray<z.ZodObject<{
+        operationId: z.ZodString;
+        invocation: z.ZodObject<{
+            executable: z.ZodString;
+            subcommandPath: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        stateChangeMarker: z.ZodBoolean;
+        requestShape: z.ZodObject<{
+            argument: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            option: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            environment: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+            stdin: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        artifacts: z.ZodArray<z.ZodString>;
+        descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"stream">;
+            channel: z.ZodEnum<{
+                stderr: "stderr";
+                stdout: "stdout";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"artifact">;
+            artifactId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        responseDescriptor: z.ZodObject<{
+            requiredKeys: z.ZodArray<z.ZodString>;
+            permittedKeys: z.ZodArray<z.ZodString>;
+            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+            }>>>;
+            successIndicator: z.ZodNullable<z.ZodString>;
+            channelRoles: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                collection: "collection";
+                diagnostic: "diagnostic";
+                payload: "payload";
+                "success-indicator": "success-indicator";
+            }>>>;
+            collectionLocations: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                pointer: z.ZodString;
+                expectedCardinality: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"exact">;
+                    count: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"at-most">;
+                    max: z.ZodInt;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"page-bounded">;
+                    max: z.ZodInt;
+                }, z.core.$strict>], "mode">;
+                referenceSet: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        volatilePointers: z.ZodArray<z.ZodString>;
+        sensitivityWitness: z.ZodNullable<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.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>]>;
+            }, z.core.$strict>>;
+            relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+export type PermittedInterface = z.infer<typeof PermittedInterface>;
+/**
+ * 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 declare const operationsOf: (iface: PermittedInterface) => readonly AnyOperation[];