@agiledigital/pingone-aic-script-tester 0.1.0

package/dist/src/diagnostics.d.ts

@@ -0,0 +1,7 @@
+/** Failure records and log retrieval: what `aic-script-tester-show-log` is made of. */
+export { readFailures, sortNewestFirst } from "./harness/failures.ts";
+export type { FailureRecord } from "./harness/failures.ts";
+export { createDefaultIo, runShowLog } from "./harness/show-log.ts";
+export type { ShowLogIo, ShowLogOptions } from "./harness/show-log.ts";
+export { loadProviderModule } from "./provider-module.ts";
+export { projectRoot, stateDir, PROJECT_ENV, STATE_DIR_ENV } from "./project.ts";

package/dist/src/diagnostics.js

@@ -0,0 +1,5 @@
+/** Failure records and log retrieval: what `aic-script-tester-show-log` is made of. */
+export { readFailures, sortNewestFirst } from "./harness/failures.js";
+export { createDefaultIo, runShowLog } from "./harness/show-log.js";
+export { loadProviderModule } from "./provider-module.js";
+export { projectRoot, stateDir, PROJECT_ENV, STATE_DIR_ENV } from "./project.js";

package/dist/src/emit-dts.d.ts

@@ -0,0 +1,2 @@
+import type { ContextsDocument } from "./schema.ts";
+export declare function emitDts(doc: ContextsDocument): string;

package/dist/src/emit-dts.js

@@ -0,0 +1,82 @@
+import { assertIdent, pascal, tsParamName, tsType } from "./idents.js";
+import { classifyBinding, membersOf } from "./schema.js";
+const HEADER = `\
+// GENERATED from docs/api/bindings/scripted-decision-next.json — do not edit.
+// Re-run: npm -w packages/rhino-local run generate
+//
+// Case-authoring types for the scripted-decision mock surface. javaScriptType
+// values are mapped as-is (object → object, array → unknown[]); they do not
+// include the Rhino Java interop layer in src/scripts/templates/am/types/.
+// Every generated method throws at runtime until a later slice implements it.
+`;
+export function emitDts(doc) {
+    const interfaces = [];
+    const aggregate = ["export interface ScriptedDecisionMocks {"];
+    for (const binding of doc.bindings) {
+        const name = assertIdent(binding.name, "binding name");
+        const kind = classifyBinding(binding);
+        if (kind === "scalar") {
+            aggregate.push(`  ${name}: ${tsType(binding.javaScriptType)};`);
+            continue;
+        }
+        if (kind === "opaque") {
+            aggregate.push(`  ${name}: OpaqueBinding;`);
+            continue;
+        }
+        const iface = pascal(name);
+        interfaces.push(...emitInterface(iface, binding.elements, iface));
+        aggregate.push(`  ${name}: ${iface};`);
+    }
+    aggregate.push("}");
+    const opaque = [
+        "/**",
+        " * Binding whose contexts metadata lists an empty `elements` array.",
+        " * A test case seeds this object directly; the generator does not invent",
+        " * methods the JSON does not name.",
+        " */",
+        "export type OpaqueBinding = {",
+        "  [key: string]: unknown;",
+        "};",
+        "",
+    ];
+    return [HEADER, ...opaque, ...interfaces, ...aggregate, ""].join("\n");
+}
+function emitInterface(ifaceName, elements, typePrefix) {
+    const members = membersOf(elements);
+    const nested = [];
+    const body = [`export interface ${ifaceName} {`];
+    for (const member of members) {
+        const ident = assertIdent(member.name, `member of ${ifaceName}`);
+        if (member.kind === "field") {
+            const nestedName = `${typePrefix}${pascal(member.name)}`;
+            if (member.elements.length === 0) {
+                body.push(`  ${ident}: OpaqueBinding;`);
+            }
+            else {
+                nested.push(...emitInterface(nestedName, member.elements, nestedName));
+                body.push(`  ${ident}: ${nestedName};`);
+            }
+            continue;
+        }
+        for (const overload of member.overloads) {
+            body.push(methodSignature(ident, overload));
+        }
+    }
+    body.push("}", "");
+    return [...nested, ...body];
+}
+function methodSignature(name, overload) {
+    const params = overload.parameters.map((parameter) => `${tsParamName(parameter.name)}: ${tsType(parameter.javaScriptType)}`);
+    const ret = tsType(overload.returnType);
+    const oneLine = `  ${name}(${params.join(", ")}): ${ret};`;
+    if (oneLine.length <= 80) {
+        return oneLine;
+    }
+    const lines = [`  ${name}(`];
+    params.forEach((param, index) => {
+        const comma = index < params.length - 1 ? "," : "";
+        lines.push(`    ${param}${comma}`);
+    });
+    lines.push(`  ): ${ret};`);
+    return lines.join("\n");
+}

package/dist/src/emit-js.d.ts

@@ -0,0 +1,3 @@
+import type { ContextsDocument } from "./schema.ts";
+export declare const UNSEEDED_STRING = "__rhino-local-unseeded__";
+export declare function emitJs(doc: ContextsDocument): string;

package/dist/src/emit-js.js

@@ -0,0 +1,149 @@
+import { assertIdent } from "./idents.js";
+import { classifyBinding, membersOf, overloadLabel } from "./schema.js";
+export const UNSEEDED_STRING = "__rhino-local-unseeded__";
+const HEADER = `\
+// GENERATED from docs/api/bindings/scripted-decision-next.json — do not edit.
+// Re-run: npm -w packages/rhino-local run generate
+//
+// Evaluated by AM's Rhino 1.7.14 as part of the script-under-test's scope.
+// AM-safe JavaScript only: no let, no top-level const, no for...of, no object
+// shorthand, no destructuring, no default parameters, and none of Map / Set /
+// Symbol / Promise / WeakMap / WeakSet. See docs/api/12-script-bindings-matrix.md.
+`;
+const HELPERS = `\
+function __rhinoLocalArgKind(value) {
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  var t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean") {
+    return t;
+  }
+  return "object";
+}
+
+function __rhinoLocalNotMocked(binding, method, args, signatures) {
+  var arity = args.length;
+  var matched = [];
+  var i;
+  var j;
+  var sig;
+  var typesOk;
+  for (i = 0; i < signatures.length; i += 1) {
+    sig = signatures[i];
+    if (sig.arity !== arity) {
+      continue;
+    }
+    typesOk = true;
+    for (j = 0; j < arity; j += 1) {
+      if (__rhinoLocalArgKind(args[j]) !== sig.types[j]) {
+        typesOk = false;
+        break;
+      }
+    }
+    if (typesOk) {
+      matched.push(sig.label);
+    }
+  }
+  if (matched.length === 0) {
+    for (i = 0; i < signatures.length; i += 1) {
+      if (signatures[i].arity === arity) {
+        matched.push(signatures[i].label);
+      }
+    }
+  }
+  if (matched.length === 0) {
+    matched.push("no matching signature");
+  }
+  throw new Error(
+    "rhino-local: not mocked: " +
+      binding +
+      "." +
+      method +
+      " arity=" +
+      arity +
+      " overload=[" +
+      matched.join(" | ") +
+      "]"
+  );
+}
+`;
+export function emitJs(doc) {
+    const lines = [HEADER, HELPERS];
+    for (const binding of doc.bindings) {
+        lines.push(emitBinding(binding));
+    }
+    return lines.join("\n").replace(/\n+$/, "") + "\n";
+}
+function emitBinding(binding) {
+    const name = assertIdent(binding.name, "binding name");
+    const kind = classifyBinding(binding);
+    if (kind === "scalar") {
+        return `var ${name} = ${scalarLiteral(binding)};\n`;
+    }
+    if (kind === "opaque") {
+        return (`// Opaque container: the contexts metadata lists no elements. A case\n` +
+            `// seeds this object directly; a later slice may replace the assignment.\n` +
+            `var ${name} = {};\n`);
+    }
+    return `var ${name} = ${emitObject(binding.elements, name, 0)};\n`;
+}
+function scalarLiteral(binding) {
+    switch (binding.javaScriptType) {
+        case "string":
+            return JSON.stringify(UNSEEDED_STRING);
+        case "boolean":
+            return "false";
+        case "number":
+            return "NaN";
+        default:
+            throw new Error(`rhino-local: not a scalar javaScriptType: ${binding.javaScriptType}`);
+    }
+}
+function emitObject(elements, path, indent) {
+    const members = membersOf(elements);
+    if (members.length === 0) {
+        return "{}";
+    }
+    const pad = "  ".repeat(indent);
+    const inner = "  ".repeat(indent + 1);
+    const parts = ["{"];
+    for (const member of members) {
+        const ident = assertIdent(member.name, `member of ${path}`);
+        if (member.kind === "field") {
+            const nestedPath = `${path}.${member.name}`;
+            const value = member.elements.length === 0
+                ? "{}"
+                : emitObject(member.elements, nestedPath, indent + 1);
+            parts.push(`${inner}${ident}: ${value},`);
+            continue;
+        }
+        parts.push(`${inner}${ident}: ${emitMethod(path, member.overloads, indent + 1)},`);
+    }
+    parts.push(`${pad}}`);
+    return parts.join("\n");
+}
+function emitMethod(bindingPath, overloads, indent) {
+    const first = overloads[0];
+    if (!first) {
+        throw new Error(`rhino-local: method at ${bindingPath} has no overloads`);
+    }
+    const bodyPad = "  ".repeat(indent + 1);
+    const closePad = "  ".repeat(indent);
+    const sigPad = "  ".repeat(indent + 2);
+    const sigs = overloads.map((overload) => {
+        const arity = overload.parameters.length;
+        const types = JSON.stringify(overload.parameters.map((parameter) => parameter.javaScriptType));
+        const label = JSON.stringify(overloadLabel(overload));
+        return `{ arity: ${arity}, types: ${types}, label: ${label} }`;
+    });
+    const firstSig = sigs[0];
+    const sigBlock = sigs.length === 1 && firstSig
+        ? `[${firstSig}]`
+        : `[\n${sigs.map((sig) => `${sigPad}${sig},`).join("\n")}\n${bodyPad}]`;
+    return [
+        "function () {",
+        `${bodyPad}__rhinoLocalNotMocked(${JSON.stringify(bindingPath)}, ${JSON.stringify(first.name)}, arguments, ${sigBlock});`,
+        `${closePad}}`,
+    ].join("\n");
+}

package/dist/src/harness/failures.d.ts

@@ -0,0 +1,26 @@
+import type { AicTrace } from "../aic/trace.ts";
+export interface FailureRecord {
+    testName: string;
+    stem: string;
+    passIds: string[];
+    file: string;
+    suite: string;
+    timestamp: string;
+    tenant: string;
+}
+/**
+ * A local-only failure has no transaction id, and must not produce a record
+ * that would send `show-log` off to fetch nothing.
+ */
+export declare function failureRecordFor(input: {
+    trace: AicTrace | undefined;
+    testName: string;
+    file: string;
+    suite: string;
+    timestamp: string;
+}): FailureRecord | undefined;
+export declare function appendFailure(record: FailureRecord, path?: string): Promise<void>;
+export declare function recordFailureIfAny(input: Parameters<typeof failureRecordFor>[0], path?: string): Promise<FailureRecord | undefined>;
+export declare function readFailures(path?: string): Promise<FailureRecord[]>;
+export declare function parseFailures(text: string): FailureRecord[];
+export declare function sortNewestFirst(records: readonly FailureRecord[]): FailureRecord[];

package/dist/src/harness/failures.js

@@ -0,0 +1,113 @@
+import { appendFile, chmod, mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { isPlainObject } from "../case/util.js";
+import { failuresPath } from "../project.js";
+/**
+ * A local-only failure has no transaction id, and must not produce a record
+ * that would send `show-log` off to fetch nothing.
+ */
+export function failureRecordFor(input) {
+    const trace = input.trace;
+    if (trace === undefined || trace.stem.length === 0 || trace.passIds.length === 0) {
+        return undefined;
+    }
+    return {
+        testName: input.testName,
+        stem: trace.stem,
+        passIds: [...trace.passIds],
+        file: input.file,
+        suite: input.suite,
+        timestamp: input.timestamp,
+        tenant: trace.tenantName,
+    };
+}
+export async function appendFailure(record, path = failuresPath({ create: true })) {
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+    // `mode` applies only when the append creates the file.
+    await chmod(path, 0o600);
+}
+export async function recordFailureIfAny(input, path) {
+    const record = failureRecordFor(input);
+    if (record === undefined) {
+        return undefined;
+    }
+    await appendFailure(record, path ?? failuresPath({ create: true }));
+    return record;
+}
+export async function readFailures(path = failuresPath()) {
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isEnoent(error)) {
+            return [];
+        }
+        throw error;
+    }
+    return parseFailures(text);
+}
+export function parseFailures(text) {
+    const records = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (line.trim() === "") {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const record = asFailureRecord(parsed);
+        if (record !== undefined) {
+            records.push(record);
+        }
+    }
+    return records;
+}
+export function sortNewestFirst(records) {
+    return records
+        .map((record, index) => ({ record, index }))
+        .sort((a, b) => {
+        const time = b.record.timestamp.localeCompare(a.record.timestamp);
+        return time !== 0 ? time : b.index - a.index;
+    })
+        .map((row) => row.record);
+}
+function asFailureRecord(value) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    if (typeof value.testName !== "string" ||
+        typeof value.stem !== "string" ||
+        value.stem.length === 0 ||
+        !isStringArray(value.passIds) ||
+        value.passIds.length === 0 ||
+        typeof value.file !== "string" ||
+        typeof value.suite !== "string" ||
+        typeof value.timestamp !== "string" ||
+        typeof value.tenant !== "string") {
+        return undefined;
+    }
+    return {
+        testName: value.testName,
+        stem: value.stem,
+        passIds: value.passIds,
+        file: value.file,
+        suite: value.suite,
+        timestamp: value.timestamp,
+        tenant: value.tenant,
+    };
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isEnoent(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/src/harness/idm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Local `check()`/`cleanup()` handle and shared managed-path split. The tenant
+ * counterpart in `aic/idm.ts` imports only that path rule across the seam.
+ */
+import type { JsonObject } from "../case/types.ts";
+import type { FixtureSpec, IdmHandle } from "./types.ts";
+/** Local handle over one run's harvested managed store. */
+export declare function localIdmHandle(store: Record<string, JsonObject[]>, onDelete: (resource: string) => void): IdmHandle;
+/** `managed/alpha_user/alice` → [`managed/alpha_user`, `alice`]. */
+export declare function splitResource(resource: string): [string, string];
+/** Collapse a ledger into the `given.managed` shape the local lane seeds. */
+export declare function ledgerToManaged(ledger: readonly FixtureSpec[]): Record<string, JsonObject[]>;

package/dist/src/harness/idm.js

@@ -0,0 +1,44 @@
+/** Local handle over one run's harvested managed store. */
+export function localIdmHandle(store, onDelete) {
+    return {
+        read(resource) {
+            const [collection, id] = splitResource(resource);
+            const row = (store[collection] ?? []).find((entry) => entry._id === id);
+            return Promise.resolve(row ?? null);
+        },
+        query(type, filter) {
+            const rows = (store[type] ?? []).filter((row) => Object.entries(filter).every((entry) => JSON.stringify(row[entry[0]]) === JSON.stringify(entry[1])));
+            return Promise.resolve(rows);
+        },
+        delete(resource) {
+            const [collection, id] = splitResource(resource);
+            const rows = store[collection];
+            if (rows !== undefined) {
+                const index = rows.findIndex((entry) => entry._id === id);
+                if (index >= 0) {
+                    rows.splice(index, 1);
+                }
+            }
+            onDelete(resource);
+            return Promise.resolve();
+        },
+    };
+}
+/** `managed/alpha_user/alice` → [`managed/alpha_user`, `alice`]. */
+export function splitResource(resource) {
+    const cut = resource.lastIndexOf("/");
+    if (cut <= 0 || cut === resource.length - 1) {
+        throw new Error(`rhino-local: ${JSON.stringify(resource)} is not a managed record path (expected managed/<type>/<id>)`);
+    }
+    return [resource.slice(0, cut), resource.slice(cut + 1)];
+}
+/** Collapse a ledger into the `given.managed` shape the local lane seeds. */
+export function ledgerToManaged(ledger) {
+    const managed = {};
+    for (const fixture of ledger) {
+        const rows = managed[fixture.type] ?? [];
+        rows.push(fixture.record);
+        managed[fixture.type] = rows;
+    }
+    return managed;
+}

package/dist/src/harness/index.d.ts

@@ -0,0 +1,11 @@
+export { defineSuite, Lease, managed, RunBuilder } from "./lease.ts";
+export type { LeaseOptions, LeaseLane, LeaseLaneRunRequest, RunResult, StepResult, Suite, CheckContext, Check, LeaseLaneCheck, LeaseLaneHooks, } from "./lease.ts";
+export { carryGiven, submittedCallbacks } from "./step.ts";
+export type { CallbackReply, StepContext, StepExpect, StepSpec } from "./step.ts";
+export { aicWhenEnabled, AIC_LANE_ENV, useLease } from "./vitest.ts";
+export type { UseLeaseAicOptions, UseLeaseOptions } from "./vitest.ts";
+export { localIdmHandle, ledgerToManaged, splitResource } from "./idm.ts";
+export { describeResidue, findResidue } from "./residue.ts";
+export type { ResidueEntry } from "./residue.ts";
+export { applyInputsAndEsv, caseWithGiven, ESV_STATE_PREFIX, mergeChannels, normaliseWire, parseInputs, toCase, toGiven, } from "./spec.ts";
+export type * from "./types.ts";

package/dist/src/harness/index.js

@@ -0,0 +1,6 @@
+export { defineSuite, Lease, managed, RunBuilder } from "./lease.js";
+export { carryGiven, submittedCallbacks } from "./step.js";
+export { aicWhenEnabled, AIC_LANE_ENV, useLease } from "./vitest.js";
+export { localIdmHandle, ledgerToManaged, splitResource } from "./idm.js";
+export { describeResidue, findResidue } from "./residue.js";
+export { applyInputsAndEsv, caseWithGiven, ESV_STATE_PREFIX, mergeChannels, normaliseWire, parseInputs, toCase, toGiven, } from "./spec.js";

package/dist/src/harness/lease.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Framework-free local lease and the narrow lane port used by AIC. Tenant
+ * lifecycle and I/O stay in `aic/file-lease.ts`; this module hands the
+ * recorded local run and its bound check/cleanup hooks across that boundary.
+ */
+import type { z } from "zod";
+import type { ChainConformanceReport } from "../aic/conform.ts";
+import type { Case, CallbackEffect, Expect, JsonObject, RecordedEffects, Verdict } from "../case/types.ts";
+import type { RhinoRunner } from "../runner.ts";
+import { normaliseWire } from "./spec.ts";
+import type { StepSpec } from "./step.ts";
+import type { Channels, FixtureSpec, IdmHandle, RequestDraft, SuiteSpec, WireMap } from "./types.ts";
+export interface RunResult {
+    kase: Case;
+    effects: RecordedEffects;
+    verdict: Verdict;
+    /** Fixture provenance for the AIC lane; author-declared managed data has none. */
+    fixtures: readonly FixtureSpec[];
+    /**
+     * One entry per suspended pass, in order. Empty for a single-pass run.
+     * `aic/chainFromRunResult` consumes these recorded cases and submissions;
+     * the AIC lane must not reconstruct them from the final case.
+     */
+    steps: StepResult[];
+    /** Present when this lease automatically checked the completed run on AIC. */
+    conformance?: ChainConformanceReport;
+}
+/** One pass of a step chain: what it was asked, what it did, what was sent back. */
+export interface StepResult {
+    kase: Case;
+    effects: RecordedEffects;
+    verdict: Verdict;
+    /** Exactly what the next pass was handed as `given.callbacks`. */
+    submitted: CallbackEffect[];
+}
+export interface CheckContext<TInput> {
+    input: TInput;
+    effects: RecordedEffects;
+}
+export interface LeaseOptions {
+    runner: RhinoRunner;
+    timeoutMs?: number;
+    /** A test that deliberately leaves a record behind and asserts on it. */
+    allowResidue?: boolean;
+    /**
+     * How to name the run in failure messages. Supplied by the vitest adapter
+     * so this module stays framework-free — the residue check and the merge
+     * logic are worth unit-testing without a test runner in the way.
+     */
+    testName?: () => string;
+    /** Fixed tenant realm; the Vitest AIC adapter supplies it to both lanes. */
+    realm?: string;
+    /** Cross-feature port implemented by the tenant-aware AIC vertical. */
+    lane?: LeaseLane;
+}
+export interface LeaseLane {
+    run(request: LeaseLaneRunRequest): Promise<ChainConformanceReport>;
+    endTest(): Promise<void>;
+}
+export interface LeaseLaneRunRequest {
+    result: RunResult;
+    source: string;
+    hooks: LeaseLaneHooks;
+}
+export type Check<TInput> = (idm: IdmHandle, ctx: CheckContext<TInput>) => void | Promise<void>;
+export type LeaseLaneCheck = (idm: IdmHandle, effects: RecordedEffects) => void | Promise<void>;
+/** Hooks bound to parsed input but replayed with each lane's own effects/IDM. */
+export interface LeaseLaneHooks {
+    stepChecks: readonly (LeaseLaneCheck | undefined)[];
+    finalChecks: readonly LeaseLaneCheck[];
+    cleanup?: (idm: IdmHandle) => void | Promise<void>;
+}
+/**
+ * One test's run, assembled lazily.
+ *
+ * Deliberately NOT a thenable. A builder that is also a promise invites an
+ * `await` halfway through the chain, after which `.check()` is appending to a
+ * run that has already settled — a bug that reads as working code. Making
+ * `.expect()` the only terminal turns that whole class into a type error.
+ */
+export declare class RunBuilder<TInput> {
+    #private;
+    constructor(lease: Lease<z.ZodType>, testName: string, rawInput: unknown);
+    state(state: Channels["state"]): this;
+    esv(esv: Readonly<Record<string, string>>): this;
+    headers(headers: WireMap): this;
+    params(params: WireMap): this;
+    session(session: JsonObject): this;
+    /**
+     * Declare one suspended pass: what the script must send, what the client
+     * sends back, and what must be true of the world in between.
+     *
+     * Passes run in declaration order and the terminal `.expect()` judges the
+     * one after the last step, so a two-callback journey is two `.step()` calls
+     * and one `.expect()`. A step whose expectations fail aborts the chain
+     * rather than replying anyway: every later pass is seeded from this one, so
+     * continuing would report a cascade of failures that all trace back here.
+     */
+    step(spec: StepSpec<TInput>): this;
+    /** The same, for a chain built from data. */
+    steps(specs: readonly StepSpec<TInput>[]): this;
+    /** Assert against each lane's IDM store and response. Fail by throwing. */
+    check(fn: Check<TInput>): this;
+    /** The only terminal. */
+    expect(expected: Expect): Promise<RunResult>;
+}
+export declare class Lease<TSchema extends z.ZodType> {
+    #private;
+    constructor(spec: SuiteSpec<TSchema>, options: LeaseOptions);
+    /** Suite-scoped fixtures, created once before the first test. */
+    open(): void;
+    readonly fixtures: {
+        create: (type: string, record: JsonObject | JsonObject[]) => Promise<void>;
+    };
+    run(input?: z.input<TSchema>): RunBuilder<z.output<TSchema>>;
+    /**
+     * Drained after every test. The per-test ledger goes; the suite's stays
+     * until close(). Clearing only at teardown would let test 3 see test 1's
+     * records, which is the cross-test interference this design exists to
+     * remove.
+     */
+    endTest(): Promise<void>;
+    /** Suite teardown: drop what the suite created, alongside the journey. */
+    close(): Promise<void>;
+    ledger(): readonly FixtureSpec[];
+    execute(testName: string, rawInput: unknown, override: Channels, expected: Expect, checks: readonly Check<unknown>[], steps?: readonly StepSpec<unknown>[]): Promise<RunResult>;
+}
+export interface Suite<TSchema extends z.ZodType> {
+    spec: SuiteSpec<TSchema>;
+    lease(options: LeaseOptions): Lease<TSchema>;
+}
+export declare function defineSuite<TSchema extends z.ZodType>(spec: SuiteSpec<TSchema>): Suite<TSchema>;
+/** A managed record the suite creates once, for the whole file. */
+export declare function managed(type: string, record: JsonObject): FixtureSpec;
+export { normaliseWire };
+export type { RequestDraft, SuiteSpec };