eval-quality 0.1.0

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

@@ -0,0 +1,417 @@
+/** permitted interfaces and the per-operation declaration inventory. */
+import { z } from 'zod';
+/** AD-19's closed four-member set, declared per pointer the descriptor names. */
+export declare const ChannelRole: z.ZodEnum<{
+    collection: "collection";
+    diagnostic: "diagnostic";
+    payload: "payload";
+    "success-indicator": "success-indicator";
+}>;
+/**
+ * AD-19's closed mode set. `page-bounded` is what makes AD-20 rule 6's
+ * injection form the required satisfaction and its bijection form an error,
+ * rather than a coin toss between two forms with opposite outcomes.
+ */
+export declare const 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">;
+export declare const CollectionLocation: 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>;
+/**
+ * AD-19's closed response descriptor, scoped per operation rather than per
+ * interface: an interface-wide union is vacuous in the ordinary multi-shape
+ * case, since a job resource, a page of rows, and an error share no required
+ * key, leaving rule 2 no truthful denominator.
+ */
+export declare const 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>;
+/**
+ * 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
+ * member at parse time, and `z.partialRecord` accepts the partial only by
+ * reintroducing the omitted-key spelling the Consistency Conventions ban.
+ *
+ * Each channel is a declared triple rather than nullable: a request channel's
+ * "declared, no keys" state already has a spelling (an empty required list,
+ * an empty permitted list, an empty type map), unlike an input-binding
+ * channel, where that state is indistinguishable from unused.
+ */
+export declare const 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>;
+/** AD-19's closed seven, uppercase; AD-40 compares against them. */
+export declare const HttpMethod: z.ZodEnum<{
+    DELETE: "DELETE";
+    GET: "GET";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+    PATCH: "PATCH";
+    POST: "POST";
+    PUT: "PUT";
+}>;
+export declare const PATH_TEMPLATE_PATTERN: RegExp;
+export declare const PathTemplate: z.ZodString;
+export declare const Operation: 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<{
+            body: "body";
+            path: "path";
+            query: "query";
+        }>;
+        legs: z.ZodArray<z.ZodObject<{
+            legId: z.ZodString;
+            inputs: 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.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-19's four interface kinds, exported once so nothing else respells them:
+ * the sealed evaluator brief carries interface identity without the operation
+ * inventory (AD-16) and needs this vocabulary. Naming the array changes no
+ * exported byte, since an enum with no `.meta({ id })` inlines at each use
+ * site exactly as the literal did.
+ */
+export declare const INTERFACE_KINDS: readonly ['api', 'web', 'cli', 'mcp'];
+export declare const InterfaceKind: z.ZodEnum<{
+    api: "api";
+    cli: "cli";
+    mcp: "mcp";
+    web: "web";
+}>;
+export declare const PermittedInterface: z.ZodObject<{
+    logicalId: z.ZodString;
+    kind: z.ZodEnum<{
+        api: "api";
+        cli: "cli";
+        mcp: "mcp";
+        web: "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<{
+                body: "body";
+                path: "path";
+                query: "query";
+            }>;
+            legs: z.ZodArray<z.ZodObject<{
+                legId: z.ZodString;
+                inputs: 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.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>;

package/dist/core/schemas/interface.js

@@ -0,0 +1,115 @@
+/** permitted interfaces and the per-operation declaration inventory. */
+import { z } from 'zod';
+import { DescriptorPointer } from './pointer.js';
+import { Identifier, KeyedShapeDescriptor, KeyName, KeyTypeMap, } from './primitives.js';
+import { SensitivityWitness } from './sensitivity-witness.js';
+/** AD-19's closed four-member set, declared per pointer the descriptor names. */
+export const ChannelRole = z.enum([
+    'success-indicator',
+    'diagnostic',
+    'payload',
+    'collection',
+]);
+/**
+ * AD-19's closed mode set. `page-bounded` is what makes AD-20 rule 6's
+ * injection form the required satisfaction and its bijection form an error,
+ * rather than a coin toss between two forms with opposite outcomes.
+ */
+export const ExpectedCardinality = z.discriminatedUnion('mode', [
+    z.strictObject({ mode: z.literal('exact'), count: z.int().min(0) }),
+    z.strictObject({ mode: z.literal('at-most'), max: z.int().min(0) }),
+    z.strictObject({ mode: z.literal('page-bounded'), max: z.int().min(0) }),
+]);
+export const CollectionLocation = z.strictObject({
+    pointer: DescriptorPointer,
+    expectedCardinality: ExpectedCardinality,
+    referenceSet: Identifier.nullable().describe('AD-20 rule 6 is relevant when a declared collection location names a reference set, so `null` is the shape that makes the rule irrelevant and must stay representable.'),
+});
+/**
+ * AD-19's closed response descriptor, scoped per operation rather than per
+ * interface: an interface-wide union is vacuous in the ordinary multi-shape
+ * case, since a job resource, a page of rows, and an error share no required
+ * key, leaving rule 2 no truthful denominator.
+ */
+export const ResponseDescriptor = z.strictObject({
+    requiredKeys: z
+        .array(KeyName)
+        .describe('No minimum of two anywhere in this shape: AD-20 rule 2 relevance is "the descriptor declares more than one pointer", so a one-pointer descriptor must parse in order to be the irrelevant case.'),
+    permittedKeys: z.array(KeyName),
+    types: KeyTypeMap.describe('Caller-keyed by plain key name, never by pointer: this is the shape where that trap bites, since `requiredKeys` sits beside a pointer-keyed `channelRoles` and a pointer-valued `successIndicator`, and the descriptor-relative spelling must not be extended here by analogy. A missing key means "not declared"; an explicit `null` value means "declared, type not stated", which is AD-31\'s enumerated indeterminate descriptor state and the shape `quantifier-over-non-collection` reads.'),
+    successIndicator: DescriptorPointer.nullable().describe('AD-20 rule 1 relevance reads this as its first conjunct, so `null` must stay representable.'),
+    channelRoles: z
+        .record(DescriptorPointer, ChannelRole)
+        .nullable()
+        .describe('Caller-keyed, and expected to be partial: a missing key means "no role declared for that pointer". AD-31 grades absent and explicitly empty differently, so `null`, `{}`, and a populated map are three distinct answers. Deliberately not refined to require a role for every descriptor key: no AD-5 code names that rule, the AD-31 predicates degrade gracefully on partial roles, and a refinement buys nothing an export can carry.'),
+    collectionLocations: z
+        .array(CollectionLocation)
+        .nullable()
+        .describe('AD-20 rule 4 relevance reads this, and AD-31 grades an absent declaration and an explicit empty one differently, so `null` and `[]` are distinct answers.'),
+});
+/**
+ * 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
+ * member at parse time, and `z.partialRecord` accepts the partial only by
+ * reintroducing the omitted-key spelling the Consistency Conventions ban.
+ *
+ * Each channel is a declared triple rather than nullable: a request channel's
+ * "declared, no keys" state already has a spelling (an empty required list,
+ * an empty permitted list, an empty type map), unlike an input-binding
+ * channel, where that state is indistinguishable from unused.
+ */
+export const RequestShape = z.strictObject({
+    path: KeyedShapeDescriptor,
+    query: KeyedShapeDescriptor,
+    header: KeyedShapeDescriptor.describe('AD-18: a header channel declaration names a header and its type and never carries a credential value.'),
+    body: KeyedShapeDescriptor,
+});
+/** AD-19's closed seven, uppercase; AD-40 compares against them. */
+export const HttpMethod = z.enum([
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'OPTIONS',
+]);
+// AD-19: parameters are spelled `{name}` in braces only, because AD-40
+// compares templates as literal segments plus parameter positions, and two
+// implementations must not disagree over whether `/notes/{id}` and
+// `/notes/:id` are one template. A colon is excluded from a literal segment,
+// so `:name` is a syntax error rather than a segment that merely starts with
+// one.
+export const PATH_TEMPLATE_PATTERN = /^(?:\/(?:[^/{}:]|\{[A-Za-z0-9_-]+\})*)+$/;
+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({
+    operationId: Identifier,
+    method: HttpMethod,
+    pathTemplate: PathTemplate,
+    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: RequestShape,
+    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.'),
+});
+/**
+ * AD-19's four interface kinds, exported once so nothing else respells them:
+ * the sealed evaluator brief carries interface identity without the operation
+ * inventory (AD-16) and needs this vocabulary. Naming the array changes no
+ * exported byte, since an enum with no `.meta({ id })` inlines at each use
+ * site exactly as the literal did.
+ */
+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.'),
+});

package/dist/core/schemas/isolation-manifest.d.ts

@@ -0,0 +1,136 @@
+/** the per-run isolation audit, and the forbidden-input accounting AD-16 adds. */
+import { z } from 'zod';
+/**
+ * The harness's record of what it actually enforced, deliberately not
+ * `Budgets`: `Budgets` is the contract's three-key declared ceiling that AD-16
+ * puts on the brief so the caller knows what it may spend, while this carries
+ * the two token counts the contract never declares. One shape for both would
+ * conflate a declaration with an observation.
+ */
+export declare const ResourceCeilings: z.ZodObject<{
+    maxToolCalls: z.ZodInt;
+    maxInputTokens: z.ZodInt;
+    maxOutputTokens: z.ZodInt;
+    maxWallClockMinutes: z.ZodNumber;
+    maxCostUsd: z.ZodString;
+}, z.core.$strict>;
+/** the prior art's five-member actual-use record, with money as a string. */
+export declare const ActualResourceUse: z.ZodObject<{
+    toolCalls: z.ZodInt;
+    inputTokens: z.ZodInt;
+    outputTokens: z.ZodInt;
+    wallClockSeconds: z.ZodNumber;
+    costUsd: z.ZodString;
+}, z.core.$strict>;
+/**
+ * AD-16 requires the manifest to "account for each forbidden input by name".
+ * `withheld: false` must parse: a prohibited input is an invalidating condition
+ * at ingest, never a parse failure.
+ */
+export declare const ForbiddenInputAccounting: z.ZodObject<{
+    withheld: z.ZodBoolean;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A strict object rather than `z.record(ForbiddenInput, …)`: the record does
+ * demand every enum member at parse time, but only as TypeScript behaviour.
+ * Its export carries `propertyNames` plus a schema-valued
+ * `additionalProperties` but never a `required` array, so the constraint
+ * would be invisible to the non-TypeScript consumer AD-13 protects, the same
+ * reasoning behind `RequestShape`'s four-key object.
+ */
+export declare const ForbiddenInputAccountingMap: z.ZodObject<{
+    "builder-transcript": z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    "comparator-results": z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    "human-labels": z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    "implementation-logs": z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    "original-spec": z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    repository: z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    "source-code": z.ZodObject<{
+        withheld: z.ZodBoolean;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const IsolationManifest: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    runId: z.ZodString;
+    contractId: z.ZodString;
+    conditionArm: z.ZodString;
+    modelSnapshot: z.ZodString;
+    systemPromptDigest: z.ZodString;
+    contractDigest: z.ZodString;
+    evaluatorConfigurationDigest: z.ZodString;
+    workspaceIdentity: z.ZodString;
+    allowedMounts: z.ZodArray<z.ZodString>;
+    observedMounts: z.ZodArray<z.ZodString>;
+    networkAllowlist: z.ZodArray<z.ZodString>;
+    observedNetworkTargets: z.ZodArray<z.ZodString>;
+    toolAllowlist: z.ZodArray<z.ZodString>;
+    observedToolCalls: z.ZodArray<z.ZodString>;
+    resourceCeilings: z.ZodObject<{
+        maxToolCalls: z.ZodInt;
+        maxInputTokens: z.ZodInt;
+        maxOutputTokens: z.ZodInt;
+        maxWallClockMinutes: z.ZodNumber;
+        maxCostUsd: z.ZodString;
+    }, z.core.$strict>;
+    actualResourceUse: z.ZodObject<{
+        toolCalls: z.ZodInt;
+        inputTokens: z.ZodInt;
+        outputTokens: z.ZodInt;
+        wallClockSeconds: z.ZodNumber;
+        costUsd: z.ZodString;
+    }, z.core.$strict>;
+    forbiddenInputAccounting: z.ZodObject<{
+        "builder-transcript": z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        "comparator-results": z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        "human-labels": z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        "implementation-logs": z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        "original-spec": z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        repository: z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        "source-code": z.ZodObject<{
+            withheld: z.ZodBoolean;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    violation: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type IsolationManifest = z.infer<typeof IsolationManifest>;