eval-quality 0.1.0

package/dist/ports/file-system-port.d.ts

@@ -0,0 +1,27 @@
+/** the file-system port: two methods, each a byte-level read or write at a caller-owned path. */
+import { FileReadRequest, FileReadResponse, FileWriteRequest, FileWriteResponse } from '../core/schemas/port-messages.ts';
+import type { PortMethod } from './port.ts';
+export type FileSystemPort = {
+    readonly readFile: PortMethod<FileReadRequest, FileReadResponse>;
+    readonly writeFile: PortMethod<FileWriteRequest, FileWriteResponse>;
+};
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export declare const fileReadParsers: {
+    readonly request: import("zod").ZodObject<{
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>;
+    readonly response: import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        bytes: import("zod").ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    }, import("zod/v4/core").$strict>;
+};
+export declare const fileWriteParsers: {
+    readonly request: import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        bytes: import("zod").ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    }, import("zod/v4/core").$strict>;
+    readonly response: import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        byteLength: import("zod").ZodInt;
+    }, import("zod/v4/core").$strict>;
+};

package/dist/ports/file-system-port.js

@@ -0,0 +1,11 @@
+/** the file-system port: two methods, each a byte-level read or write at a caller-owned path. */
+import { FileReadRequest, FileReadResponse, FileWriteRequest, FileWriteResponse, } from '../core/schemas/port-messages.js';
+/** the boundary parsers `application/` and the conformance suite validate with. */
+export const fileReadParsers = {
+    request: FileReadRequest,
+    response: FileReadResponse,
+};
+export const fileWriteParsers = {
+    request: FileWriteRequest,
+    response: FileWriteResponse,
+};

package/dist/ports/port.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AD-28's shared port contract shape: the one asynchronous method signature
+ * every port implements, plus the smallest structural parser interface
+ * `invokePort` needs for two-way boundary validation. No concrete port lives
+ * here. `CorpusPort`, `EnvironmentProbePort`, `ClockPort`, and
+ * `FileSystemPort` each sit in their own file beside this one and read
+ * `PortMethod` from it; their adapters are under `adapters/` and the
+ * conformance suite that checks an adapter against AD-37 is under `testing/`.
+ *
+ * Deliberately no Zod import: `BoundaryParser` is structural, so a Zod
+ * schema satisfies it without making `ports/` depend on the runtime
+ * validation library by name. `ports/` may import `core/schemas` only.
+ */
+export type BoundaryParseResult<Value> = {
+    readonly success: true;
+    readonly data: Value;
+} | {
+    readonly success: false;
+    readonly error: unknown;
+};
+export type BoundaryParser<Value> = {
+    readonly safeParse: (input: unknown) => BoundaryParseResult<Value>;
+};
+export type PortMethod<Request, Response> = (request: Request, signal: AbortSignal) => Promise<Response>;
+export type InvokePortOptions<Request, Response> = {
+    readonly request: unknown;
+    readonly requestParser: BoundaryParser<Request>;
+    readonly responseParser: BoundaryParser<Response>;
+    readonly port: PortMethod<Request, unknown>;
+    readonly signal: AbortSignal;
+    readonly requestPath: string;
+    readonly responsePath: string;
+};

package/dist/ports/port.js

@@ -0,0 +1,14 @@
+/**
+ * AD-28's shared port contract shape: the one asynchronous method signature
+ * every port implements, plus the smallest structural parser interface
+ * `invokePort` needs for two-way boundary validation. No concrete port lives
+ * here. `CorpusPort`, `EnvironmentProbePort`, `ClockPort`, and
+ * `FileSystemPort` each sit in their own file beside this one and read
+ * `PortMethod` from it; their adapters are under `adapters/` and the
+ * conformance suite that checks an adapter against AD-37 is under `testing/`.
+ *
+ * Deliberately no Zod import: `BoundaryParser` is structural, so a Zod
+ * schema satisfies it without making `ports/` depend on the runtime
+ * validation library by name. `ports/` may import `core/schemas` only.
+ */
+export {};

package/dist/testing/conformance.d.ts

@@ -0,0 +1,88 @@
+import type { ClockReadRequest, CorpusResolveRequest, FileReadRequest, FileWriteRequest } from '../core/schemas/port-messages.ts';
+import type { BoundaryParser } from '../ports/port.ts';
+export type ConformanceOutcome = {
+    /** `<method>/<assertion>`, e.g. `readFile/typed-fault`. Unique within a report. */
+    readonly id: string;
+    readonly title: string;
+    readonly passed: boolean;
+    readonly detail: string;
+};
+export type ConformancePort = 'corpus' | 'clock' | 'file-system' | 'environment-probe';
+/** how many outcomes a complete run of each port produces. Asserted as literals by fixture 58. */
+export declare const CONFORMANCE_OUTCOME_COUNTS: {
+    readonly corpus: 6;
+    readonly clock: 6;
+    readonly 'file-system': 12;
+    readonly 'environment-probe': 19;
+};
+export type ConformanceReport = {
+    readonly subject: string;
+    readonly port: ConformancePort;
+    readonly outcomes: readonly ConformanceOutcome[];
+    readonly passed: boolean;
+};
+export type ScenarioKind = 'resolves' | 'fails' | 'in-band-error' | 'hangs';
+export type BuiltSubject<Request> = {
+    readonly port: (request: Request, signal: AbortSignal) => Promise<unknown>;
+    readonly underlyingCalls: () => number;
+    readonly dispose?: () => Promise<void>;
+};
+export type PortSubject<Request> = {
+    readonly name: string;
+    readonly sampleRequest: Request;
+    /**
+     * A FRESH instance per scenario. The call counter must count the
+     * underlying mechanism (the filesystem call, the HTTP request), never the
+     * port invocation, or the retry assertion counts the wrong thing and
+     * passes for every adapter.
+     */
+    readonly build: (scenario: ScenarioKind) => Promise<BuiltSubject<Request>>;
+    /** how long "promptly" is for this subject. Default 1000. */
+    readonly abortBudgetMs?: number;
+};
+/** "Promptly" with no bound is unfalsifiable. One second clears any real adapter's abort latency and sits well inside a default test timeout. */
+export declare const DEFAULT_ABORT_BUDGET_MS = 1000;
+/**
+ * A thrown value read as AD-28's fault shape. Structural, not `instanceof`: a
+ * published suite can see a `RuntimeFault` from a second copy of this package.
+ * A plain `Error` fails it (fixture 45).
+ */
+export type FaultView = {
+    readonly code: string;
+    readonly artifactPath: string;
+};
+export declare function faultView(error: unknown): FaultView | undefined;
+export declare function describeThrown(error: unknown): string;
+/** For assertions carrying their own title. `probe-conformance.ts` is the only caller; `index.ts` re-exports none of this machinery. */
+export declare function titledOutcome(id: string, title: string, passed: boolean, detail: string): ConformanceOutcome;
+export type BuildResult<Request> = {
+    readonly ok: true;
+    readonly built: BuiltSubject<Request>;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+export declare function buildScenario<Request>(subject: PortSubject<Request>, scenario: ScenarioKind): Promise<BuildResult<Request>>;
+/** `undefined` when dispose succeeded or was absent; the throw's description otherwise. */
+export declare function disposeScenario<Request>(built: BuiltSubject<Request>): Promise<string | undefined>;
+/** A counter that throws is a broken subject. */
+export declare function countCalls<Request>(built: BuiltSubject<Request>): number | string;
+/** Folds a `dispose` throw into an outcome that had passed. */
+export declare function withDispose(base: ConformanceOutcome, disposeDetail: string | undefined): ConformanceOutcome;
+export type Settled = {
+    readonly kind: 'resolved';
+    readonly value: unknown;
+} | {
+    readonly kind: 'rejected';
+    readonly error: unknown;
+};
+export declare function settle(call: Promise<unknown>): Promise<Settled>;
+/** The six outcomes for one port method, in report order. */
+export declare function runSharedAssertions<Request>(prefix: string, subject: PortSubject<Request>, responseParser: BoundaryParser<unknown>): Promise<ConformanceOutcome[]>;
+/** The count is part of the verdict, so an empty or short outcome list cannot read as a pass. */
+export declare function reportOf(subject: string, port: ConformancePort, outcomes: readonly ConformanceOutcome[]): ConformanceReport;
+/** One line per outcome; this string is an adapter author's only view of a failure. A failure leads with `FAIL` and carries its detail. */
+export declare function formatConformanceReport(report: ConformanceReport): string;
+export declare function runCorpusPortConformance(subject: PortSubject<CorpusResolveRequest>): Promise<ConformanceReport>;
+export declare function runClockPortConformance(subject: PortSubject<ClockReadRequest>): Promise<ConformanceReport>;
+export declare function runFileSystemPortConformance(readSubject: PortSubject<FileReadRequest>, writeSubject: PortSubject<FileWriteRequest>): Promise<ConformanceReport>;

package/dist/testing/conformance.js

@@ -0,0 +1,281 @@
+/**
+ * AD-37's conformance suite: six assertions per port method, run against a
+ * caller-supplied subject.
+ *
+ * Imports no test runner. A published module that imported vitest would make
+ * it a runtime dependency, or fail to load for an adopter using something
+ * else. `scripts/dependency-direction.ts` enforces that.
+ *
+ * Imports no `core/probe/` either. A suite sharing the subject's decision
+ * procedure would pass any subject that shared it too.
+ */
+import { RUNTIME_FAULT_CODES } from '../core/schemas/faults.js';
+import { clockReadParsers } from '../ports/clock-port.js';
+import { corpusResolveParsers } from '../ports/corpus-port.js';
+import { fileReadParsers, fileWriteParsers } from '../ports/file-system-port.js';
+/** how many outcomes a complete run of each port produces. Asserted as literals by fixture 58. */
+export const CONFORMANCE_OUTCOME_COUNTS = {
+    corpus: 6,
+    clock: 6,
+    'file-system': 12,
+    'environment-probe': 19,
+};
+/** "Promptly" with no bound is unfalsifiable. One second clears any real adapter's abort latency and sits well inside a default test timeout. */
+export const DEFAULT_ABORT_BUDGET_MS = 1000;
+const TITLES = {
+    'typed-fault': 'a mechanism failure rejects with a declared RuntimeFault',
+    'single-underlying-call-on-success': 'exactly one underlying call on a successful invocation',
+    'single-underlying-call-on-failure': 'exactly one underlying call on a failing invocation (no internal retry)',
+    'prompt-abort': 'an aborted signal rejects promptly with code "aborted"',
+    'no-in-band-error': 'a value the response schema rejects throws rather than resolving',
+    'schema-valid-return': 'a successful invocation returns a schema-valid response',
+};
+/** The six ids in report order. Every port method emits all six, prefixed by its own name. */
+const SHARED_ASSERTION_IDS = [
+    'typed-fault',
+    'single-underlying-call-on-success',
+    'single-underlying-call-on-failure',
+    'prompt-abort',
+    'no-in-band-error',
+    'schema-valid-return',
+];
+export function faultView(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    const candidate = error;
+    const { code, artifactPath } = candidate;
+    if (typeof code !== 'string' || typeof artifactPath !== 'string') {
+        return undefined;
+    }
+    if (!RUNTIME_FAULT_CODES.some((declared) => declared === code)) {
+        return undefined;
+    }
+    return { code, artifactPath };
+}
+export function describeThrown(error) {
+    if (error instanceof Error)
+        return `${error.name}: ${error.message}`;
+    return `a non-Error value: ${String(error)}`;
+}
+function outcome(prefix, id, passed, detail) {
+    return {
+        id: `${prefix}/${id}`,
+        title: TITLES[id] ?? id,
+        passed,
+        detail,
+    };
+}
+/** For assertions carrying their own title. `probe-conformance.ts` is the only caller; `index.ts` re-exports none of this machinery. */
+export function titledOutcome(id, title, passed, detail) {
+    return { id, title, passed, detail };
+}
+export async function buildScenario(subject, scenario) {
+    try {
+        return { ok: true, built: await subject.build(scenario) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            detail: `build('${scenario}') threw ${describeThrown(error)}`,
+        };
+    }
+}
+/** `undefined` when dispose succeeded or was absent; the throw's description otherwise. */
+export async function disposeScenario(built) {
+    if (built.dispose === undefined)
+        return undefined;
+    try {
+        await built.dispose();
+        return undefined;
+    }
+    catch (error) {
+        return `dispose() threw ${describeThrown(error)}`;
+    }
+}
+/** A counter that throws is a broken subject. */
+export function countCalls(built) {
+    try {
+        return built.underlyingCalls();
+    }
+    catch (error) {
+        return `underlyingCalls() threw ${describeThrown(error)}`;
+    }
+}
+/** Folds a `dispose` throw into an outcome that had passed. */
+export function withDispose(base, disposeDetail) {
+    if (disposeDetail === undefined)
+        return base;
+    return {
+        ...base,
+        passed: false,
+        detail: `${base.detail}; ${disposeDetail}`,
+    };
+}
+export async function settle(call) {
+    try {
+        return { kind: 'resolved', value: await call };
+    }
+    catch (error) {
+        return { kind: 'rejected', error };
+    }
+}
+/**
+ * The `resolves` build, shared by two assertions: one underlying call, and a
+ * response the port schema accepts. The schema is the suite's, so a subject
+ * cannot widen what counts as valid.
+ */
+async function resolvesOutcomes(prefix, subject, responseParser) {
+    const run = await buildScenario(subject, 'resolves');
+    if (!run.ok) {
+        return [
+            outcome(prefix, 'single-underlying-call-on-success', false, run.detail),
+            outcome(prefix, 'schema-valid-return', false, run.detail),
+        ];
+    }
+    const settled = await settle(run.built.port(subject.sampleRequest, new AbortController().signal));
+    const calls = countCalls(run.built);
+    const disposeDetail = await disposeScenario(run.built);
+    const callOutcome = settled.kind === 'rejected'
+        ? outcome(prefix, 'single-underlying-call-on-success', false, `the 'resolves' scenario rejected with ${describeThrown(settled.error)}`)
+        : typeof calls === 'string'
+            ? outcome(prefix, 'single-underlying-call-on-success', false, calls)
+            : outcome(prefix, 'single-underlying-call-on-success', calls === 1, `underlyingCalls() was ${calls}, expected 1`);
+    const schemaOutcome = settled.kind === 'rejected'
+        ? outcome(prefix, 'schema-valid-return', false, `the 'resolves' scenario rejected with ${describeThrown(settled.error)}`)
+        : outcome(prefix, 'schema-valid-return', responseParser.safeParse(settled.value).success, 'the resolved value failed the port response schema');
+    return [
+        withDispose(callOutcome, disposeDetail),
+        withDispose(schemaOutcome, disposeDetail),
+    ];
+}
+/**
+ * The `fails` build, shared by two assertions. The second catches an internal
+ * retry: a retry happens on failure and not on success, so a single id would
+ * report a retrying adapter and a double-dispatching one identically.
+ */
+async function failsOutcomes(prefix, subject) {
+    const run = await buildScenario(subject, 'fails');
+    if (!run.ok) {
+        return [
+            outcome(prefix, 'typed-fault', false, run.detail),
+            outcome(prefix, 'single-underlying-call-on-failure', false, run.detail),
+        ];
+    }
+    const settled = await settle(run.built.port(subject.sampleRequest, new AbortController().signal));
+    const calls = countCalls(run.built);
+    const disposeDetail = await disposeScenario(run.built);
+    let typed;
+    if (settled.kind === 'resolved') {
+        typed = outcome(prefix, 'typed-fault', false, "the 'fails' scenario resolved instead of rejecting");
+    }
+    else {
+        const view = faultView(settled.error);
+        typed =
+            view === undefined
+                ? outcome(prefix, 'typed-fault', false, `rejected with ${describeThrown(settled.error)}, which carries no declared AD-28 code`)
+                : outcome(prefix, 'typed-fault', view.artifactPath.length > 0, `the ${view.code} fault carries an empty artifactPath`);
+    }
+    const callOutcome = typeof calls === 'string'
+        ? outcome(prefix, 'single-underlying-call-on-failure', false, calls)
+        : outcome(prefix, 'single-underlying-call-on-failure', calls === 1, `underlyingCalls() was ${calls}, expected 1; more than one is an internal retry, which AD-28 forbids`);
+    return [
+        withDispose(typed, disposeDetail),
+        withDispose(callOutcome, disposeDetail),
+    ];
+}
+/** The `hangs` build. The signal aborts once the call is in flight; a promise that never settles fails on the budget. */
+async function abortOutcome(prefix, subject) {
+    const run = await buildScenario(subject, 'hangs');
+    if (!run.ok)
+        return outcome(prefix, 'prompt-abort', false, run.detail);
+    const budgetMs = subject.abortBudgetMs ?? DEFAULT_ABORT_BUDGET_MS;
+    const controller = new AbortController();
+    // Handlers are attached before the abort, so a late rejection is never an
+    // unhandled one even when the budget wins the race.
+    const call = settle(run.built.port(subject.sampleRequest, controller.signal));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    controller.abort();
+    let timer;
+    const budget = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('budget-expired'), budgetMs);
+    });
+    const raced = await Promise.race([call, budget]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    const disposeDetail = await disposeScenario(run.built);
+    let result;
+    if (raced === 'budget-expired') {
+        result = outcome(prefix, 'prompt-abort', false, `the call had not settled ${budgetMs}ms after the signal aborted`);
+    }
+    else if (raced.kind === 'resolved') {
+        result = outcome(prefix, 'prompt-abort', false, 'the call resolved after the signal aborted instead of rejecting');
+    }
+    else {
+        const view = faultView(raced.error);
+        result = outcome(prefix, 'prompt-abort', view?.code === 'aborted', `rejected with ${view === undefined ? describeThrown(raced.error) : `code "${view.code}"`}, expected the "aborted" fault`);
+    }
+    return withDispose(result, disposeDetail);
+}
+/**
+ * The `in-band-error` build: AD-28's "a port never returns a partial success
+ * or an in-band error value". The code is left unpinned, since an adapter may
+ * recognize its own mechanism's error shape and throw `port-failure` first.
+ * Resolving fails.
+ */
+async function inBandOutcome(prefix, subject) {
+    const run = await buildScenario(subject, 'in-band-error');
+    if (!run.ok)
+        return outcome(prefix, 'no-in-band-error', false, run.detail);
+    const settled = await settle(run.built.port(subject.sampleRequest, new AbortController().signal));
+    const disposeDetail = await disposeScenario(run.built);
+    const result = settled.kind === 'resolved'
+        ? outcome(prefix, 'no-in-band-error', false, 'the in-band error value was returned instead of thrown')
+        : outcome(prefix, 'no-in-band-error', faultView(settled.error) !== undefined, `rejected with ${describeThrown(settled.error)}, which carries no declared AD-28 code`);
+    return withDispose(result, disposeDetail);
+}
+/** The six outcomes for one port method, in report order. */
+export async function runSharedAssertions(prefix, subject, responseParser) {
+    const gathered = [
+        ...(await resolvesOutcomes(prefix, subject, responseParser)),
+        ...(await failsOutcomes(prefix, subject)),
+        await abortOutcome(prefix, subject),
+        await inBandOutcome(prefix, subject),
+    ];
+    const byId = new Map(gathered.map((each) => [each.id, each]));
+    return SHARED_ASSERTION_IDS.map((id) => byId.get(`${prefix}/${id}`) ??
+        outcome(prefix, id, false, 'the suite produced no outcome for this id'));
+}
+/** The count is part of the verdict, so an empty or short outcome list cannot read as a pass. */
+export function reportOf(subject, port, outcomes) {
+    return {
+        subject,
+        port,
+        outcomes,
+        passed: outcomes.length === CONFORMANCE_OUTCOME_COUNTS[port] &&
+            outcomes.every((each) => each.passed),
+    };
+}
+/** One line per outcome; this string is an adapter author's only view of a failure. A failure leads with `FAIL` and carries its detail. */
+export function formatConformanceReport(report) {
+    const passes = report.outcomes.filter((each) => each.passed).length;
+    const header = `${report.passed ? 'PASS' : 'FAIL'} ${report.port} conformance for "${report.subject}": ${passes}/${report.outcomes.length} assertions passed`;
+    const lines = report.outcomes.map((each) => each.passed
+        ? `pass ${each.id}: ${each.title}`
+        : `FAIL ${each.id}: ${each.title} - ${each.detail}`);
+    return [header, ...lines].join('\n');
+}
+export async function runCorpusPortConformance(subject) {
+    return reportOf(subject.name, 'corpus', await runSharedAssertions('resolve', subject, corpusResolveParsers.response));
+}
+export async function runClockPortConformance(subject) {
+    return reportOf(subject.name, 'clock', await runSharedAssertions('read', subject, clockReadParsers.response));
+}
+export async function runFileSystemPortConformance(readSubject, writeSubject) {
+    const name = readSubject.name === writeSubject.name
+        ? readSubject.name
+        : `${readSubject.name} + ${writeSubject.name}`;
+    return reportOf(name, 'file-system', [
+        ...(await runSharedAssertions('readFile', readSubject, fileReadParsers.response)),
+        ...(await runSharedAssertions('writeFile', writeSubject, fileWriteParsers.response)),
+    ]);
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The `eval-quality/conformance` subpath: what an outside adapter author needs
+ * to implement a port and check the implementation.
+ *
+ * The boundary vocabulary is published here because this subpath is where AD-37
+ * puts the conformance definition an adapter author reads, and that author
+ * cannot implement `CorpusPort` without the type. The root barrel does not
+ * carry it.
+ *
+ * Type re-exports use `export type`; `biome.json` sets
+ * `style.useExportType: "error"`.
+ */
+export type { ClockReadRequest, ClockReadResponse, CorpusResolveRequest, CorpusResolveResponse, FileReadRequest, FileReadResponse, FileWriteRequest, FileWriteResponse, ProbeObservation, ProbeObservedBody, ProbeRequest, ProbeRequestBody, } from '../core/schemas/port-messages.ts';
+export type { ProbeTargetAuthorization, ProbeTargetPolicy, } from '../core/schemas/probe-policy.ts';
+export type { ClockPort } from '../ports/clock-port.ts';
+export { clockReadParsers } from '../ports/clock-port.ts';
+export type { CorpusPort } from '../ports/corpus-port.ts';
+export { corpusResolveParsers } from '../ports/corpus-port.ts';
+export type { EnvironmentProbePort } from '../ports/environment-probe-port.ts';
+export { probeParsers } from '../ports/environment-probe-port.ts';
+export type { FileSystemPort } from '../ports/file-system-port.ts';
+export { fileReadParsers, fileWriteParsers, } from '../ports/file-system-port.ts';
+export type { BuiltSubject, ConformanceOutcome, ConformancePort, ConformanceReport, PortSubject, ScenarioKind, } from './conformance.ts';
+export { CONFORMANCE_OUTCOME_COUNTS, formatConformanceReport, runClockPortConformance, runCorpusPortConformance, runFileSystemPortConformance, } from './conformance.ts';
+export type { ProbeSubject } from './probe-conformance.ts';
+export { runEnvironmentProbePortConformance } from './probe-conformance.ts';

package/dist/testing/index.js

@@ -0,0 +1,18 @@
+/**
+ * The `eval-quality/conformance` subpath: what an outside adapter author needs
+ * to implement a port and check the implementation.
+ *
+ * The boundary vocabulary is published here because this subpath is where AD-37
+ * puts the conformance definition an adapter author reads, and that author
+ * cannot implement `CorpusPort` without the type. The root barrel does not
+ * carry it.
+ *
+ * Type re-exports use `export type`; `biome.json` sets
+ * `style.useExportType: "error"`.
+ */
+export { clockReadParsers } from '../ports/clock-port.js';
+export { corpusResolveParsers } from '../ports/corpus-port.js';
+export { probeParsers } from '../ports/environment-probe-port.js';
+export { fileReadParsers, fileWriteParsers, } from '../ports/file-system-port.js';
+export { CONFORMANCE_OUTCOME_COUNTS, formatConformanceReport, runClockPortConformance, runCorpusPortConformance, runFileSystemPortConformance, } from './conformance.js';
+export { runEnvironmentProbePortConformance } from './probe-conformance.js';

package/dist/testing/probe-conformance.d.ts

@@ -0,0 +1,45 @@
+/**
+ * AD-35's thirteen extra assertions, for the environment-probe port only. The
+ * subject supplies its policy and one request per denial, since only it knows
+ * how its own interface-to-target mapping is wired.
+ *
+ * Each of the thirteen builds its own `'resolves'` subject and reads
+ * `underlyingCalls()` from a counter starting at zero, so every count below is
+ * absolute.
+ */
+import type { ProbeRequest } from '../core/schemas/port-messages.ts';
+import type { ProbeTargetPolicy } from '../core/schemas/probe-policy.ts';
+import type { ConformanceReport, PortSubject } from './conformance.ts';
+export type ProbeSubject = PortSubject<ProbeRequest> & {
+    readonly policy: ProbeTargetPolicy;
+    /** a request the policy ALLOWS, pointed at the subject's own fixture server. */
+    readonly authorizedRequest: ProbeRequest;
+    /** a request whose interfaceId the policy does not name at all. */
+    readonly unmappedRequest: ProbeRequest;
+    /** requests whose mapped target resolves into each denied class. */
+    readonly deniedAddressRequests: {
+        readonly loopback: ProbeRequest;
+        readonly private: ProbeRequest;
+        readonly linkLocal: ProbeRequest;
+        readonly metadata: ProbeRequest;
+    };
+    readonly unauthorizedMethodRequest: ProbeRequest;
+    readonly unauthorizedSchemeRequest: ProbeRequest;
+    /** answered with a redirect to a target the policy denies. */
+    readonly redirectingRequest: ProbeRequest;
+    /** answered with a chain of authorized redirects longer than `maxRedirects`. */
+    readonly overRedirectRequest: ProbeRequest;
+    /** answered past `maxResponseBytes`. */
+    readonly oversizeResponseRequest: ProbeRequest;
+    /** answered after `maxElapsedMs`. */
+    readonly slowRequest: ProbeRequest;
+    /** answered 500 by an authorized target. */
+    readonly faultingRequest: ProbeRequest;
+};
+/**
+ * Nineteen outcomes: the six shared assertions plus AD-35's thirteen.
+ * `maxRequestBytes` is the one cap with no assertion; the request shape is the
+ * suite's own, so the suite cannot make a subject emit an oversize request. It
+ * stays declared and adapter-enforced.
+ */
+export declare function runEnvironmentProbePortConformance(subject: ProbeSubject): Promise<ConformanceReport>;