eval-quality 0.1.0

package/dist/core/schemas/port-messages.d.ts

@@ -0,0 +1,103 @@
+/** the request and response shape of every AD-28 port method. */
+import { z } from 'zod';
+import { JsonValue } from './primitives.ts';
+export { ProbeObservedBody, ProbeRequestBody } from './probe-body.ts';
+export declare const CorpusResolveRequest: z.ZodObject<{
+    privateRef: z.ZodString;
+}, z.core.$strict>;
+export declare const CorpusResolveResponse: z.ZodObject<{
+    privateRef: z.ZodString;
+    bytes: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+}, z.core.$strict>;
+export declare const ClockReadRequest: z.ZodObject<{}, z.core.$strict>;
+export declare const ClockReadResponse: z.ZodObject<{
+    now: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const FileReadRequest: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+export declare const FileReadResponse: z.ZodObject<{
+    path: z.ZodString;
+    bytes: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+}, z.core.$strict>;
+export declare const FileWriteRequest: z.ZodObject<{
+    path: z.ZodString;
+    bytes: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+}, z.core.$strict>;
+export declare const FileWriteResponse: z.ZodObject<{
+    path: z.ZodString;
+    byteLength: z.ZodInt;
+}, z.core.$strict>;
+/**
+ * AD-35: the request names a logical interface identifier and never a URL,
+ * host, or port. Mapping the identifier to an authorized target is the
+ * adapter's, from configuration outside the contract.
+ *
+ * No credential appears here. AD-18 forbids a credential value in a
+ * declaration, and the values that reach this shape come from a declaration;
+ * authorization material is the adapter's, supplied by the same mapping that
+ * authorizes the target.
+ */
+export declare const ProbeRequest: z.ZodObject<{
+    probeId: z.ZodString;
+    interfaceId: z.ZodString;
+    operationId: z.ZodString;
+    method: z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+        PATCH: "PATCH";
+        POST: "POST";
+        PUT: "PUT";
+    }>;
+    pathTemplate: z.ZodString;
+    channels: z.ZodObject<{
+        path: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        query: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        header: z.ZodRecord<z.ZodString, z.ZodString>;
+        body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"json">;
+            value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"absent">;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * What the adapter observed. Deliberately response content only: no elapsed
+ * time, no redirect count, no retry count. AD-35's caps are safety limits, so
+ * exceeding one throws a `budget-exhausted` fault and never lands as a field
+ * on a successful observation. AD-10's verdict stays a function of what the
+ * system returned, with no input from how long the network took.
+ *
+ * Every response the system returns is an observation, at any status. Only a
+ * policy denial, a cap, an abort, or a transport failure throws; a 500 is the
+ * payload AD-10's seeded-fault check reads, never an error.
+ */
+export declare const ProbeObservation: z.ZodObject<{
+    probeId: z.ZodString;
+    interfaceId: z.ZodString;
+    operationId: z.ZodString;
+    status: z.ZodInt;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        value: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type CorpusResolveRequest = z.infer<typeof CorpusResolveRequest>;
+export type CorpusResolveResponse = z.infer<typeof CorpusResolveResponse>;
+export type ClockReadRequest = z.infer<typeof ClockReadRequest>;
+export type ClockReadResponse = z.infer<typeof ClockReadResponse>;
+export type FileReadRequest = z.infer<typeof FileReadRequest>;
+export type FileReadResponse = z.infer<typeof FileReadResponse>;
+export type FileWriteRequest = z.infer<typeof FileWriteRequest>;
+export type FileWriteResponse = z.infer<typeof FileWriteResponse>;
+export type ProbeRequest = z.infer<typeof ProbeRequest>;
+export type ProbeObservation = z.infer<typeof ProbeObservation>;

package/dist/core/schemas/port-messages.js

@@ -0,0 +1,90 @@
+/** the request and response shape of every AD-28 port method. */
+import { z } from 'zod';
+import { HttpMethod, PathTemplate } from './interface.js';
+import { Identifier, JsonValue, KeyName, Rfc3339Utc } from './primitives.js';
+import { ProbeObservedBody, ProbeRequestBody } from './probe-body.js';
+export { ProbeObservedBody, ProbeRequestBody } from './probe-body.js';
+// AD-8: the corpus port resolves an opaque reference to bytes from a
+// caller-owned location. It does not check the digest: AD-8 puts digest
+// recomputation in the core ("the core recomputes every per-artifact digest
+// from the resolved bytes"), and an adapter that checked it would be trusting
+// the manifest label AD-8 says is never trusted.
+export const CorpusResolveRequest = z.strictObject({
+    privateRef: z.string().min(1),
+});
+export const CorpusResolveResponse = z.strictObject({
+    privateRef: z
+        .string()
+        .min(1)
+        .describe('Echoed back so a response cannot be silently bound to a different request. Nothing else in the response identifies what was resolved, and bytes carry no self-identity.'),
+    bytes: z.instanceof(Uint8Array),
+});
+// AD-1 forbids a clock read under `core/`, so a timestamp arrives through a
+// port. The request is an empty strict object: every `PortMethod` takes a
+// request and `invokePort` parses it, so a port with nothing to ask still
+// needs a shape that parses.
+export const ClockReadRequest = z.strictObject({});
+export const ClockReadResponse = z.strictObject({
+    now: Rfc3339Utc,
+});
+export const FileReadRequest = z.strictObject({
+    path: z.string().min(1),
+});
+export const FileReadResponse = z.strictObject({
+    path: z.string().min(1),
+    bytes: z.instanceof(Uint8Array),
+});
+export const FileWriteRequest = z.strictObject({
+    path: z.string().min(1),
+    bytes: z.instanceof(Uint8Array),
+});
+export const FileWriteResponse = z.strictObject({
+    path: z.string().min(1),
+    byteLength: z.int().min(0),
+});
+/**
+ * AD-35: the request names a logical interface identifier and never a URL,
+ * host, or port. Mapping the identifier to an authorized target is the
+ * adapter's, from configuration outside the contract.
+ *
+ * No credential appears here. AD-18 forbids a credential value in a
+ * declaration, and the values that reach this shape come from a declaration;
+ * authorization material is the adapter's, supplied by the same mapping that
+ * authorizes the target.
+ */
+export const ProbeRequest = z.strictObject({
+    probeId: Identifier.describe('An opaque correlation label minted by the pre-flight plan and echoed unchanged on the observation. Two witnesses of one operation, and the three observations a state-reset differential needs, are otherwise distinguishable only by array position, which NFR9 forbids any stage from reading.'),
+    interfaceId: Identifier,
+    operationId: Identifier,
+    method: HttpMethod,
+    pathTemplate: PathTemplate,
+    channels: z.strictObject({
+        path: z.record(KeyName, JsonValue),
+        query: z.record(KeyName, JsonValue),
+        header: z
+            .record(KeyName, z.string())
+            .describe('String-valued because a header value is a string on the wire; the other channels carry the declared JSON value.'),
+        body: ProbeRequestBody,
+    }),
+});
+/**
+ * What the adapter observed. Deliberately response content only: no elapsed
+ * time, no redirect count, no retry count. AD-35's caps are safety limits, so
+ * exceeding one throws a `budget-exhausted` fault and never lands as a field
+ * on a successful observation. AD-10's verdict stays a function of what the
+ * system returned, with no input from how long the network took.
+ *
+ * Every response the system returns is an observation, at any status. Only a
+ * policy denial, a cap, an abort, or a transport failure throws; a 500 is the
+ * payload AD-10's seeded-fault check reads, never an error.
+ */
+export const ProbeObservation = z.strictObject({
+    probeId: Identifier,
+    interfaceId: Identifier,
+    operationId: Identifier,
+    status: z.int().min(100).max(599),
+    headers: z
+        .record(KeyName, z.string())
+        .describe('Repeated headers are joined with ", " per RFC 9110 before they reach this shape. `set-cookie` is the one header that rule is wrong for, and it is dropped rather than mangled: nothing in AD-10 reads it, and a joined `set-cookie` is a value no consumer can split back.'),
+    body: ProbeObservedBody,
+});

package/dist/core/schemas/preflight-verdict.d.ts

@@ -0,0 +1,60 @@
+/** the pure verdict AD-10 computes over probed environment observations. */
+import { z } from 'zod';
+/**
+ * Transcribed from AD-10's own prose, which bounds the verdict to a closed,
+ * named list of checks; a member it does not name would be this schema
+ * minting pre-flight semantics it has no authority over.
+ */
+export declare const PREFLIGHT_CHECK_KINDS: readonly ['interface-present', 'input-sensitivity', 'state-reset', 'clean-control', 'seeded-faults-scoped', 'seeded-fault-fired'];
+export declare const PreflightCheckKind: z.ZodEnum<{
+    "clean-control": "clean-control";
+    "input-sensitivity": "input-sensitivity";
+    "interface-present": "interface-present";
+    "seeded-fault-fired": "seeded-fault-fired";
+    "seeded-faults-scoped": "seeded-faults-scoped";
+    "state-reset": "state-reset";
+}>;
+export declare const PreflightCheck: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "clean-control": "clean-control";
+        "input-sensitivity": "input-sensitivity";
+        "interface-present": "interface-present";
+        "seeded-fault-fired": "seeded-fault-fired";
+        "seeded-faults-scoped": "seeded-faults-scoped";
+        "state-reset": "state-reset";
+    }>;
+    operationId: z.ZodNullable<z.ZodString>;
+    outcome: z.ZodEnum<{
+        exempt: "exempt";
+        failed: "failed";
+        satisfied: "satisfied";
+    }>;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type PreflightCheck = z.infer<typeof PreflightCheck>;
+export declare const PreflightVerdict: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    runId: z.ZodString;
+    fixtureDigest: z.ZodString;
+    passed: z.ZodBoolean;
+    checks: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "clean-control": "clean-control";
+            "input-sensitivity": "input-sensitivity";
+            "interface-present": "interface-present";
+            "seeded-fault-fired": "seeded-fault-fired";
+            "seeded-faults-scoped": "seeded-faults-scoped";
+            "state-reset": "state-reset";
+        }>;
+        operationId: z.ZodNullable<z.ZodString>;
+        outcome: z.ZodEnum<{
+            exempt: "exempt";
+            failed: "failed";
+            satisfied: "satisfied";
+        }>;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PreflightVerdict = z.infer<typeof PreflightVerdict>;

package/dist/core/schemas/preflight-verdict.js

@@ -0,0 +1,38 @@
+/** the pure verdict AD-10 computes over probed environment observations. */
+import { z } from 'zod';
+import { lineageFields } from './lineage.js';
+import { Digest, Identifier } from './primitives.js';
+/**
+ * Transcribed from AD-10's own prose, which bounds the verdict to a closed,
+ * named list of checks; a member it does not name would be this schema
+ * minting pre-flight semantics it has no authority over.
+ */
+export const PREFLIGHT_CHECK_KINDS = [
+    'interface-present',
+    'input-sensitivity',
+    'state-reset',
+    'clean-control',
+    'seeded-faults-scoped',
+    'seeded-fault-fired',
+];
+export const PreflightCheckKind = z.enum(PREFLIGHT_CHECK_KINDS);
+export const PreflightCheck = z.strictObject({
+    kind: PreflightCheckKind,
+    operationId: Identifier.nullable().describe('Nullable because AD-10 scopes input sensitivity and state reset per operation and interface presence per interface, so a check that is not per-operation has nothing to name here.'),
+    outcome: z
+        .enum(['satisfied', 'failed', 'exempt'])
+        .describe('`exempt` exists because AD-10 says "an operation declaring no inputs in any channel is exempt and records the exemption", and an exemption with no spelling is an exemption nobody records. That a failed pre-flight invalidates the run, and that a sensitivity witness resolving `insufficient-evidence` fails rather than passes, are AD-10 semantics for `core/preflight`; the schema carries the outcome and refines nothing.'),
+    note: z.string().nullable(),
+});
+export const PreflightVerdict = z
+    .strictObject({
+    ...lineageFields,
+    runId: z.string().min(1).describe('An opaque caller label.'),
+    fixtureDigest: Digest.describe("Required, not nullable. AD-10 makes the fixture digest a required field of the verdict, and AD-11 names it as one of the scoring version's five inputs, so an absent one leaves the scoring version uncomputable."),
+    passed: z.boolean(),
+    checks: z.array(PreflightCheck),
+})
+    .meta({
+    id: 'PreflightVerdict',
+    description: "The pre-flight verdict: a pure function of the observations the environment-probe port returned, with no prior art. AD-10 bounds it to a closed list of check kinds, all six transcribed from that AD's own prose, and requires the fixture digest as a required field. Probing a fixture is not executing the system under test, and a failed pre-flight invalidates the run rather than becoming a contract verdict.",
+});

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

@@ -0,0 +1,78 @@
+/** shared primitive shapes: identifiers, digests, dates, and the value container. */
+import { z } from 'zod';
+export declare const IDENTIFIER_PATTERN: RegExp;
+/** the charset spelling 1 embeds; exported so pointer.ts never re-spells it. */
+export declare const IDENTIFIER_CHARSET_SOURCE = "[a-z0-9]+(?:-[a-z0-9]+)*";
+export declare const Identifier: z.ZodString;
+export declare const BEHAVIOR_ID_PATTERN: RegExp;
+export declare const ORACLE_ID_PATTERN: RegExp;
+export declare const PROBE_ID_PATTERN: RegExp;
+export declare const WAIVER_ID_PATTERN: RegExp;
+export declare const DEFECT_ID_PATTERN: RegExp;
+export declare const FINDING_ID_PATTERN: RegExp;
+export declare const RUBRIC_ID_PATTERN: RegExp;
+export declare const RUBRIC_CRITERION_ID_PATTERN: RegExp;
+export declare const BehaviorId: z.ZodString;
+export declare const OracleId: z.ZodString;
+export declare const ProbeId: z.ZodString;
+export declare const WaiverId: z.ZodString;
+export declare const DefectId: z.ZodString;
+export declare const FindingId: z.ZodString;
+export declare const RubricId: z.ZodString;
+export declare const RubricCriterionId: z.ZodString;
+export declare const DIGEST_FORM: RegExp;
+export declare const Digest: z.ZodString;
+export declare const DECIMAL_STRING_PATTERN: RegExp;
+export declare const UNSIGNED_DECIMAL_STRING_PATTERN: RegExp;
+export declare const DecimalString: z.ZodString;
+export declare const UnsignedDecimalString: z.ZodString;
+export declare const POSITIVE_DECIMAL_STRING_PATTERN: RegExp;
+export declare const PositiveDecimalString: z.ZodString;
+export declare const Rfc3339Utc: z.ZodISODateTime;
+/** the six JSON type names a declaration may name a key's type as. */
+export declare const JsonTypeName: z.ZodEnum<{
+    array: "array";
+    boolean: "boolean";
+    null: "null";
+    number: "number";
+    object: "object";
+    string: "string";
+}>;
+export declare const KeyName: z.ZodString;
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const JsonValue: z.ZodType<JsonValue>;
+/**
+ * AD-4's `shape` descriptor and AD-19's request channel both need "required
+ * keys, permitted keys, and per-key JSON type, never an embedded JSON
+ * Schema"; spelled once here so two copies of one triple don't drift apart.
+ * `.describe()` returns a new schema rather than mutating this one, so each
+ * use site can add its own description.
+ */
+export declare const KeyTypeMap: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+    array: "array";
+    boolean: "boolean";
+    null: "null";
+    number: "number";
+    object: "object";
+    string: "string";
+}>>>;
+export declare const KeyedShapeDescriptor: 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>;
+export type KeyedShapeDescriptor = z.infer<typeof KeyedShapeDescriptor>;
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** a caller-keyed object inside the value container; not a control object. */
+export declare const JsonObjectValue: z.ZodType<JsonObject>;

package/dist/core/schemas/primitives.js

@@ -0,0 +1,121 @@
+/** shared primitive shapes: identifiers, digests, dates, and the value container. */
+import { z } from 'zod';
+// Fixed here rather than per field: pointer spelling 1 depends on this exact
+// charset, and a second copy per field is a drift risk. The kebab-slug shape
+// matches both hand-authored contracts though no AD requires it, so it is
+// ratified rather than invented.
+const IDENTIFIER_SOURCE = '[a-z0-9]+(?:-[a-z0-9]+)*';
+export const IDENTIFIER_PATTERN = new RegExp(`^${IDENTIFIER_SOURCE}$`);
+/** the charset spelling 1 embeds; exported so pointer.ts never re-spells it. */
+export const IDENTIFIER_CHARSET_SOURCE = IDENTIFIER_SOURCE;
+export const Identifier = z
+    .string()
+    .regex(IDENTIFIER_PATTERN)
+    .describe('A kebab-case slug. Excludes "/" and "~" so an identifier can be embedded in an interaction-rooted pointer without escaping.');
+// All eight Consistency-Conventions prefixes are defined here even though this
+// artifact uses five: the Probe, Evidence Artifact, and finding shapes import
+// P-, D-, and F- rather than re-spelling the quantifier, and a second spelling
+// of `{3,}` is exactly the drift the convention names.
+const prefixedIdentifier = (prefix) => new RegExp(`^${prefix}-[0-9]{3,}$`);
+export const BEHAVIOR_ID_PATTERN = prefixedIdentifier('B');
+export const ORACLE_ID_PATTERN = prefixedIdentifier('O');
+export const PROBE_ID_PATTERN = prefixedIdentifier('P');
+export const WAIVER_ID_PATTERN = prefixedIdentifier('W');
+export const DEFECT_ID_PATTERN = prefixedIdentifier('D');
+export const FINDING_ID_PATTERN = prefixedIdentifier('F');
+export const RUBRIC_ID_PATTERN = prefixedIdentifier('R');
+export const RUBRIC_CRITERION_ID_PATTERN = prefixedIdentifier('RC');
+export const BehaviorId = z.string().regex(BEHAVIOR_ID_PATTERN);
+export const OracleId = z.string().regex(ORACLE_ID_PATTERN);
+export const ProbeId = z.string().regex(PROBE_ID_PATTERN);
+export const WaiverId = z.string().regex(WAIVER_ID_PATTERN);
+export const DefectId = z.string().regex(DEFECT_ID_PATTERN);
+export const FindingId = z.string().regex(FINDING_ID_PATTERN);
+export const RubricId = z.string().regex(RUBRIC_ID_PATTERN);
+export const RubricCriterionId = z.string().regex(RUBRIC_CRITERION_ID_PATTERN);
+// AD-27's rendered digest form. It lives here rather than privately in
+// core/canonical/digest.ts so the schema and the digest functions share one
+// spelling, and core/ imports core/schemas rather than the reverse.
+export const DIGEST_FORM = /^sha256:[0-9a-f]{64}$/;
+export const Digest = z
+    .string()
+    .regex(DIGEST_FORM)
+    .describe('AD-27 digest: "sha256:" plus 64 lowercase hexadecimal characters.');
+// AD-36's declared format lives here rather than on the field: an undeclared
+// "declared format" is the same unshaped-declaration defect AD-19's value
+// spaces were added to close.
+export const DECIMAL_STRING_PATTERN = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+export const UNSIGNED_DECIMAL_STRING_PATTERN = /^(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+export const DecimalString = z
+    .string()
+    .regex(DECIMAL_STRING_PATTERN)
+    .describe('AD-36 decimal-string format: an optionally signed decimal with no exponent and no leading zeros, carried as a string so exact decimal semantics survive canonicalization.');
+export const UnsignedDecimalString = z
+    .string()
+    .regex(UNSIGNED_DECIMAL_STRING_PATTERN)
+    .describe('The decimal-string format restricted to non-negative values, for quantities where a negative has no meaning.');
+// Spelled as an alternation rather than a negative lookahead on purpose: JSON
+// Schema's `pattern` is ECMA-262 and would accept a lookahead, but several of
+// the non-JavaScript validators AD-13 also publishes this schema for compile
+// patterns with no lookahead support at all.
+export const POSITIVE_DECIMAL_STRING_PATTERN = /^([1-9][0-9]*(\.[0-9]+)?|0\.[0-9]*[1-9][0-9]*)$/;
+export const PositiveDecimalString = z
+    .string()
+    .regex(POSITIVE_DECIMAL_STRING_PATTERN)
+    .describe("The decimal-string format restricted to values greater than zero, for a ceiling where zero is not a ceiling. This is what carries the prior art's `exclusiveMinimum: 0` across AD-36's move of money from a JSON number to a string; without it that bound would be silently dropped by the retyping.");
+// Consistency Conventions: dates are RFC 3339 in UTC. z.iso.datetime() with no
+// options accepts a trailing "Z" and rejects a numeric offset, which is exactly
+// the convention; { offset: true } would accept both.
+export const Rfc3339Utc = z.iso
+    .datetime()
+    .describe('RFC 3339 timestamp in UTC. A numeric offset is not accepted.');
+/** the six JSON type names a declaration may name a key's type as. */
+export const JsonTypeName = z.enum([
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'array',
+    'null',
+]);
+// A declared key name: used in a request shape, a response descriptor, or a
+// reference-set key list. Plain caller-supplied text.
+export const KeyName = z.string().min(1);
+// The one shape whose keys belong to the caller, so `additionalProperties` is
+// schema-valued rather than false here alone. Hand-rolled with z.lazy rather
+// than z.json(): the latter exports a generated `$defs` ref name that the
+// published-schema drift check would pin and that separates the description
+// from the shared definition, and AD-36 needs the numeric restriction on the
+// definition itself.
+export const JsonValue = z
+    .lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValue),
+    z.record(z.string(), JsonValue),
+]))
+    .meta({
+    id: 'JsonValue',
+    description: 'AD-36 value domain. Every number is a finite IEEE 754 double-precision value, and every integer lies in the safe-integer range; a larger integer, and any value needing exact decimal semantics such as money, is carried as a string in its own declared format. JSON Schema cannot express finiteness, so this restriction is stated rather than encoded: producers are told the rule here instead of discovering it through a digest mismatch, and the canonical scanner rejects a violating value before any parse.',
+});
+/**
+ * AD-4's `shape` descriptor and AD-19's request channel both need "required
+ * keys, permitted keys, and per-key JSON type, never an embedded JSON
+ * Schema"; spelled once here so two copies of one triple don't drift apart.
+ * `.describe()` returns a new schema rather than mutating this one, so each
+ * use site can add its own description.
+ */
+export const KeyTypeMap = z
+    .record(KeyName, JsonTypeName.nullable())
+    .describe('Caller-keyed by plain key name, never by pointer: the descriptor-relative pointer spelling does not apply to these keys and must not be extended to them by analogy. A missing key means "not declared"; an explicit `null` value means "declared, type not stated".');
+export const KeyedShapeDescriptor = z.strictObject({
+    requiredKeys: z.array(KeyName),
+    permittedKeys: z
+        .array(KeyName)
+        .describe('The closed set of keys the shape admits. Deliberately not refined to be a superset of `requiredKeys`: no AD-5 code names that contradiction, so it joins the cross-field rules left to the compiler in v0. There is no spelling for "these keys are required and extras are unconstrained" — AD-4 calls the descriptor closed, so an open mode would be a different grammar.'),
+    types: KeyTypeMap,
+});
+/** a caller-keyed object inside the value container; not a control object. */
+export const JsonObjectValue = z.record(z.string(), JsonValue);

package/dist/core/schemas/private-artifact-manifest.d.ts

@@ -0,0 +1,56 @@
+/** the public-safe index of every private artifact this repository references. */
+import { z } from 'zod';
+/**
+ * The prior art's eight `artifactType` members, ratified unchanged as
+ * `artifactKind` (AD-24 rename only). An existing entry re-keys without
+ * re-classifying.
+ */
+export declare const PRIVATE_ARTIFACT_KINDS: readonly ['private-input-record', 'raw-trace', 'raw-result', 'human-label', 'implementation-patch', 'isolation-manifest', 'scripted-baseline-output', 'other'];
+export declare const PrivateArtifactKind: z.ZodEnum<{
+    "human-label": "human-label";
+    "implementation-patch": "implementation-patch";
+    "isolation-manifest": "isolation-manifest";
+    other: "other";
+    "private-input-record": "private-input-record";
+    "raw-result": "raw-result";
+    "raw-trace": "raw-trace";
+    "scripted-baseline-output": "scripted-baseline-output";
+}>;
+export declare const PrivateArtifactEntry: z.ZodObject<{
+    privateRef: z.ZodString;
+    digest: z.ZodString;
+    artifactKind: z.ZodEnum<{
+        "human-label": "human-label";
+        "implementation-patch": "implementation-patch";
+        "isolation-manifest": "isolation-manifest";
+        other: "other";
+        "private-input-record": "private-input-record";
+        "raw-result": "raw-result";
+        "raw-trace": "raw-trace";
+        "scripted-baseline-output": "scripted-baseline-output";
+    }>;
+    publicSafeRunId: z.ZodNullable<z.ZodString>;
+    sanitizationPolicy: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const PrivateArtifactManifest: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    entries: z.ZodArray<z.ZodObject<{
+        privateRef: z.ZodString;
+        digest: z.ZodString;
+        artifactKind: z.ZodEnum<{
+            "human-label": "human-label";
+            "implementation-patch": "implementation-patch";
+            "isolation-manifest": "isolation-manifest";
+            other: "other";
+            "private-input-record": "private-input-record";
+            "raw-result": "raw-result";
+            "raw-trace": "raw-trace";
+            "scripted-baseline-output": "scripted-baseline-output";
+        }>;
+        publicSafeRunId: z.ZodNullable<z.ZodString>;
+        sanitizationPolicy: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PrivateArtifactManifest = z.infer<typeof PrivateArtifactManifest>;

package/dist/core/schemas/private-artifact-manifest.js

@@ -0,0 +1,46 @@
+/** the public-safe index of every private artifact this repository references. */
+import { z } from 'zod';
+import { lineageFields } from './lineage.js';
+import { Digest } from './primitives.js';
+/**
+ * The prior art's eight `artifactType` members, ratified unchanged as
+ * `artifactKind` (AD-24 rename only). An existing entry re-keys without
+ * re-classifying.
+ */
+export const PRIVATE_ARTIFACT_KINDS = [
+    'private-input-record',
+    'raw-trace',
+    'raw-result',
+    'human-label',
+    'implementation-patch',
+    'isolation-manifest',
+    'scripted-baseline-output',
+    'other',
+];
+export const PrivateArtifactKind = z.enum(PRIVATE_ARTIFACT_KINDS);
+export const PrivateArtifactEntry = z.strictObject({
+    privateRef: z
+        .string()
+        .min(1)
+        .describe('The opaque handle the corpus port resolves under AD-8. Only emptiness is excluded: an opaque reference with a shape this package understands would stop being opaque.'),
+    digest: Digest.describe('The prior art\'s `sha256`, renamed against the shared AD-27 primitive; the value form is byte-identical. AD-8 is explicit that "a manifest digest is never a trusted label": the core recomputes the digest from the resolved bytes and a mismatch is an AD-28 `digest-mismatch` fault at ingest. That is a rule about resolved bytes, which a schema over a string cannot see, so it is recorded here and enforced nowhere in this file.'),
+    artifactKind: PrivateArtifactKind.describe("The prior art's `artifactType`, renamed and ratified with its eight members unchanged."),
+    publicSafeRunId: z
+        .string()
+        .nullable()
+        .describe('The run this artifact belongs to, in the public-safe vocabulary. `null` for an artifact belonging to no single run.'),
+    sanitizationPolicy: z
+        .string()
+        .min(1)
+        .nullable()
+        .describe('AD-8 carries "the sanitization policy applied to it", and the nearest antecedent is the entry rather than the manifest: a manifest holding a raw trace beside a human label gives the two different treatment, so per-entry is the only reading that survives. Opaque rather than an enum for the reason `ScopedResource.kind` is opaque: no AD supplies a value space, and inventing one is the unshaped-declaration defect in reverse. `null` spells "none applied", which must stay representable.'),
+});
+export const PrivateArtifactManifest = z
+    .strictObject({
+    ...lineageFields,
+    entries: z.array(PrivateArtifactEntry),
+})
+    .meta({
+    id: 'PrivateArtifactManifest',
+    description: "The public-safe index of every private artifact this repository references. Succeeds the prior-art `private-evidence-manifest` schema per AD-24, with three divergences: the prior art's `manifestVersion: const 1` becomes AD-11's `schemaVersion` alongside AD-29's lineage, `artifactType` becomes `artifactKind` with its eight members ratified unchanged, and each entry gains AD-8's `sanitizationPolicy`. AD-18 binds this artifact hardest: it \"never contains a private path, credential, or domain value\". That prohibition is not expressible over opaque strings, so it is stated here, recorded in the constraint ledger as not expressible, and enforced by review and by the publication guard rather than by this schema.",
+});

package/dist/core/schemas/probe-body.d.ts

@@ -0,0 +1,25 @@
+/** the two tagged body shapes the probe boundary and AD-10's witnesses share. */
+import { z } from 'zod';
+import { JsonValue } from './primitives.ts';
+/**
+ * Both bodies are tagged. An untagged `JsonValue` cannot tell a JSON string
+ * response from a `text/html` one, since `JsonValue` accepts a bare string, and
+ * `absent` needs its own branch because `null` is a legal JSON body.
+ */
+export declare const ProbeRequestBody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"json">;
+    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"absent">;
+}, z.core.$strict>], "kind">;
+export declare const ProbeObservedBody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"json">;
+    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<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">;
+export type ProbeRequestBody = z.infer<typeof ProbeRequestBody>;
+export type ProbeObservedBody = z.infer<typeof ProbeObservedBody>;

package/dist/core/schemas/probe-body.js

@@ -0,0 +1,23 @@
+/** the two tagged body shapes the probe boundary and AD-10's witnesses share. */
+import { z } from 'zod';
+import { JsonValue } from './primitives.js';
+// Split out of `port-messages.ts` so `sensitivity-witness.ts` can carry the
+// request body without importing that module: `port-messages.ts` reads
+// `HttpMethod` from `interface.ts`, and `interface.ts` reads the witness, so
+// the direct import closes a cycle that fails at module evaluation. Nothing
+// here carries `.meta({ id })`, so both unions still inline at each use site
+// and no published byte moves.
+/**
+ * Both bodies are tagged. An untagged `JsonValue` cannot tell a JSON string
+ * response from a `text/html` one, since `JsonValue` accepts a bare string, and
+ * `absent` needs its own branch because `null` is a legal JSON body.
+ */
+export const ProbeRequestBody = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('json'), value: JsonValue }),
+    z.strictObject({ kind: z.literal('absent') }),
+]);
+export const ProbeObservedBody = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('json'), value: JsonValue }),
+    z.strictObject({ kind: z.literal('text'), value: z.string() }),
+    z.strictObject({ kind: z.literal('absent') }),
+]);