@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/run/types.d.ts

@@ -0,0 +1,238 @@
+import type { BaselineEntry, BaselineFile } from "../baseline.ts";
+import type { Client } from "../../client/client.ts";
+import type { CheckSwitches, EntityConfig, OriginSpec, PayloadPolicy, ProfileSpec, QueryConfig, RateLimitSpec } from "../../config/types/config.ts";
+import type { Hooks, OutOfBandConfig, Uploads } from "../../config/types/hooks.ts";
+import type { PrincipalsConfig, SecurityConfig } from "../../config/types/security.ts";
+import type { CredentialStore } from "../../credentials/store.ts";
+import type { ExternalsConfig, Scenario } from "../../config/types/steps.ts";
+import type { FencedRequest } from "../fence.ts";
+import type { Finding, Inconclusive } from "../finding.ts";
+import type { NetworkKind } from "../../errors/network.ts";
+import type { SpoolOptions } from "../transcript/spool.ts";
+import type { KeptCredential, PersistedPrincipal } from "../principals.ts";
+import type { ProgressHandler } from "../progress/types.ts";
+import type { ScopeReport } from "../scope/types.ts";
+import type { SpecModel } from "../../spec/graph/types.ts";
+import type { SpecOverlay } from "../../spec/overlay.ts";
+import type { TargetVersion, TargetVersionSpec } from "../target-version.ts";
+import type { TeardownReport } from "../teardown/types.ts";
+export interface RunOptions {
+    spec: string;
+    baseUrl: string;
+    /** The config's principals, by id. */
+    principals: PrincipalsConfig;
+    /** The principal that writes; unset, the first of `principals`. */
+    writer?: string;
+    /** One recipe per scheme the document declares; see `ApiConfig.security`. */
+    security?: SecurityConfig;
+    /** Extra secret header names; see `ApiConfig.redact`. */
+    redact?: {
+        headers?: string[];
+    };
+    hooks?: Hooks;
+    uploads?: Uploads;
+    /** Directory of the config file — pool globs are resolved from here. */
+    configDir?: string;
+    seed?: number;
+    cohortSize?: number;
+    globalHeaders?: Record<string, string>;
+    /** The config's `cache`: `bypass: false` sends no cache bypass on reads. */
+    cache?: {
+        bypass?: boolean;
+    };
+    /** Entity names; each expands into the target set. */
+    only?: string[];
+    /**
+     * Target operationIds (`*` globs, `<originId>:` prefixes). With `only`, the union is graded and
+     * every other operation is support — called, never graded. Omit both for a full run.
+     */
+    ops?: string[];
+    /** Named profiles this run can select between. `"full"` and `"cheap"` exist without an entry. */
+    profiles?: Record<string, ProfileSpec>;
+    /** Active profile by name. Defaults to `"full"` — every operation runs, today's behavior. */
+    profile?: string;
+    /** Stops the run between checks; teardown and the result still follow. */
+    signal?: AbortSignal;
+    /** Per-run token for values that must not collide across runs. Random when omitted. */
+    nonce?: string;
+    /** Leaves created records in place. Useful when inspecting a failure by hand. */
+    keepFixtures?: boolean;
+    /** Returns the credential values the run held as `RunResult.credentials`; the CLI writes them outside the output directory. */
+    keepCredentials?: boolean;
+    /** Requests allowed in flight at once, across the whole run. */
+    maxInFlight?: number;
+    /** Paces requests per category. Checked before `x-rate-limit` tags for the same request. */
+    rateLimits?: RateLimitSpec[];
+    /** Requests per second to `baseUrl` in all; see `ApiConfig.maxRps`. */
+    maxRps?: number;
+    /** Non-fatal notes, such as an upload path that matched no file. The CLI prints them; unset, they are dropped. */
+    warn?: (message: string) => void;
+    /** Live status. Called on phase/entity/check/request; the CLI prints a heartbeat from this. */
+    onProgress?: ProgressHandler;
+    /** Extra hosts with their own OpenAPI. Auth stays on the primary. */
+    origins?: OriginSpec[];
+    /** Patches to the document, applied before the API tester reads it; see `ApiConfig.overlay`. */
+    overlay?: SpecOverlay;
+    /** The only operationIds the API tester may call; see `ApiConfig.allow`. */
+    allow?: string[];
+    /** See `ApiConfig.fence`. */
+    fence?: {
+        failRun?: boolean;
+    };
+    /** See `ApiConfig.teardown`. */
+    teardown?: {
+        verify?: boolean;
+    };
+    /** Known findings, as `testing api baseline` writes them; see `ApiConfig.baseline`. */
+    baseline?: BaselineFile;
+    /** Where the backend says which build it is; see `ApiConfig.targetVersion`. */
+    targetVersion?: TargetVersionSpec;
+    /** Declared flows for operations the matrix cannot reach. */
+    scenarios?: Scenario[];
+    /** Each scenario external's kind; see `ApiConfig.externals`. */
+    externals?: ExternalsConfig;
+    /** Backoff for `resolveOutOfBand` / `resolvePrincipalAuth`. */
+    outOfBand?: OutOfBandConfig;
+    /** How much of the payload catalog to send; see `ApiConfig.payloads`. */
+    payloads?: PayloadPolicy;
+    /** Checks switched on that do not run by default; see `ApiConfig.checks`. */
+    checks?: CheckSwitches;
+    /** Skip `teardownPrincipal` — used when this run is a secondary origin sharing accounts. */
+    skipPrincipalTeardown?: boolean;
+    /**
+     * Set when this run is a secondary origin's: the primary run's store, whose principals are already
+     * signed in, and the origin's `security` mapping. The primary validated the config against this
+     * document, and the primary revokes what the store minted.
+     */
+    sharedCredentials?: {
+        store: CredentialStore;
+        mapping: Readonly<Record<string, string>>;
+        /** The recipes no primary scheme declares, whose format and placements are an origin scheme's. */
+        originOnly: ReadonlySet<string>;
+    };
+    /** Global filter catalog defaults, and the filter grammar when the API tester cannot infer it. */
+    query?: QueryConfig;
+    /** Per-entity overlays. */
+    entities?: Record<string, EntityConfig>;
+    /**
+     * Persist every exchange under this run dir (`exchanges.jsonl`, `exchanges/`, `blobs/`).
+     * Omit to leave the journal off. The CLI decides the default from the profile.
+     */
+    exchangeDir?: string;
+    /**
+     * Where the run keeps its account ledger, rewritten before each account-making request is sent,
+     * so a run that dies still names every account it made. The CLI puts it in the run's folder as
+     * `accounts.json`. Omit to keep the ledger in memory only.
+     */
+    accountsFile?: string;
+    /**
+     * How much of the transcript's bodies each client keeps in memory (default 32 MiB), and where it
+     * spools the rest, encrypted (default the system's temporary directory). Removed when the run ends.
+     */
+    transcript?: SpoolOptions;
+    network?: {
+        /** The longest `Retry-After` a 429 or 503 is waited out for. Default 60_000. */
+        maxRetryAfterMs?: number;
+        retries?: number;
+        waitMs?: number;
+        /** Per-attempt abort. Default 180_000. `0` waits for the socket. */
+        requestTimeoutMs?: number;
+        /** The transport every request goes through. The global `fetch` unless given, e.g. an in-process app's handler. */
+        fetch?: typeof fetch;
+    };
+}
+/** One check's wall time on one entity. Its requests are counted from the transcript. */
+export interface CheckTiming {
+    check: string;
+    entity: string;
+    ms: number;
+}
+export interface RunResult {
+    findings: Finding[];
+    model: SpecModel;
+    client: Client;
+    entitiesTested: string[];
+    checksRun: string[];
+    /** Checks that never ran, and what each needed. A quiet run is only meaningful alongside it. */
+    checksSkipped: Array<{
+        check: string;
+        entity: string;
+        needs: string;
+    }>;
+    /**
+     * Checks that did not run because something they depend on was already reported broken.
+     *
+     * Recorded rather than dropped for the same reason skips are: suppression is correct — one
+     * root cause should produce one finding — but a suppressed check has *not* passed, and a
+     * report that shows only the root cause invites the reader to believe everything downstream
+     * was verified. It was not, and it must be re-run once the cause is fixed.
+     */
+    checksSuppressed: Array<{
+        check: string;
+        entity: string;
+        because: string;
+    }>;
+    /**
+     * Checks a targeted run did not run on an entity because none of their subjects is a target.
+     * Neither run nor skipped: the check could apply, this run was not asked to grade it.
+     */
+    checksOutOfScope: Array<{
+        check: string;
+        entity: string;
+    }>;
+    /** Checks that ran but could not reach a verdict — see `Inconclusive`. */
+    inconclusive: Inconclusive[];
+    /** How long each check took on each entity, start to finish. */
+    checkTimings: CheckTiming[];
+    /** What passing checks observed about policies the document leaves open. */
+    checkNotes: Array<{
+        check: string;
+        entity: string;
+        note: string;
+    }>;
+    /** Name of the profile that ran — `"full"` unless `--profile` / `config.profile` said otherwise. */
+    profile: string;
+    /** Operations a profile excluded, and why. Each also has a matching `profile.skip` gap finding. */
+    profileExclusions: Array<{
+        entity: string;
+        operationId: string;
+        reason: string;
+    }>;
+    /** What this run graded, per operation — targets only when targeted, every operation when full. */
+    scope: ScopeReport;
+    created: number;
+    teardown: TeardownReport | null;
+    /** Baseline entries no finding matched any more. Absent with no baseline. */
+    baseline?: {
+        fixed: BaselineEntry[];
+    };
+    /** The build this run tested, or why it could not be read. Absent when not configured. */
+    targetVersion?: TargetVersion;
+    /** Requests `hooks.beforeRequest` refused, and whether that alone fails the run. Absent with no hook. */
+    fenced?: {
+        requests: FencedRequest[];
+        failRun: boolean;
+    };
+    /**
+     * The principals as the run left them, with no credential value — written to
+     * `<outDir>/<datetime>/principals.json` by the CLI.
+     */
+    principals: PersistedPrincipal[];
+    /** The credential values the run held, with `keepCredentials` only. */
+    credentials?: KeptCredential[];
+    /** Set when the run was stopped before every entity was tested. */
+    interrupted?: boolean;
+    /** Journal size when `exchangeDir` was set. */
+    exchanges?: {
+        count: number;
+    };
+    /** Set when `fetch` never got an HTTP status — the run names the kind instead of crashing. */
+    network?: {
+        kind: NetworkKind;
+        attempts: number;
+        waitedMs: number;
+        incomplete: boolean;
+        url: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/api/runtime/run/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api/runtime/runs.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Each `testing api run` writes into a fresh timestamped folder so a later run does not
+ * overwrite the last report.
+ *
+ * Default root is `.testing/api/runs`. `--out` / `outDir` replace that root; the leaf is
+ * always `<root>/<datetime>/`. `latest` is a relative symlink at the root.
+ */
+export declare const DEFAULT_RUNS_ROOT = ".testing/api/runs";
+export declare const LATEST_LINK = "latest";
+/** UTC, filesystem-safe. `2026-08-18T14:30:05.123Z` → `2026-08-18T14-30-05Z`. */
+export declare function formatRunStamp(at: Date): string;
+export interface AllocatedRunDir {
+    /** Resolved history root (`--out` / `outDir` / default). */
+    root: string;
+    /** Fresh directory for this invocation's artifacts. */
+    runDir: string;
+    /** Folder name under `root` — the stamp, plus `-2` / `-3` on collision. */
+    stamp: string;
+    /** Path of the `latest` symlink (always `<root>/latest`). */
+    latest: string;
+    /**
+     * Undoes the allocation for a run that refused to start: removes `runDir`, and points `latest`
+     * back where it was, or removes it if there was none, when this run had moved it.
+     */
+    rollback: () => Promise<void>;
+}
+export declare function allocateRunDir(root?: string, at?: Date): Promise<AllocatedRunDir>;
+/**
+ * Moves `latest` to this run. Called once its reports are written: a run that crashed half-way
+ * must not become what `latest` shows.
+ */
+export declare function publishLatest(run: Pick<AllocatedRunDir, "root" | "stamp">): Promise<void>;
+//# sourceMappingURL=runs.d.ts.map

package/dist/api/runtime/runs.js

@@ -0,0 +1,80 @@
+/**
+ * Each `testing api run` writes into a fresh timestamped folder so a later run does not
+ * overwrite the last report.
+ *
+ * Default root is `.testing/api/runs`. `--out` / `outDir` replace that root; the leaf is
+ * always `<root>/<datetime>/`. `latest` is a relative symlink at the root.
+ */
+import { mkdir, readlink, rm, symlink } from "node:fs/promises";
+import { join, resolve } from "node:path";
+export const DEFAULT_RUNS_ROOT = ".testing/api/runs";
+export const LATEST_LINK = "latest";
+/** UTC, filesystem-safe. `2026-08-18T14:30:05.123Z` → `2026-08-18T14-30-05Z`. */
+export function formatRunStamp(at) {
+    return at
+        .toISOString()
+        .replaceAll(":", "-")
+        .replace(/\.\d{3}Z$/, "Z");
+}
+export async function allocateRunDir(root = DEFAULT_RUNS_ROOT, at = new Date()) {
+    const resolvedRoot = resolve(root);
+    await mkdir(resolvedRoot, { recursive: true });
+    const { dir: runDir, stamp } = await mkdirUnique(resolvedRoot, formatRunStamp(at));
+    const latest = join(resolvedRoot, LATEST_LINK);
+    const previous = await linkTarget(latest);
+    const rollback = async () => {
+        await rm(runDir, { force: true, recursive: true });
+        const now = await linkTarget(latest);
+        /* A junction reads back absolute on Windows; resolving compares either form. */
+        if (now === undefined || resolve(resolvedRoot, now) !== runDir)
+            return;
+        if (previous === undefined)
+            await rm(latest, { force: true });
+        else
+            await pointLatest(resolvedRoot, previous);
+    };
+    return { latest, rollback, root: resolvedRoot, runDir, stamp };
+}
+/** Where the `latest` link points; undefined when there is none, or it is not a link. */
+async function linkTarget(path) {
+    try {
+        return await readlink(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function mkdirUnique(root, base) {
+    let stamp = base;
+    let n = 2;
+    for (;;) {
+        const dir = join(root, stamp);
+        try {
+            await mkdir(dir);
+            return { dir, stamp };
+        }
+        catch (error) {
+            if (!isAlreadyExists(error))
+                throw error;
+            stamp = `${base}-${n}`;
+            n += 1;
+        }
+    }
+}
+/**
+ * Moves `latest` to this run. Called once its reports are written: a run that crashed half-way
+ * must not become what `latest` shows.
+ */
+export async function publishLatest(run) {
+    await pointLatest(run.root, run.stamp);
+}
+async function pointLatest(root, stamp) {
+    const latest = join(root, LATEST_LINK);
+    await rm(latest, { force: true, recursive: true });
+    /* Junctions work without admin on Windows; `dir` is the Unix equivalent. */
+    await symlink(stamp, latest, process.platform === "win32" ? "junction" : "dir");
+}
+function isAlreadyExists(error) {
+    return (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST");
+}
+//# sourceMappingURL=runs.js.map

package/dist/api/runtime/scenario/failure.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How a scenario stops: a step that failed, with what it sent and the operations it blames, or a
+ * run told to stop.
+ */
+import type { Exchange } from "../exchange.ts";
+export declare class StepFailure extends Error {
+    readonly evidence: Exchange[];
+    readonly blames: string[];
+    constructor(message: string, evidence: Exchange[], blames: string[]);
+}
+/** The run was told to stop: a step cut short is not a step that failed. */
+export declare class ScenarioStopped extends Error {
+    name: string;
+}
+/** What a step threw, as a failure: its own, or one with no evidence that blames nothing. */
+export declare function failureOf(error: unknown): StepFailure;
+/** The step's own operation, as the list a failure blames. */
+export declare function blamed(stepOp: string | undefined): string[];
+//# sourceMappingURL=failure.d.ts.map

package/dist/api/runtime/scenario/failure.js

@@ -0,0 +1,28 @@
+/**
+ * How a scenario stops: a step that failed, with what it sent and the operations it blames, or a
+ * run told to stop.
+ */
+export class StepFailure extends Error {
+    evidence;
+    blames;
+    constructor(message, evidence, blames) {
+        super(message);
+        this.evidence = evidence;
+        this.blames = blames;
+    }
+}
+/** The run was told to stop: a step cut short is not a step that failed. */
+export class ScenarioStopped extends Error {
+    name = "ScenarioStopped";
+}
+/** What a step threw, as a failure: its own, or one with no evidence that blames nothing. */
+export function failureOf(error) {
+    if (error instanceof StepFailure)
+        return error;
+    return new StepFailure(error instanceof Error ? error.message : String(error), [], []);
+}
+/** The step's own operation, as the list a failure blames. */
+export function blamed(stepOp) {
+    return stepOp === undefined ? [] : [stepOp];
+}
+//# sourceMappingURL=failure.js.map

package/dist/api/runtime/scenario/grade.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A scenario's grades: every covered operation it called passes on that call, a failing step
+ * fails the operations it blames, and what it never reached is blocked by that step.
+ */
+import type { StepFailure } from "./failure.ts";
+import type { ScenarioRun } from "./types.ts";
+/** Where a scenario stopped, and why. */
+export interface Stop {
+    index: number;
+    failure: StepFailure;
+}
+/** Each of `ids` the scenario called is graded by it and proved by its call. */
+export declare function proveCalled(run: ScenarioRun, ids: readonly string[], check: string): void;
+/**
+ * A finished scenario. A failing step blames its own operation whether or not the scenario covers
+ * it: a support step that fails (arming an account, setting the scene) must not stop the scenario
+ * in silence.
+ */
+export declare function gradeScenario(run: ScenarioRun, graded: readonly string[], stoppedAt: Stop | null): void;
+//# sourceMappingURL=grade.d.ts.map

package/dist/api/runtime/scenario/grade.js

@@ -0,0 +1,51 @@
+/**
+ * A scenario's grades: every covered operation it called passes on that call, a failing step
+ * fails the operations it blames, and what it never reached is blocked by that step.
+ */
+import { scenarioCheckId } from "./validate.js";
+/** Each of `ids` the scenario called is graded by it and proved by its call. */
+export function proveCalled(run, ids, check) {
+    const { grades } = run.input;
+    for (const id of ids) {
+        const call = run.calls.get(id);
+        if (call === undefined)
+            continue;
+        grades.graded([id], check);
+        const observation = run.observations.get(id);
+        grades.prove(id, observation === undefined ? { call: call.seq } : { call: call.seq, observation });
+    }
+}
+/**
+ * A finished scenario. A failing step blames its own operation whether or not the scenario covers
+ * it: a support step that fails (arming an account, setting the scene) must not stop the scenario
+ * in silence.
+ */
+export function gradeScenario(run, graded, stoppedAt) {
+    const { input, scenario } = run;
+    const check = scenarioCheckId(scenario);
+    const failedOps = new Set(stoppedAt?.failure.blames.filter((id) => graded.includes(id) || input.mode === "full" || input.inScope(id)) ?? []);
+    proveCalled(run, graded.filter((id) => !failedOps.has(id)), check);
+    if (stoppedAt === null)
+        return;
+    const where = `scenario "${scenario.id}" stopped at step ${stoppedAt.index + 1}`;
+    const { failure } = stoppedAt;
+    if (failedOps.size > 0) {
+        input.grades.graded([...failedOps], check);
+        input.findings
+            .attributed([...failedOps])
+            .ownedBy(check)
+            .backend(check, scenario.id, {
+            summary: `${where}: ${failure.message}`,
+            detail: failure.message,
+            evidence: failure.evidence,
+        });
+    }
+    const unreached = graded.filter((id) => !failedOps.has(id) && !run.calls.has(id));
+    if (unreached.length > 0) {
+        input.findings
+            .attributed(unreached)
+            .ownedBy(check)
+            .blocked(check, scenario.id, { summary: `${where} before calling it`, cause: `${where}: ${failure.message}` });
+    }
+}
+//# sourceMappingURL=grade.js.map

package/dist/api/runtime/scenario/lineage.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Which account each scope name descends from: a value a ledgered sign-up answered, or one a step
+ * saved after sending such a value. A self delete sent through a session carries no principal, so
+ * the names it sends are what tie it to the account it removed.
+ *
+ * A tag is the ledger's entry, held here only: it never enters the scope, an exchange or a report.
+ */
+import type { ScenarioRequestStep } from "../../config/types/steps.ts";
+import type { AccountEntry } from "../accounts/ledger.ts";
+import type { Exchange } from "../exchange.ts";
+/** By scope name, the account its value descends from. */
+export type Lineage = Map<string, AccountEntry>;
+/** What a scenario asks of the run's account ledger. */
+export interface ScenarioAccounts {
+    /** The entry whose sign-up `exchange` answered. */
+    madeBy: (exchange: Exchange) => AccountEntry | undefined;
+    /** The operation that deletes the caller's own account. */
+    deleteSelf: string;
+    /** `entry` deleted itself by `exchange`: settled, while the run still owes it. */
+    deletedItself: (entry: AccountEntry, exchange: Exchange) => void;
+}
+/** Every `{name}` the step's request sends. */
+export declare function referenced(step: ScenarioRequestStep): Set<string>;
+/**
+ * The account a step's answer descends from: the one its own sign-up made, else the one account
+ * every tagged name it sent descends from. Names from two accounts tag nothing.
+ */
+export declare function tagOf(lineage: Lineage, step: ScenarioRequestStep, made: AccountEntry | undefined): AccountEntry | undefined;
+/** Tags every name the step saved with `tag`; a name rebound with none no longer descends. */
+export declare function keep(lineage: Lineage, step: ScenarioRequestStep, tag: AccountEntry | undefined): void;
+/**
+ * A self delete the backend accepted, sent with no principal (through a session, say), settles the
+ * account its names descend from. One sent as a principal is the watch's to settle by that principal.
+ */
+export declare function selfDeleted(lineage: Lineage, sent: {
+    accounts: ScenarioAccounts | undefined;
+    step: ScenarioRequestStep;
+    exchange: Exchange;
+}): void;
+//# sourceMappingURL=lineage.d.ts.map

package/dist/api/runtime/scenario/lineage.js

@@ -0,0 +1,55 @@
+/**
+ * Which account each scope name descends from: a value a ledgered sign-up answered, or one a step
+ * saved after sending such a value. A self delete sent through a session carries no principal, so
+ * the names it sends are what tie it to the account it removed.
+ *
+ * A tag is the ledger's entry, held here only: it never enters the scope, an exchange or a report.
+ */
+import { placeholderNames } from "../../config/types/placeholder.js";
+/** Every `{name}` the step's request sends. */
+export function referenced(step) {
+    const path = "path" in step ? step.path : undefined;
+    return new Set(placeholderNames([path, step.body, step.headers, step.query, step.bind]));
+}
+/**
+ * The account a step's answer descends from: the one its own sign-up made, else the one account
+ * every tagged name it sent descends from. Names from two accounts tag nothing.
+ */
+export function tagOf(lineage, step, made) {
+    if (made !== undefined)
+        return made;
+    const carried = new Set();
+    for (const name of referenced(step)) {
+        const entry = lineage.get(name);
+        if (entry !== undefined)
+            carried.add(entry);
+    }
+    return carried.size === 1 ? [...carried][0] : undefined;
+}
+/** Tags every name the step saved with `tag`; a name rebound with none no longer descends. */
+export function keep(lineage, step, tag) {
+    const saved = [...Object.keys(step.saveAs ?? {}), ...Object.keys(step.saveClaimsFrom?.bind ?? {})];
+    for (const name of saved) {
+        if (tag === undefined)
+            lineage.delete(name);
+        else
+            lineage.set(name, tag);
+    }
+}
+/**
+ * A self delete the backend accepted, sent with no principal (through a session, say), settles the
+ * account its names descend from. One sent as a principal is the watch's to settle by that principal.
+ */
+export function selfDeleted(lineage, sent) {
+    const { accounts, step, exchange } = sent;
+    if (accounts === undefined || step.anonymous !== true)
+        return;
+    if (exchange.operationId !== accounts.deleteSelf)
+        return;
+    if (exchange.status < 200 || exchange.status >= 300)
+        return;
+    const entry = tagOf(lineage, step, undefined);
+    if (entry !== undefined)
+        accounts.deletedItself(entry, exchange);
+}
+//# sourceMappingURL=lineage.js.map

package/dist/api/runtime/scenario/poll.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A polled step's window and the wait between its sends.
+ */
+/** `"30s"`, `"500ms"`, `"2m"`. */
+export declare function durationMs(text: string): number;
+/** The wait before the next poll: doubling to five seconds, never shorter than the interval asked for. */
+export declare function nextPollWait(current: number, everyMs: number): number;
+/** The wait a run makes when no `sleep` is given. */
+export declare function wait(ms: number): Promise<void>;
+//# sourceMappingURL=poll.d.ts.map

package/dist/api/runtime/scenario/poll.js

@@ -0,0 +1,20 @@
+/**
+ * A polled step's window and the wait between its sends.
+ */
+/** `"30s"`, `"500ms"`, `"2m"`. */
+export function durationMs(text) {
+    const match = /^(\d+(?:\.\d+)?)(ms|s|m)$/.exec(text.trim());
+    if (match === null)
+        throw new Error(`testing api: "${text}" is not a duration (use 500ms, 30s or 2m)`);
+    const value = Number(match[1]);
+    return match[2] === "ms" ? value : match[2] === "s" ? value * 1000 : value * 60_000;
+}
+/** The wait before the next poll: doubling to five seconds, never shorter than the interval asked for. */
+export function nextPollWait(current, everyMs) {
+    return Math.min(current * 2, Math.max(5_000, everyMs));
+}
+/** The wait a run makes when no `sleep` is given. */
+export function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=poll.js.map

package/dist/api/runtime/scenario/record.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What a passing request step keeps: its call, the values it saves into scope, the claims it reads
+ * from a token, the account those values descend from, and the observation each of its asserts makes.
+ */
+import type { ScenarioAssert, ScenarioRequestStep } from "../../config/types/steps.ts";
+import type { Exchange } from "../exchange.ts";
+import type { ScenarioRun } from "./types.ts";
+import { type Want } from "./want.ts";
+/** A request step that passed, and what it asserted. */
+export interface Passed {
+    step: ScenarioRequestStep;
+    exchange: Exchange;
+    stepOp: string | undefined;
+    wants: Array<{
+        assert: ScenarioAssert;
+        want: Want;
+    }>;
+}
+export declare function record(run: ScenarioRun, passed: Passed): void;
+//# sourceMappingURL=record.d.ts.map