eval-quality 0.1.0

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

@@ -0,0 +1,92 @@
+/** the per-run isolation audit, and the forbidden-input accounting AD-16 adds. */
+import { z } from 'zod';
+import { FORBIDDEN_INPUT_FLOOR } from './eval-contract.js';
+import { lineageFields } from './lineage.js';
+import { Digest, Identifier, PositiveDecimalString, UnsignedDecimalString, } from './primitives.js';
+/**
+ * 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 const ResourceCeilings = z.strictObject({
+    maxToolCalls: z.int().min(1),
+    maxInputTokens: z.int().min(1),
+    maxOutputTokens: z.int().min(1),
+    maxWallClockMinutes: z
+        .number()
+        .gt(0)
+        .describe("The prior art's `exclusiveMinimum: 0`, kept. A ceiling of zero minutes is not a ceiling, it is a run that may not happen, and the manifest records what the harness actually enforced."),
+    maxCostUsd: PositiveDecimalString.describe("Money, so AD-36 carries it as a string. The prior art's number does not survive; an AD-24 divergence, and the reason AD-36's exact-decimal rule reaches the manifest as well as the run record. The retyping keeps the prior art's `exclusiveMinimum: 0` rather than dropping it: `UnsignedDecimalString` would admit \"0\", which is the bound the prior art spent a keyword excluding."),
+});
+/** the prior art's five-member actual-use record, with money as a string. */
+export const ActualResourceUse = z.strictObject({
+    toolCalls: z.int().min(0),
+    inputTokens: z.int().min(0),
+    outputTokens: z.int().min(0),
+    wallClockSeconds: z.number().min(0),
+    costUsd: UnsignedDecimalString,
+});
+/**
+ * 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 const ForbiddenInputAccounting = z.strictObject({
+    withheld: z.boolean(),
+    note: z.string().nullable(),
+});
+// Generated from FORBIDDEN_INPUT_FLOOR, the same reason the constraint ledger
+// generates its arity entries from TUPLE_ARITY: a hand-written second list is
+// drift waiting to happen, and AD-16 makes an incomplete floor a coded
+// compile-time failure because the list has one home.
+//
+// Declared after the shape it references and cast so the seven literal keys
+// survive into `z.infer`: `Object.fromEntries` alone widens to an index
+// signature, which would stop a typed accept fixture from catching a missing
+// member.
+const accountingShape = Object.fromEntries(FORBIDDEN_INPUT_FLOOR.map((member) => [member, ForbiddenInputAccounting]));
+/**
+ * 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 const ForbiddenInputAccountingMap = z.strictObject(accountingShape);
+export const IsolationManifest = z
+    .strictObject({
+    ...lineageFields,
+    runId: z.string().min(1),
+    contractId: Identifier.describe('The prior art\'s `taskId`, renamed. "Task" is experiment vocabulary with no product meaning, and the manifest keeps an identifier because it is the artifact `core/ingest` matches against a run; the run record and the probe pin what they describe by digest instead.'),
+    conditionArm: z
+        .string()
+        .min(1)
+        .describe("An opaque caller label with no product semantics, per AD-24. The prior art's three-member enum does not survive, on the same reasoning as the run record's."),
+    modelSnapshot: z.string().min(1),
+    systemPromptDigest: Digest,
+    contractDigest: Digest,
+    evaluatorConfigurationDigest: Digest.describe('Added here and absent from the prior art. AD-32 requires this digest to agree between the manifest and the run record, which was previously an agreement rule asserted over two fields that did not exist. Required and non-nullable on both, which is what makes the substitution cost two contradictions rather than one omission. The agreement itself is a cross-artifact rule no schema can see.'),
+    workspaceIdentity: z.string().min(1),
+    allowedMounts: z.array(z.string()),
+    observedMounts: z
+        .array(z.string())
+        .describe('Observed mounts, network targets, and tool calls exceeding their allowlist is a violation AD-16 has `core/ingest` record; it is a cross-field rule with no AD-5 code and the schema admits it.'),
+    networkAllowlist: z.array(z.string()),
+    observedNetworkTargets: z.array(z.string()),
+    toolAllowlist: z.array(z.string()),
+    observedToolCalls: z.array(z.string()),
+    resourceCeilings: ResourceCeilings,
+    actualResourceUse: ActualResourceUse,
+    forbiddenInputAccounting: ForbiddenInputAccountingMap.describe('The field AD-16 adds and the prior art lacks: "the isolation manifest\'s required fields … account for each forbidden input by name". Seven keys, generated from `FORBIDDEN_INPUT_FLOOR` so the floor has one home.'),
+    violation: z
+        .string()
+        .nullable()
+        .describe("The sixteenth of the prior art's sixteen required members, and the one that is not a description of the run: a non-null violation invalidates it. AD-16 says the schema is \"seeded from the prior art's fifteen\"; the prior art's `required` array has sixteen. Settled by construction: the fifteen are the fields describing the run and this is the invalidation outcome. All sixteen are carried."),
+})
+    .meta({
+    id: 'IsolationManifest',
+    description: "The per-run isolation audit. Succeeds the prior-art `isolation-manifest` schema per AD-24, carrying all sixteen of its required members plus `evaluatorConfigurationDigest`, `forbiddenInputAccounting`, and AD-29's lineage; `taskId` becomes `contractId`, `condition` is demoted to an opaque `conditionArm`, and money in both resource shapes becomes a decimal string. An absent, unparseable, incomplete, or violating manifest invalidates the run under AD-16 and never downgrades a verdict; a schema rejection is the correct expression of unparseable and incomplete, so nothing is admitted for their sake, and the violating case is `core/ingest`'s.",
+});

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

@@ -0,0 +1,21 @@
+/** AD-11's schema version and AD-29's lineage pair, spelled once. */
+import { z } from 'zod';
+/**
+ * The three fields every lineage-bearing artifact carries, lifted here so
+ * eleven artifacts spread it instead of respelling it (the drift the
+ * Consistency Conventions warn against).
+ *
+ * This module imports only zod and primitives.ts: `artifact.ts` imports all
+ * twelve schema modules including this one, so importing `artifact.ts` back
+ * from here would close a circular import.
+ *
+ * Spread rather than nested, so `EvalContract`'s shape and the reject
+ * fixtures naming `['schemaVersion']`/`['parentDigest']` stay unchanged; the
+ * two discriminated-union artifacts (`Probe`, `EvidenceArtifact`) spread it
+ * inside every branch instead, since a union has no root property bag.
+ */
+export declare const lineageFields: {
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+};

package/dist/core/schemas/lineage.js

@@ -0,0 +1,28 @@
+/** AD-11's schema version and AD-29's lineage pair, spelled once. */
+import { z } from 'zod';
+import { Digest } from './primitives.js';
+/**
+ * The three fields every lineage-bearing artifact carries, lifted here so
+ * eleven artifacts spread it instead of respelling it (the drift the
+ * Consistency Conventions warn against).
+ *
+ * This module imports only zod and primitives.ts: `artifact.ts` imports all
+ * twelve schema modules including this one, so importing `artifact.ts` back
+ * from here would close a circular import.
+ *
+ * Spread rather than nested, so `EvalContract`'s shape and the reject
+ * fixtures naming `['schemaVersion']`/`['parentDigest']` stay unchanged; the
+ * two discriminated-union artifacts (`Probe`, `EvidenceArtifact`) spread it
+ * inside every branch instead, since a union has no root property bag.
+ */
+export const lineageFields = {
+    schemaVersion: z
+        .int()
+        .min(1)
+        .describe('AD-11 requires an integer under this exact name. Deliberately not `z.literal(1)`: the literal exports as `{"type":"number","const":1}`, losing `integer` for a non-TypeScript consumer, and it would turn a version-2 artifact into an anonymous schema-parse failure instead of AD-28\'s dedicated `schema-version-mismatch` fault. Version equality belongs to the reader that throws that fault.'),
+    parentDigest: Digest.nullable().describe('AD-29 lineage. `null` if and only if `revisionCount` is 0. That biconditional is stated here rather than refined: a refinement is silently dropped from the published schema, so a non-TypeScript consumer would never see it, and the constraint ledger records it as not expressible.'),
+    revisionCount: z
+        .int()
+        .min(0)
+        .describe("AD-29: one greater than the parent artifact's."),
+};

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

@@ -0,0 +1,72 @@
+/** an oracle: a structured direction and an enforceable check. */
+import { z } from 'zod';
+import { Expression } from './expression.ts';
+/**
+ * AD-3's five direction fields: the channel the sealed evaluator reads,
+ * generated into prose by `seal`. Structured rather than free prose because
+ * alignment against `check` is a computation over two declared structures.
+ */
+export declare const Direction: z.ZodObject<{
+    evidenceTargets: z.ZodArray<z.ZodString>;
+    relation: z.ZodEnum<{
+        absence: "absence";
+        all: "all";
+        any: "any";
+        containment: "containment";
+        "count-tolerance": "count-tolerance";
+        "covers-by-key": "covers-by-key";
+        "deep-equality": "deep-equality";
+        equality: "equality";
+        existence: "existence";
+        "for-all": "for-all";
+        "for-any": "for-any";
+        not: "not";
+        ordering: "ordering";
+        regex: "regex";
+        "set-membership": "set-membership";
+        shape: "shape";
+    }>;
+    polarity: z.ZodEnum<{
+        "expects-hold": "expects-hold";
+        "expects-violation": "expects-violation";
+    }>;
+    scope: z.ZodNullable<z.ZodString>;
+    negativeDomain: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type Direction = z.infer<typeof Direction>;
+export declare const Oracle: z.ZodObject<{
+    id: z.ZodString;
+    direction: z.ZodNullable<z.ZodObject<{
+        evidenceTargets: z.ZodArray<z.ZodString>;
+        relation: z.ZodEnum<{
+            absence: "absence";
+            all: "all";
+            any: "any";
+            containment: "containment";
+            "count-tolerance": "count-tolerance";
+            "covers-by-key": "covers-by-key";
+            "deep-equality": "deep-equality";
+            equality: "equality";
+            existence: "existence";
+            "for-all": "for-all";
+            "for-any": "for-any";
+            not: "not";
+            ordering: "ordering";
+            regex: "regex";
+            "set-membership": "set-membership";
+            shape: "shape";
+        }>;
+        polarity: z.ZodEnum<{
+            "expects-hold": "expects-hold";
+            "expects-violation": "expects-violation";
+        }>;
+        scope: z.ZodNullable<z.ZodString>;
+        negativeDomain: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    check: z.ZodNullable<z.ZodType<Expression, unknown, z.core.$ZodTypeInternals<Expression, unknown>>>;
+    polarity: z.ZodEnum<{
+        "expects-hold": "expects-hold";
+        "expects-violation": "expects-violation";
+    }>;
+    commentary: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;

package/dist/core/schemas/oracle.js

@@ -0,0 +1,35 @@
+/** an oracle: a structured direction and an enforceable check. */
+import { z } from 'zod';
+import { Expression, Polarity, Relation } from './expression.js';
+import { InteractionPointer } from './pointer.js';
+import { OracleId } from './primitives.js';
+/**
+ * AD-3's five direction fields: the channel the sealed evaluator reads,
+ * generated into prose by `seal`. Structured rather than free prose because
+ * alignment against `check` is a computation over two declared structures.
+ */
+export const Direction = z.strictObject({
+    evidenceTargets: z
+        .array(InteractionPointer)
+        .describe('Interaction-rooted pointers only. AD-3 computes containment after quantifier substitution, so a target is always fully rooted and the bound-element spelling never appears here.'),
+    relation: Relation.describe("Drawn from AD-4's full sixteen-member vocabulary — eleven operators, three connectives, two quantifiers — not the operators alone."),
+    polarity: Polarity.describe('Coin flip (a), settled: polarity is declared twice, here and on the oracle. AD-3 names it as one of the three axes the alignment predicate binds and AD-33 gives every check one, so declaring it once makes the alignment predicate vacuous on a third of its content. Duplication is what makes drift detectable, and the drift is deliberately not refined away: `direction-check-misaligned` needs the disagreement to stay representable.'),
+    scope: z
+        .string()
+        .nullable()
+        .describe('Evaluator-facing, and exempt from the alignment predicate, which binds evidence targets, relation, and polarity only.'),
+    negativeDomain: z
+        .string()
+        .nullable()
+        .describe('Evaluator-facing and exempt from alignment. `seal` renders it as an unordered set so the brief is byte-identical under reordering.'),
+});
+export const Oracle = z.strictObject({
+    id: OracleId,
+    direction: Direction.nullable().describe('`null` is half of what `oracle-missing-channel` fires on, so it must parse.'),
+    check: Expression.nullable().describe('`null` is the other half of `oracle-missing-channel`.'),
+    polarity: Polarity.describe('AD-33: every check declares one polarity, and it lives at oracle level rather than inside the expression tree. Required and explicit rather than defaulted to `expects-hold`: a Zod default diverges input and output mode and the explicit-null convention forbids implicit absence.'),
+    commentary: z
+        .string()
+        .nullable()
+        .describe("AD-3's author documentation. No predicate reads it and `seal` never emits it, because a channel the evaluator reads and no predicate audits is the free-prose channel AD-3 exists to close."),
+});

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

@@ -0,0 +1,115 @@
+/** the interaction plan: steps as selectors over observations. */
+import { z } from 'zod';
+import { JsonValue } from './primitives.ts';
+/**
+ * AD-39: input-binding values are tagged and never share a value space. The
+ * untagged spelling let `{ "title": "type-violating" }` mean the matcher to
+ * one implementation and the literal string to another, and flipped a witness
+ * match between `caught` and `missed` on one record; that form is
+ * unrepresentable here.
+ */
+export declare const BindingValue: z.ZodUnion<readonly [z.ZodObject<{
+    literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    matcher: z.ZodEnum<{
+        any: "any";
+        "type-violating": "type-violating";
+    }>;
+}, z.core.$strict>]>;
+/** the constraint identifier the ledger carries for the check below. */
+export declare const BINDING_CHANNEL_NON_EMPTY = "binding-channel-non-empty";
+export declare const BindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    matcher: z.ZodEnum<{
+        any: "any";
+        "type-violating": "type-violating";
+    }>;
+}, z.core.$strict>]>>>;
+/**
+ * A four-key strict object with each channel nullable, not a record over the
+ * channel enum. Verified on the pin: a record over a four-member enum key
+ * requires every member at parse time and fails five of the Gate C fixture's
+ * six steps, all of which bind a subset of the channels.
+ */
+export declare const InputBinding: z.ZodObject<{
+    path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+    body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+/**
+ * AD-39: a step is a selector over observations the evaluator produced, never
+ * an instruction. Its selection predicate is spelled as its two members, the
+ * input binding and the temporal clause, directly on the step itself,
+ * matching the only hand-authored contract rather than nesting them under a
+ * further key.
+ */
+export declare const InteractionStep: z.ZodObject<{
+    stepId: z.ZodString;
+    operationId: z.ZodString;
+    inputBinding: z.ZodObject<{
+        path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+        body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>;
+    after: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type InteractionStep = z.infer<typeof InteractionStep>;

package/dist/core/schemas/plan.js

@@ -0,0 +1,58 @@
+/** the interaction plan: steps as selectors over observations. */
+import { z } from 'zod';
+import { Identifier, JsonValue, KeyName } from './primitives.js';
+/**
+ * AD-39: input-binding values are tagged and never share a value space. The
+ * untagged spelling let `{ "title": "type-violating" }` mean the matcher to
+ * one implementation and the literal string to another, and flipped a witness
+ * match between `caught` and `missed` on one record; that form is
+ * unrepresentable here.
+ */
+export const BindingValue = z.union([
+    z.strictObject({ literal: JsonValue }),
+    z.strictObject({ matcher: z.enum(['any', 'type-violating']) }),
+]);
+/** the constraint identifier the ledger carries for the check below. */
+export const BINDING_CHANNEL_NON_EMPTY = 'binding-channel-non-empty';
+// Caller-keyed: the keys are the author's own parameter names. `{}` is
+// rejected because a binding channel has exactly one spelling for "binds
+// nothing" (`null`), unlike a request-shape channel's empty triple, which
+// means "declared, no keys." No AD-5 code fires on an empty binding map, so
+// the schema is the enforcement point, under the admit-rule's second clause.
+const BindingChannelMap = z
+    .record(KeyName, BindingValue)
+    .refine((entries) => Object.keys(entries).length > 0, {
+    error: 'an input-binding channel names at least one parameter; an unbound channel is null',
+});
+// Named so the constraint ledger has one stable address for the non-empty
+// check rather than a path through four sibling channels, and so the export
+// injects `minProperties` once on the shared definition.
+export const BindingChannel = BindingChannelMap.nullable().meta({
+    id: 'InputBindingChannel',
+    description: 'A parameter-name-to-binding-value map, or `null` for a channel this step binds nothing in. An empty map is rejected: `null` is the only spelling for unbound. That rejection is a Zod check and does not survive the export, so the constraint ledger carries it for injection on the object branch.',
+});
+/**
+ * A four-key strict object with each channel nullable, not a record over the
+ * channel enum. Verified on the pin: a record over a four-member enum key
+ * requires every member at parse time and fails five of the Gate C fixture's
+ * six steps, all of which bind a subset of the channels.
+ */
+export const InputBinding = z.strictObject({
+    path: BindingChannel,
+    query: BindingChannel,
+    header: BindingChannel,
+    body: BindingChannel,
+});
+/**
+ * AD-39: a step is a selector over observations the evaluator produced, never
+ * an instruction. Its selection predicate is spelled as its two members, the
+ * input binding and the temporal clause, directly on the step itself,
+ * matching the only hand-authored contract rather than nesting them under a
+ * further key.
+ */
+export const InteractionStep = z.strictObject({
+    stepId: Identifier,
+    operationId: Identifier,
+    inputBinding: InputBinding,
+    after: Identifier.nullable().describe("The temporal clause: the identifier of an earlier step, or `null`. That the named step carries no clause of its own is AD-39's one-level bound, which fires `nested-temporal-clause` at compile time and is deliberately not enforced here, so the code keeps a shape to fire on."),
+});

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

@@ -0,0 +1,63 @@
+/** the three pointer spellings and the consumers each is assigned to. */
+import { z } from 'zod';
+/**
+ * AD-26's closed channel vocabulary, in AD-26's own order: order matters
+ * because enum order lands in the export, and the published-schema drift
+ * check pins whatever ships. These were once private regex fragments; they
+ * are exported here because the Sealed Run Record's quoted evidence needs to
+ * name a channel by one shared spelling.
+ */
+export declare const EVIDENCE_CHANNELS: readonly ['response-body', 'response-headers', 'response-status', 'call-inputs', 'stdout', 'stderr', 'exit-code'];
+export type EvidenceChannelName = (typeof EVIDENCE_CHANNELS)[number];
+export declare const EvidenceChannel: z.ZodEnum<{
+    "call-inputs": "call-inputs";
+    "exit-code": "exit-code";
+    "response-body": "response-body";
+    "response-headers": "response-headers";
+    "response-status": "response-status";
+    stderr: "stderr";
+    stdout: "stdout";
+}>;
+/**
+ * AD-19's four transport channels. `call-inputs` alone has no declared
+ * structure to resolve against (the defect AD-26 revision 3 records), so a
+ * transport channel is mandatory immediately after it.
+ */
+export declare const TRANSPORT_CHANNELS: readonly ['path', 'query', 'header', 'body'];
+export type TransportChannelName = (typeof TRANSPORT_CHANNELS)[number];
+export declare const TransportChannel: z.ZodEnum<{
+    body: "body";
+    header: "header";
+    path: "path";
+    query: "query";
+}>;
+export declare const TAIL_BEARING_CHANNELS: readonly ["response-body", "response-headers", "stdout", "stderr"];
+export declare const SCALAR_CHANNELS: readonly ["response-status", "exit-code"];
+export declare const TRANSPORT_ROOTED_CHANNEL: "call-inputs";
+export declare const INTERACTION_POINTER_PATTERN: RegExp;
+export declare const BOUND_ELEMENT_POINTER_PATTERN: RegExp;
+export declare const DESCRIPTOR_POINTER_PATTERN: RegExp;
+/**
+ * Spelling 1, interaction-rooted. Consumers: `{ pointer }` operands, a
+ * direction's evidence targets, and a rubric criterion's evidence.
+ */
+export declare const InteractionPointer: z.ZodString;
+/**
+ * Spelling 2, bound-element relative. Consumer: a `{ pointer }` operand inside
+ * a quantifier predicate. Never an evidence target, because AD-3 computes
+ * containment after quantifier substitution, by which point every target is
+ * fully rooted.
+ */
+export declare const BoundElementPointer: z.ZodString;
+/**
+ * Spelling 3, descriptor-relative. Consumers: a nominated success indicator,
+ * every channel-role key, a collection location's pointer, and volatile
+ * pointers. Gate C authoring point 7 fixed this spelling's scope and never gave
+ * it a syntax; this is the syntax.
+ */
+export declare const DescriptorPointer: z.ZodString;
+/**
+ * The pointer form an operand may carry: rooted at an interaction, or relative
+ * to a quantifier's bound element.
+ */
+export declare const EvidencePointer: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;

package/dist/core/schemas/pointer.js

@@ -0,0 +1,94 @@
+/** the three pointer spellings and the consumers each is assigned to. */
+import { z } from 'zod';
+import { IDENTIFIER_CHARSET_SOURCE } from './primitives.js';
+/**
+ * AD-26's closed channel vocabulary, in AD-26's own order: order matters
+ * because enum order lands in the export, and the published-schema drift
+ * check pins whatever ships. These were once private regex fragments; they
+ * are exported here because the Sealed Run Record's quoted evidence needs to
+ * name a channel by one shared spelling.
+ */
+export const EVIDENCE_CHANNELS = [
+    'response-body',
+    'response-headers',
+    'response-status',
+    'call-inputs',
+    'stdout',
+    'stderr',
+    'exit-code',
+];
+export const EvidenceChannel = z.enum(EVIDENCE_CHANNELS).meta({
+    id: 'EvidenceChannel',
+    description: "AD-26's closed evidence channel vocabulary. The same seven the interaction-rooted pointer addresses; a channel outside this set is a syntax error rather than an unreachable-evidence finding.",
+});
+/**
+ * AD-19's four transport channels. `call-inputs` alone has no declared
+ * structure to resolve against (the defect AD-26 revision 3 records), so a
+ * transport channel is mandatory immediately after it.
+ */
+export const TRANSPORT_CHANNELS = ['path', 'query', 'header', 'body'];
+export const TransportChannel = z.enum(TRANSPORT_CHANNELS).meta({
+    id: 'TransportChannel',
+    description: "AD-19's four transport channels. They are the segment `call-inputs` takes before its tail, and the four keys an observation's recorded call inputs are keyed by.",
+});
+// The three-way partition (tail-bearing, scalar, transport-rooted) is spelled
+// out and typed against the enum rather than rebuilt from it, so a typo fails
+// the typecheck; a test asserts it stays disjoint and exhaustive. A status or
+// exit code is scalar, so a pointer into one is a syntax error rather than an
+// unreachable-evidence finding.
+export const TAIL_BEARING_CHANNELS = [
+    'response-body',
+    'response-headers',
+    'stdout',
+    'stderr',
+];
+export const SCALAR_CHANNELS = [
+    'response-status',
+    'exit-code',
+];
+export const TRANSPORT_ROOTED_CHANNEL = 'call-inputs';
+// An RFC 6901 reference token: any character but "/" and "~", plus the two
+// escapes. A token may be empty, which is RFC 6901's spelling for a key that is
+// the empty string.
+const TOKEN = '(?:[^/~]|~[01])*';
+const TAIL = `(?:/${TOKEN})*`;
+const alternation = (members) => members.join('|');
+export const INTERACTION_POINTER_PATTERN = new RegExp(`^/interactions/${IDENTIFIER_CHARSET_SOURCE}/(?:(?:${alternation(TAIL_BEARING_CHANNELS)})${TAIL}|(?:${alternation(SCALAR_CHANNELS)})|${TRANSPORT_ROOTED_CHANNEL}/(?:${alternation(TRANSPORT_CHANNELS)})${TAIL})$`);
+export const BOUND_ELEMENT_POINTER_PATTERN = new RegExp(`^@(?:/${TOKEN})+$`);
+export const DESCRIPTOR_POINTER_PATTERN = new RegExp(`^(?:/${TOKEN})*$`);
+/**
+ * Spelling 1, interaction-rooted. Consumers: `{ pointer }` operands, a
+ * direction's evidence targets, and a rubric criterion's evidence.
+ */
+export const InteractionPointer = z
+    .string()
+    .regex(INTERACTION_POINTER_PATTERN)
+    .describe('AD-26 interaction-rooted pointer: "/interactions/{stepId}/" followed by one channel of the closed vocabulary. `call-inputs` takes one of the four transport channels as its next segment; `response-status` and `exit-code` take no tail. Syntax only: whether the step exists and whether the evidence is reachable are compile-time checks, not schema checks.');
+/**
+ * Spelling 2, bound-element relative. Consumer: a `{ pointer }` operand inside
+ * a quantifier predicate. Never an evidence target, because AD-3 computes
+ * containment after quantifier substitution, by which point every target is
+ * fully rooted.
+ */
+export const BoundElementPointer = z
+    .string()
+    .regex(BOUND_ELEMENT_POINTER_PATTERN)
+    .describe('AD-26 bound-element pointer: "@/" plus an RFC 6901 tail, addressing the element a quantifier binds. Bare "@/" addresses the element itself. That it appears only inside a quantifier is a compile-time check, not a schema check.');
+/**
+ * Spelling 3, descriptor-relative. Consumers: a nominated success indicator,
+ * every channel-role key, a collection location's pointer, and volatile
+ * pointers. Gate C authoring point 7 fixed this spelling's scope and never gave
+ * it a syntax; this is the syntax.
+ */
+export const DescriptorPointer = z
+    .string()
+    .regex(DESCRIPTOR_POINTER_PATTERN)
+    .describe("A plain RFC 6901 pointer into one operation's response descriptor. It resolves through the operation an interaction step names, never through the interaction root. A request or response shape's descriptor keys are plain key names rather than pointers, so this spelling does not apply there. The empty string is admitted and carries RFC 6901's own meaning, the whole document: as a nominated success indicator it says success is visible in the response taken as a whole rather than at any one key, and as a channel-role key it assigns a role to the whole body.");
+/**
+ * The pointer form an operand may carry: rooted at an interaction, or relative
+ * to a quantifier's bound element.
+ */
+export const EvidencePointer = z.union([
+    InteractionPointer,
+    BoundElementPointer,
+]);