eval-quality 0.1.0

package/dist/core/seal/plan-index.js

@@ -0,0 +1,155 @@
+import { SCALAR_CHANNELS, TAIL_BEARING_CHANNELS, TRANSPORT_CHANNELS, TRANSPORT_ROOTED_CHANNEL, } from '../schemas/pointer.js';
+import { IDENTIFIER_CHARSET_SOURCE } from '../schemas/primitives.js';
+// An RFC 6901 reference token, respelled here because pointer.ts keeps its
+// own TOKEN/TAIL fragments private. IDENTIFIER_CHARSET_SOURCE and the channel
+// partition below are project vocabulary, so those are imported rather than
+// respelled.
+const TOKEN_SOURCE = '(?:[^/~]|~[01])*';
+const TAIL_SOURCE = `(?:/${TOKEN_SOURCE})*`;
+const alternation = (members) => members.join('|');
+// Mirrors `pointer.ts`'s own `INTERACTION_POINTER_PATTERN` three-branch
+// partition rather than a flatter grammar: a flatter version once silently
+// accepted `/interactions/poll/response-status/oops` (a schema reject) by
+// discarding the bogus trailing segment instead of rejecting the pointer.
+// Named capture groups replace positional indices, avoiding a fragile
+// dependency on `IDENTIFIER_CHARSET_SOURCE` staying free of its own capturing
+// groups.
+const EVIDENCE_TARGET_PATTERN = new RegExp(`^/interactions/(?<stepId>${IDENTIFIER_CHARSET_SOURCE})/(?:(?<tailBearingChannel>${alternation(TAIL_BEARING_CHANNELS)})(?<tailBearingTail>${TAIL_SOURCE})|(?<scalarChannel>${alternation(SCALAR_CHANNELS)})|${TRANSPORT_ROOTED_CHANNEL}/(?<transportChannel>${alternation(TRANSPORT_CHANNELS)})(?<callInputsTail>${TAIL_SOURCE}))$`);
+const isEvidenceChannel = (value) => TAIL_BEARING_CHANNELS.includes(value) ||
+    SCALAR_CHANNELS.includes(value);
+const isTransportChannel = (value) => TRANSPORT_CHANNELS.includes(value);
+/**
+ * Exported so `core/evaluate/evidence-resolution.ts` decodes pointer tails
+ * with these same two functions, avoiding a second private copy (the drift
+ * `IDENTIFIER_CHARSET_SOURCE`'s own precedent warns against).
+ */
+export const decodeToken = (token) => token.replace(/~1/g, '/').replace(/~0/g, '~');
+export const decodeTail = (tailSource) => tailSource === '' ? [] : tailSource.slice(1).split('/').map(decodeToken);
+/**
+ * Parses one `InteractionPointer` string (`INTERACTION_POINTER_PATTERN` in
+ * `pointer.ts`) into its step id, channel, transport channel, and tail, using
+ * the schema's own channel partition so this accepts exactly what
+ * `InteractionPointer.safeParse` accepts. A should-never-happen precondition
+ * violation throws `TypeError`, per `digest.ts`'s precedent.
+ */
+export function parseEvidenceTarget(pointer) {
+    const groups = EVIDENCE_TARGET_PATTERN.exec(pointer)?.groups;
+    if (groups === undefined || groups.stepId === undefined) {
+        throw new TypeError(`not an interaction-rooted evidence pointer of a recognized channel: ${pointer}`);
+    }
+    const stepId = groups.stepId;
+    if (groups.scalarChannel !== undefined) {
+        if (!isEvidenceChannel(groups.scalarChannel)) {
+            // Unreachable: SCALAR_CHANNELS is exactly what this group can match.
+            throw new TypeError(`unrecognized evidence channel in pointer: ${pointer}`);
+        }
+        return {
+            stepId,
+            channel: groups.scalarChannel,
+            transportChannel: null,
+            tail: [],
+        };
+    }
+    if (groups.tailBearingChannel !== undefined) {
+        if (!isEvidenceChannel(groups.tailBearingChannel)) {
+            // Unreachable: TAIL_BEARING_CHANNELS is exactly what this group can match.
+            throw new TypeError(`unrecognized evidence channel in pointer: ${pointer}`);
+        }
+        return {
+            stepId,
+            channel: groups.tailBearingChannel,
+            transportChannel: null,
+            tail: decodeTail(groups.tailBearingTail ?? ''),
+        };
+    }
+    if (groups.transportChannel !== undefined) {
+        if (!isTransportChannel(groups.transportChannel)) {
+            // Unreachable: TRANSPORT_CHANNELS is exactly what this group can match.
+            throw new TypeError(`call-inputs evidence target names no transport channel: ${pointer}`);
+        }
+        return {
+            stepId,
+            channel: 'call-inputs',
+            transportChannel: groups.transportChannel,
+            tail: decodeTail(groups.callInputsTail ?? ''),
+        };
+    }
+    // Unreachable: the pattern's three branches are exhaustive once stepId matched.
+    throw new TypeError(`not an interaction-rooted evidence pointer of a recognized channel: ${pointer}`);
+}
+/**
+ * Builds the index once over the whole plan and interface set. Neither
+ * schema enforces `stepId`/`operationId` uniqueness. Strict callers keep the
+ * default throw instead of resolving by array order. Standalone structural
+ * checks can select `unresolved`, which removes every ambiguous identifier
+ * from lookup while preserving all unambiguous entries.
+ */
+export function buildPlanIndex(interactionPlan, permittedInterfaces, options = {}) {
+    const duplicateIds = options.duplicateIds ?? 'throw';
+    const steps = new Map();
+    const duplicateStepIds = new Set();
+    const stepsByOperation = new Map();
+    for (const step of interactionPlan) {
+        if (steps.has(step.stepId) || duplicateStepIds.has(step.stepId)) {
+            if (duplicateIds === 'throw') {
+                throw new TypeError(`duplicate interaction step id: ${step.stepId}`);
+            }
+            steps.delete(step.stepId);
+            duplicateStepIds.add(step.stepId);
+        }
+        else {
+            steps.set(step.stepId, step);
+        }
+        const group = stepsByOperation.get(step.operationId);
+        if (group === undefined) {
+            stepsByOperation.set(step.operationId, [step]);
+        }
+        else {
+            group.push(step);
+        }
+    }
+    const operations = new Map();
+    const duplicateOperationIds = new Set();
+    for (const iface of permittedInterfaces) {
+        for (const operation of iface.operations) {
+            if (operations.has(operation.operationId) ||
+                duplicateOperationIds.has(operation.operationId)) {
+                if (duplicateIds === 'throw') {
+                    throw new TypeError(`duplicate operation id across permitted interfaces: ${operation.operationId}`);
+                }
+                operations.delete(operation.operationId);
+                duplicateOperationIds.add(operation.operationId);
+            }
+            else {
+                operations.set(operation.operationId, operation);
+            }
+        }
+    }
+    return {
+        stepOf: (stepId) => steps.get(stepId),
+        operationOf: (operationId) => operations.get(operationId),
+        stepsUsing: (operationId) => stepsByOperation.get(operationId) ?? [],
+    };
+}
+/**
+ * Resolves a step id through the index or throws. Split from `stepOf` so the
+ * index itself stays a plain lookup (`| undefined`, per
+ * `noUncheckedIndexedAccess`) while callers get one function instead of
+ * repeating the `undefined` check. A precondition violation, not a
+ * `RuntimeFault`.
+ */
+export function resolveStep(index, stepId) {
+    const step = index.stepOf(stepId);
+    if (step === undefined) {
+        throw new TypeError(`evidence target names a step the interaction plan does not declare: ${stepId}`);
+    }
+    return step;
+}
+/** Resolves an operation id through the index or throws. See `resolveStep`. */
+export function resolveOperation(index, operationId) {
+    const operation = index.operationOf(operationId);
+    if (operation === undefined) {
+        throw new TypeError(`step names an operation the permitted interfaces do not declare: ${operationId}`);
+    }
+    return operation;
+}

package/dist/core/seal/scripting-audit.d.ts

@@ -0,0 +1,15 @@
+import type { SealedEvaluatorBrief } from '../schemas/sealed-evaluator-brief.ts';
+/**
+ * `probeStepBound: null` skips the audit (the codebase's null-means-absent
+ * convention); a declared `0` is legal and strict, permitting no marker.
+ *
+ * Checked per direction, never summed across the brief, so an unrelated
+ * direction's own count never tightens an already-declared bound.
+ *
+ * Scoped to `brief.directions[].text` only, leaving `behaviors`,
+ * `scopedResources`, and `safetyLimits` unscanned: AD-16 runs this audit
+ * after generation over what `seal` generated, and AD-38 names AD-3's
+ * generated direction as that output. The other three are carried through
+ * from the contract.
+ */
+export declare function auditBriefScripting(brief: SealedEvaluatorBrief): void;

package/dist/core/seal/scripting-audit.js

@@ -0,0 +1,51 @@
+/**
+ * The post-generation scripting audit (AD-16, `brief-exceeds-scripting-bound`).
+ * The declaration-side graph predicate over the interaction plan
+ * (`core/compile/scripting-bound.ts`) can't see free text an author wrote
+ * directly onto a direction's `scope`/`negativeDomain`. This audit is the
+ * other half: it counts sequencing/transition vocabulary in each direction's
+ * rendered `text`. The templates in `direction-prose.ts` compose no ordering
+ * word of their own, so a match arrives from the author's `scope` or
+ * `negativeDomain`, or from an `operationId` that `derived-reference.ts`
+ * humanizes into one (`next-page` renders "the next page endpoint").
+ */
+import { StructuralFailure } from '../failure-codes.js';
+const AD5_CODE = 'brief-exceeds-scripting-bound';
+// Matches the ordering vocabulary forbidden in generator-composed text,
+// minus bare ordinals (bare "first" also appears as a data-position
+// adjective in accepted author prose), plus a numbered- or lettered-list
+// marker (`1.`, `2)`, `a)`). `afterward`/`subsequent` match their inflected
+// forms too, since a bare-word boundary can't catch one word inside another
+// and each inflection is a real evasion path.
+//
+// The list-marker branch anchors to actual list context (string start,
+// after a newline, or after a sentence-ending mark) rather than any
+// mid-sentence digit-punctuation-space. Its trailing boundary rejects a
+// following digit rather than requiring whitespace, so "1.Send the request"
+// still opens a list item while "12.5" reads as a decimal fraction. The
+// marker is an unbounded digit run or a single letter, so `a)`/`b)` count
+// alongside `1.`/`2)`.
+const SEQUENCE_MARKER_PATTERN = /\b(?:then|before|after|subsequent(?:ly)?|next|finally|afterward(?:s)?)\b|(?<=^\s*|\n\s*|[.!?]\s*)(?:\d+|[a-z])[.)](?!\d)/gi;
+/**
+ * `probeStepBound: null` skips the audit (the codebase's null-means-absent
+ * convention); a declared `0` is legal and strict, permitting no marker.
+ *
+ * Checked per direction, never summed across the brief, so an unrelated
+ * direction's own count never tightens an already-declared bound.
+ *
+ * Scoped to `brief.directions[].text` only, leaving `behaviors`,
+ * `scopedResources`, and `safetyLimits` unscanned: AD-16 runs this audit
+ * after generation over what `seal` generated, and AD-38 names AD-3's
+ * generated direction as that output. The other three are carried through
+ * from the contract.
+ */
+export function auditBriefScripting(brief) {
+    if (brief.probeStepBound === null)
+        return;
+    for (const direction of brief.directions) {
+        const count = direction.text.match(SEQUENCE_MARKER_PATTERN)?.length ?? 0;
+        if (count > brief.probeStepBound) {
+            throw new StructuralFailure(AD5_CODE, `SealedEvaluatorBrief.directions[oracleId=${direction.oracleId}].text`, `${count} enumerated-probe-step marker(s) exceed the declared bound of ${brief.probeStepBound}`);
+        }
+    }
+}

package/dist/core/seal/seal.d.ts

@@ -0,0 +1,18 @@
+import type { EvalContract } from '../schemas/eval-contract.ts';
+import { SealedEvaluatorBrief } from '../schemas/sealed-evaluator-brief.ts';
+export declare function seal(contract: EvalContract): SealedEvaluatorBrief;
+/**
+ * The runtime backstop behind AD-16's exclusion guarantee. TypeScript's
+ * compile-time excess-property check protects only `seal()`'s current
+ * return literal; a future non-literal construction path (an `as` cast, a
+ * spread, an incremental build) would otherwise have no backstop. Reads only
+ * the `safeParse` result shape, so `core/schemas` stays the sole Zod
+ * boundary and a rejection becomes a `TypeError` (this file's
+ * precondition-violation convention) with no `ZodError` import to test
+ * against.
+ *
+ * Scoped to `seal()`, the one function in `core/` minting a package-boundary
+ * artifact today. Exported so a regression test can drive the rejection path
+ * directly.
+ */
+export declare function validateAssembledBrief(brief: unknown): SealedEvaluatorBrief;

package/dist/core/seal/seal.js

@@ -0,0 +1,155 @@
+/**
+ * `seal`: walks a compiled `EvalContract`'s oracles to assemble the
+ * `SealedEvaluatorBrief` AD-16 describes, making its isolation boundary
+ * structural rather than conventional. Pure per AD-1/AD-2: no filesystem,
+ * network, clock, randomness, model call, or evaluator execution. Reuses
+ * `buildPlanIndex`/`renderDirectionText` for the generated prose and
+ * `digestArtifact` for `contractDigest`; never reimplements rendering or
+ * hashing locally. Before returning, `validateAssembledBrief` gives AD-16's
+ * exclusion guarantee a runtime backstop; see that function for why.
+ */
+import { digestArtifact } from '../canonical/digest.js';
+import { freezeArtifact } from '../lineage/freeze.js';
+import { SealedEvaluatorBrief } from '../schemas/sealed-evaluator-brief.js';
+import { renderDirectionText } from './direction-prose.js';
+import { buildPlanIndex } from './plan-index.js';
+// `seal` digests the contract whole, so one stable label serves every call
+// regardless of which contract is being sealed.
+const CONTRACT_ARTIFACT_PATH = 'EvalContract';
+/**
+ * Sorts by a natural identifying string key, throwing `TypeError` on a
+ * duplicate key rather than emitting an order-dependent result. The schema
+ * enforces no uniqueness on `oracle.id`, `permittedInterface.logicalId`, or
+ * `scopedResource.reference`, so a duplicate is a real possibility and
+ * sort-stability alone would otherwise silently break byte-identity under
+ * contract-step reordering. This is the same precondition-violation
+ * convention `plan-index.ts`'s duplicate-`stepId`/`operationId` guard uses.
+ */
+function sortedByKey(items, keyOf, keyLabel) {
+    const seen = new Set();
+    for (const item of items) {
+        const key = keyOf(item);
+        if (seen.has(key)) {
+            throw new TypeError(`duplicate ${keyLabel} in sealed brief input: ${key}`);
+        }
+        seen.add(key);
+    }
+    return [...items].sort((a, b) => {
+        const keyA = keyOf(a);
+        const keyB = keyOf(b);
+        return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+    });
+}
+export function seal(contract) {
+    const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces);
+    // A `null` direction reaching here is a precondition violation: a
+    // compiled contract's oracles must carry a non-null direction by the
+    // time `seal` reads them. Throw, never filter or skip.
+    const directions = contract.oracles.map((oracle) => {
+        if (oracle.direction === null) {
+            throw new TypeError(`oracle ${oracle.id} reached seal() with a null direction`);
+        }
+        return {
+            oracleId: oracle.id,
+            text: renderDirectionText(oracle.direction, index),
+        };
+    });
+    // A per-element projection, not a carry-through: `PermittedInterface` has
+    // an `operations` field `BriefInterface` does not, so shipping it here
+    // would hand the evaluator the action inventory AD-39 keeps from it.
+    const permittedInterfaces = contract.permittedInterfaces.map((iface) => ({
+        logicalId: iface.logicalId,
+        kind: iface.kind,
+    }));
+    // `null` on the contract means "no scoped resources declared"; `seal`
+    // always resolves an answer, so it carries through as `[]`, matching the
+    // brief field's non-nullable schema.
+    const scopedResources = contract.scopedResources ?? [];
+    // Explicitly typed, not just inferred, so TypeScript's excess-property
+    // check still runs against this literal: assigning an object literal to
+    // an explicitly-typed binding triggers the same check as returning it
+    // from a typed function.
+    const brief = {
+        // `seal` owns these two fields per AD-24/AD-29: this call mints a
+        // fresh artifact, never a revision of a prior brief. `seal` is pure
+        // and stateless with no "prior brief" argument (AD-12), so the only
+        // honest artifact is a lineage root: `parentDigest` null,
+        // `revisionCount` 0, independent of the contract's own lineage.
+        // `schemaVersion` is the brief schema's current version.
+        schemaVersion: 1,
+        parentDigest: null,
+        revisionCount: 0,
+        // A plain digest of the literal input: two differently-ordered
+        // contracts necessarily digest differently, by construction. This
+        // field sits outside the byte-identical-under-reordering guarantee the
+        // rest of the brief carries, since it tracks the literal contract that
+        // was sealed.
+        contractDigest: digestArtifact(contract, CONTRACT_ARTIFACT_PATH),
+        // Carried through in contract order, unsorted: its own schema doc
+        // calls it "carried through unchanged," unlike the arrays below.
+        // Copied rather than aliased, like every field here, since the brief
+        // must not keep sharing structure with the input, or a caller
+        // mutating `contract.behaviors` after `seal()` returns would
+        // silently mutate the "sealed" brief too.
+        behaviors: [...contract.behaviors],
+        directions: sortedByKey(directions, (d) => d.oracleId, 'oracleId'),
+        permittedInterfaces: sortedByKey(permittedInterfaces, (i) => i.logicalId, 'permittedInterfaces logicalId'),
+        scopedResources: sortedByKey(scopedResources, (r) => r.reference, 'scopedResources reference'),
+        // Copied rather than aliased, for the same reason as `behaviors` above.
+        budgets: { ...contract.budgets },
+        // Sorted lexicographically; sort-key duplicates are impossible here
+        // since equal strings are interchangeable, so no duplicate guard.
+        safetyLimits: [...contract.safetyLimits].sort(),
+        probeStepBound: contract.probeStepBound,
+    };
+    // The parse returns Zod's own deep clone, so the freeze lands on the
+    // brief the caller receives and leaves the contract it was built from alone.
+    return freezeArtifact(validateAssembledBrief(brief));
+}
+/**
+ * The runtime backstop behind AD-16's exclusion guarantee. TypeScript's
+ * compile-time excess-property check protects only `seal()`'s current
+ * return literal; a future non-literal construction path (an `as` cast, a
+ * spread, an incremental build) would otherwise have no backstop. Reads only
+ * the `safeParse` result shape, so `core/schemas` stays the sole Zod
+ * boundary and a rejection becomes a `TypeError` (this file's
+ * precondition-violation convention) with no `ZodError` import to test
+ * against.
+ *
+ * Scoped to `seal()`, the one function in `core/` minting a package-boundary
+ * artifact today. Exported so a regression test can drive the rejection path
+ * directly.
+ */
+export function validateAssembledBrief(brief) {
+    const result = SealedEvaluatorBrief.safeParse(brief);
+    if (result.success)
+        return result.data;
+    const issueCount = result.error.issues.length;
+    const firstIssue = result.error.issues[0];
+    const firstPath = firstIssue ? dotPath(firstIssue.path) : '';
+    throw new TypeError(`seal() assembled a brief that failed SealedEvaluatorBrief validation: ${issueCount} issue${issueCount === 1 ? '' : 's'}, first at "${firstPath === '' ? '(root)' : firstPath}"`, { cause: result.error });
+}
+/**
+ * Formats a Zod issue path for the message above, mirroring zod's own
+ * `core.toDotPath` branch by branch without importing it: a word-shaped
+ * segment joins with `.`; a numeric, symbol, or non-identifier segment is
+ * bracketed. The mirror holds even at the edges, so a segment that is
+ * word-shaped but starts with a digit stays unbracketed here exactly as zod
+ * leaves it.
+ */
+function dotPath(path) {
+    const segments = [];
+    for (const segment of path) {
+        if (typeof segment === 'number')
+            segments.push(`[${segment}]`);
+        else if (typeof segment === 'symbol' || /[^\w$]/.test(segment)) {
+            segments.push(`[${JSON.stringify(String(segment))}]`);
+        }
+        else {
+            if (segments.length > 0)
+                segments.push('.');
+            segments.push(segment);
+        }
+    }
+    return segments.join('');
+}

package/dist/core/stage-contracts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AD-34's stage-shape vocabulary. Two conformance types pin the exact shapes
+ * of `compile` and `seal`; two generic types record the conditional
+ * plan/reduce pair, which `preflight` implements.
+ *
+ * AD-24's six-stage input/output/owner/lineage table lives in
+ * `core/lineage/stage-table.ts`. This file holds the stage *shapes* TypeScript
+ * checks an implementation against; that one holds the *table* AD-24 fixes.
+ * Neither imports the other.
+ */
+import type { EvalContract } from './schemas/eval-contract.ts';
+import type { SealedEvaluatorBrief } from './schemas/sealed-evaluator-brief.ts';
+/** The core compile stage's one runtime option. Core behavior never depends on an implicit configuration source (AD-1), so this is required; `application/compile.ts` is the only caller that supplies a default. */
+export type CompileOptions = {
+    readonly strict: boolean;
+};
+/** `core/compile/compile.ts`'s exact conformance shape. */
+export type CompileStage = (contract: EvalContract, options: CompileOptions) => EvalContract;
+/** `core/seal/seal.ts`'s exact conformance shape. */
+export type SealStage = (contract: EvalContract) => SealedEvaluatorBrief;
+/**
+ * A stage's pure planning half: artifacts in, a request description out.
+ * AD-34 makes this pair conditional on a stage needing external observation.
+ * Compile and seal need none, so neither implements this; pre-flight does, and
+ * `core/preflight/plan.ts` and `core/preflight/reduce.ts` are the pair that
+ * satisfies these two types.
+ */
+export type PlanStage<InputArtifact, RequestDescription> = (input: InputArtifact) => RequestDescription;
+/** A stage's pure reducing half: the plan plus the observations a port produced, reduced to the next artifact. */
+export type ReduceStage<RequestDescription, Observation, OutputArtifact> = (plan: RequestDescription, observations: Observation) => OutputArtifact;

package/dist/core/stage-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './application/index.ts';
+export type { ArtifactReference } from './core/schemas/artifact-reference.ts';
+export type { EvalContract } from './core/schemas/eval-contract.ts';
+export type { EvaluatorConfiguration } from './core/schemas/evaluator-configuration.ts';
+export type { EvidenceArtifact } from './core/schemas/evidence-artifact.ts';
+export type { IsolationManifest } from './core/schemas/isolation-manifest.ts';
+export type { PreflightCheck, PreflightVerdict, } from './core/schemas/preflight-verdict.ts';
+export type { PrivateArtifactManifest } from './core/schemas/private-artifact-manifest.ts';
+export type { Probe } from './core/schemas/probe.ts';
+export type { Rubric } from './core/schemas/rubric.ts';
+export type { ScoringPolicy } from './core/schemas/scoring-policy.ts';
+export type { SealedEvaluatorBrief } from './core/schemas/sealed-evaluator-brief.ts';
+export type { SealedRunRecord } from './core/schemas/sealed-run-record.ts';
+export type { FixtureReset, ManifestationWitness, SensitivityWitness, SensitivityWitnessLeg, WitnessChannel, WitnessInputs, } from './core/schemas/sensitivity-witness.ts';
+export declare const VERSION = "0.1.0";

package/dist/index.js

@@ -0,0 +1,22 @@
+// eval-quality: compile disciplined eval contracts and score known-defect detection.
+//
+// Barrel export. Modules land here along the artifact pipeline:
+//   compile:   validate Behavioral Evaluation Contracts and discipline coverage
+//   seal:      emit deterministic evaluator briefs
+//   ingest:    validate caller-produced run records and isolation manifests
+//   preflight: compile the contract's witnesses into probe requests, then
+//              reduce the observations the environment-probe port returned
+//   score:     derive per-oracle outcomes and contract-strength vectors
+//   emit:      produce versioned evidence artifacts
+//
+// The package executes nothing: it never runs an agent, judge, or system under test.
+//
+// The dependency matrix grants this file two edges and no others: `root ->
+// application` and `root -> core-schemas`. So the layer barrel
+// `application/index.ts` is how everything else under `core/` is reached,
+// while the artifact types below come straight off `core/schemas` on the
+// second edge. The port vocabulary stays at the `eval-quality/conformance`
+// subpath, where AD-37 puts the conformance definition an adapter author
+// reads; the reference adapters stay at `eval-quality/adapters`.
+export * from './application/index.js';
+export const VERSION = '0.1.0';

package/dist/ports/clock-port.d.ts

@@ -0,0 +1,13 @@
+/** AD-1 forbids a clock read under `core/`, so a timestamp arrives through this port. */
+import { ClockReadRequest, ClockReadResponse } from '../core/schemas/port-messages.ts';
+import type { PortMethod } from './port.ts';
+export type ClockPort = {
+    readonly read: PortMethod<ClockReadRequest, ClockReadResponse>;
+};
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export declare const clockReadParsers: {
+    readonly request: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+    readonly response: import("zod").ZodObject<{
+        now: import("zod").ZodISODateTime;
+    }, import("zod/v4/core").$strict>;
+};

package/dist/ports/clock-port.js

@@ -0,0 +1,7 @@
+/** AD-1 forbids a clock read under `core/`, so a timestamp arrives through this port. */
+import { ClockReadRequest, ClockReadResponse, } from '../core/schemas/port-messages.js';
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export const clockReadParsers = {
+    request: ClockReadRequest,
+    response: ClockReadResponse,
+};

package/dist/ports/corpus-port.d.ts

@@ -0,0 +1,16 @@
+/** AD-8's corpus-provider port: an opaque reference in, resolved bytes out. */
+import { CorpusResolveRequest, CorpusResolveResponse } from '../core/schemas/port-messages.ts';
+import type { PortMethod } from './port.ts';
+export type CorpusPort = {
+    readonly resolve: PortMethod<CorpusResolveRequest, CorpusResolveResponse>;
+};
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export declare const corpusResolveParsers: {
+    readonly request: import("zod").ZodObject<{
+        privateRef: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>;
+    readonly response: import("zod").ZodObject<{
+        privateRef: import("zod").ZodString;
+        bytes: import("zod").ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    }, import("zod/v4/core").$strict>;
+};

package/dist/ports/corpus-port.js

@@ -0,0 +1,7 @@
+/** AD-8's corpus-provider port: an opaque reference in, resolved bytes out. */
+import { CorpusResolveRequest, CorpusResolveResponse, } from '../core/schemas/port-messages.js';
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export const corpusResolveParsers = {
+    request: CorpusResolveRequest,
+    response: CorpusResolveResponse,
+};

package/dist/ports/environment-probe-port.d.ts

@@ -0,0 +1,76 @@
+/**
+ * AD-35's environment-probe port: a logical interface identifier in, one
+ * observation out. The request never names a URL, host, or port. Mapping the
+ * identifier to an authorized target is the adapter's job, from configuration
+ * outside the contract.
+ *
+ * Four rules an implementation MUST follow. Prose here because `ports/` holds
+ * no logic; `src/testing/probe-conformance.ts` is the executable half.
+ *
+ * 1. Apply the policy before any network call, and again to every redirect
+ *    target.
+ * 2. Issue the request against the address the policy validated
+ *    (`canonicalAddress`), keep the original host in the `Host` header, and
+ *    verify TLS against that host. Never re-resolve a hostname after
+ *    validation: re-resolving between the check and the connection is the
+ *    classic way past an allowlist like this one. Where a host resolves to
+ *    several addresses, validate each and connect only to a validated one.
+ * 3. A policy denial throws `forbidden-target`; a cap throws
+ *    `budget-exhausted`; an abort throws `aborted`; a transport failure throws
+ *    `port-failure`.
+ * 4. Every response the server returns is an observation, at any status. A 4xx
+ *    or 5xx resolves to a schema-valid `ProbeObservation`, since AD-10's
+ *    "every declared seeded fault being observed to fire" reads the status as
+ *    payload. Throw on a non-2xx and a seeded fault goes invisible, which
+ *    makes the whole pre-flight vacuous.
+ */
+import { ProbeObservation, ProbeRequest } from '../core/schemas/port-messages.ts';
+import type { PortMethod } from './port.ts';
+export type EnvironmentProbePort = {
+    readonly probe: PortMethod<ProbeRequest, ProbeObservation>;
+};
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export declare const probeParsers: {
+    readonly request: import("zod").ZodObject<{
+        probeId: import("zod").ZodString;
+        interfaceId: import("zod").ZodString;
+        operationId: import("zod").ZodString;
+        method: import("zod").ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            HEAD: "HEAD";
+            OPTIONS: "OPTIONS";
+            PATCH: "PATCH";
+            POST: "POST";
+            PUT: "PUT";
+        }>;
+        pathTemplate: import("zod").ZodString;
+        channels: import("zod").ZodObject<{
+            path: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>>;
+            query: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>>;
+            header: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"json">;
+                value: import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"absent">;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+    readonly response: import("zod").ZodObject<{
+        probeId: import("zod").ZodString;
+        interfaceId: import("zod").ZodString;
+        operationId: import("zod").ZodString;
+        status: import("zod").ZodInt;
+        headers: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            value: import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"text">;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"absent">;
+        }, import("zod/v4/core").$strict>], "kind">;
+    }, import("zod/v4/core").$strict>;
+};

package/dist/ports/environment-probe-port.js

@@ -0,0 +1,32 @@
+/**
+ * AD-35's environment-probe port: a logical interface identifier in, one
+ * observation out. The request never names a URL, host, or port. Mapping the
+ * identifier to an authorized target is the adapter's job, from configuration
+ * outside the contract.
+ *
+ * Four rules an implementation MUST follow. Prose here because `ports/` holds
+ * no logic; `src/testing/probe-conformance.ts` is the executable half.
+ *
+ * 1. Apply the policy before any network call, and again to every redirect
+ *    target.
+ * 2. Issue the request against the address the policy validated
+ *    (`canonicalAddress`), keep the original host in the `Host` header, and
+ *    verify TLS against that host. Never re-resolve a hostname after
+ *    validation: re-resolving between the check and the connection is the
+ *    classic way past an allowlist like this one. Where a host resolves to
+ *    several addresses, validate each and connect only to a validated one.
+ * 3. A policy denial throws `forbidden-target`; a cap throws
+ *    `budget-exhausted`; an abort throws `aborted`; a transport failure throws
+ *    `port-failure`.
+ * 4. Every response the server returns is an observation, at any status. A 4xx
+ *    or 5xx resolves to a schema-valid `ProbeObservation`, since AD-10's
+ *    "every declared seeded fault being observed to fire" reads the status as
+ *    payload. Throw on a non-2xx and a seeded fault goes invisible, which
+ *    makes the whole pre-flight vacuous.
+ */
+import { ProbeObservation, ProbeRequest, } from '../core/schemas/port-messages.js';
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export const probeParsers = {
+    request: ProbeRequest,
+    response: ProbeObservation,
+};