cloving 1.2.0 → 1.4.0

package/dist/src/storage/command-wait-rows.js

@@ -0,0 +1,96 @@
+import { integer, optionalInteger, optionalText, text, } from "./domain-rows.js";
+import { upsert } from "./statements.js";
+export const commandWaitSchema = `
+CREATE TABLE command_waits (
+  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,
+  name TEXT NOT NULL,
+  command TEXT NOT NULL,
+  input_digest TEXT NOT NULL REFERENCES documents (digest) DEFERRABLE INITIALLY DEFERRED,
+  maximum_wait_seconds INTEGER NOT NULL,
+  poll_every_seconds INTEGER NOT NULL,
+  started_at INTEGER NOT NULL,
+  deadline INTEGER NOT NULL,
+  next_check_at INTEGER,
+  state TEXT NOT NULL,
+  settled_at INTEGER,
+  reason TEXT,
+  PRIMARY KEY (run_id, name)
+) STRICT;
+`;
+export const commandWaitCheckSchema = `
+ALTER TABLE command_waits ADD COLUMN check_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE command_waits ADD COLUMN check_operation TEXT;
+ALTER TABLE command_waits ADD COLUMN last_check_settled_at INTEGER;
+ALTER TABLE command_waits ADD COLUMN result TEXT;
+`;
+const openingColumns = "run_id, name, command, input_digest, maximum_wait_seconds, poll_every_seconds, started_at, deadline, next_check_at, state, settled_at, reason";
+const checkColumns = "check_count, check_operation, last_check_settled_at, result";
+const columns = `${openingColumns}, ${checkColumns}`;
+const save = upsert({
+    table: "command_waits",
+    names: columns.split(", "),
+    key: 2,
+});
+export function commandWaitRow(value) {
+    return {
+        runId: text(value, "run_id"),
+        name: text(value, "name"),
+        command: text(value, "command"),
+        inputDigest: text(value, "input_digest"),
+        maximumWaitSeconds: integer(value, "maximum_wait_seconds"),
+        pollEverySeconds: integer(value, "poll_every_seconds"),
+        startedAt: integer(value, "started_at"),
+        deadline: integer(value, "deadline"),
+        nextCheckAt: optionalInteger(value, "next_check_at"),
+        state: text(value, "state"),
+        checkCount: integer(value, "check_count"),
+        checkOperation: optionalText(value, "check_operation"),
+        lastCheckSettledAt: optionalInteger(value, "last_check_settled_at"),
+        result: optionalText(value, "result"),
+        settledAt: optionalInteger(value, "settled_at"),
+        reason: optionalText(value, "reason"),
+    };
+}
+export async function loadCommandWaits(connection, scope = {}) {
+    const { runId } = scope;
+    const selected = scope.version === "opened"
+        ? `${openingColumns}, 0 AS check_count, NULL AS check_operation, NULL AS last_check_settled_at, NULL AS result`
+        : columns;
+    const rows = await connection.all(`SELECT ${selected} FROM command_waits` +
+        (runId === undefined ? "" : " WHERE run_id = ?") +
+        " ORDER BY run_id, name", runId === undefined ? [] : [runId]);
+    return rows.map(commandWaitRow);
+}
+export function commandWaitStatements(rows, scope = {}) {
+    return rows.map((row) => ({
+        sql: scope.version === "opened"
+            ? upsert({
+                table: "command_waits",
+                names: openingColumns.split(", "),
+                key: 2,
+            })
+            : save,
+        parameters: [
+            row.runId,
+            row.name,
+            row.command,
+            row.inputDigest,
+            row.maximumWaitSeconds,
+            row.pollEverySeconds,
+            row.startedAt,
+            row.deadline,
+            row.nextCheckAt,
+            row.state,
+            row.settledAt,
+            row.reason,
+            ...(scope.version === "opened"
+                ? []
+                : [
+                    row.checkCount,
+                    row.checkOperation,
+                    row.lastCheckSettledAt,
+                    row.result,
+                ]),
+        ],
+    }));
+}

package/dist/src/storage/decision-snapshots.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitRow } from "./command-wait-rows.ts";
 import { type DecisionRows, type DocumentRow } from "./decision-rows.ts";
 import { type AttemptRow, type DomainSnapshot, type ProjectionRows, type SqlConnection } from "./domain-rows.ts";
 import { type EffectRows } from "./effect-rows.ts";
@@ -5,13 +6,20 @@ export interface ProjectionSnapshot extends ProjectionRows, DecisionRows {
     readonly deliveries: readonly AttemptRow[];
     readonly pending: readonly string[];
     readonly sequence: number;
+    readonly waits?: readonly CommandWaitRow[];
 }
 export interface DecidedSnapshot extends DomainSnapshot, DecisionRows {
     readonly documents: readonly DocumentRow[];
 }
-export interface CurrentSnapshot extends DecidedSnapshot {
+export interface EffectedSnapshot extends DecidedSnapshot {
     readonly effects: EffectRows;
 }
+export interface CurrentSnapshot extends EffectedSnapshot {
+    readonly waits: readonly CommandWaitRow[];
+}
+export declare function loadOperationSnapshot(connection: SqlConnection): Promise<Pick<ProjectionSnapshot, "outbox" | "deliveries">>;
 export declare function loadProjections(connection: SqlConnection): Promise<ProjectionSnapshot>;
 export declare function loadDecided(connection: SqlConnection): Promise<DecidedSnapshot>;
+export declare function loadEffected(connection: SqlConnection): Promise<EffectedSnapshot>;
 export declare function loadCurrent(connection: SqlConnection): Promise<CurrentSnapshot>;
+export declare function loadWaiting(connection: SqlConnection): Promise<CurrentSnapshot>;

package/dist/src/storage/decision-snapshots.js

@@ -1,8 +1,16 @@
+import { loadCommandWaits } from "./command-wait-rows.js";
 import { loadDecisions, loadDocuments, } from "./decision-rows.js";
-import { latestSequence, loadAttempts, loadSnapshot, projectionRows, text, } from "./domain-rows.js";
+import { latestSequence, loadAttempts, loadSnapshot, outboxRow, projectionRows, text, } from "./domain-rows.js";
 import { loadEffects } from "./effect-rows.js";
+export async function loadOperationSnapshot(connection) {
+    return {
+        outbox: (await connection.all("SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox ORDER BY created_sequence, rowid")).map(outboxRow),
+        deliveries: await loadAttempts(connection),
+    };
+}
 export async function loadProjections(connection) {
     return {
+        waits: await loadCommandWaits(connection),
         ...(await projectionRows(connection)),
         ...(await loadDecisions(connection)),
         deliveries: await loadAttempts(connection),
@@ -17,9 +25,21 @@ export async function loadDecided(connection) {
         documents: await loadDocuments(connection),
     };
 }
-export async function loadCurrent(connection) {
+export async function loadEffected(connection) {
     return {
         ...(await loadDecided(connection)),
         effects: await loadEffects(connection),
     };
 }
+export async function loadCurrent(connection) {
+    return {
+        ...(await loadEffected(connection)),
+        waits: await loadCommandWaits(connection),
+    };
+}
+export async function loadWaiting(connection) {
+    return {
+        ...(await loadEffected(connection)),
+        waits: await loadCommandWaits(connection, { version: "opened" }),
+    };
+}

package/dist/src/storage/domain-changes.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitRow } from "./command-wait-rows.ts";
 import { type DetailRow, type DocumentRow, type GateRow } from "./decision-rows.ts";
 import { type CommandRow, type DefinitionRow, type EventRow, type RunRow, type SqlConnection } from "./domain-rows.ts";
 import { type EffectRows } from "./effect-rows.ts";
@@ -37,6 +38,7 @@ export interface DomainChange extends EffectRows {
     readonly staged: readonly StagedDelivery[];
     readonly closed: readonly ClosedDelivery[];
     readonly gates: readonly GateRow[];
+    readonly waits: readonly CommandWaitRow[];
     readonly details: readonly DetailRow[];
     readonly documents: readonly DocumentRow[];
     readonly completesAdoption: boolean;

package/dist/src/storage/domain-changes.js

@@ -1,3 +1,4 @@
+import { commandWaitRow, commandWaitStatements, } from "./command-wait-rows.js";
 import { detailColumns, detailRow, documentRow, gateColumns, gateRow, } from "./decision-rows.js";
 import { commandRow, definitionRow, eventRow, integer, latestSequence, optionalInteger, optionalText, runRow, text, } from "./domain-rows.js";
 import { effectStatements } from "./effect-changes.js";
@@ -48,6 +49,7 @@ function statements(change) {
         ...deliveryStatements(change),
         ...decisionStatements(change),
         ...effectStatements(change),
+        ...commandWaitStatements(change.waits),
         ...(change.completesAdoption
             ? [
                 {
@@ -195,6 +197,7 @@ function parseChange(value) {
             receipt: optionalText(row, "receipt"),
         })),
         gates: list(value, "gates").map(gateRow),
+        waits: list(value, "waits").map(commandWaitRow),
         details: list(value, "details").map(detailRow),
         documents: list(value, "documents").map(documentRow),
         budgets: list(value, "budgets").map(budgetRow),

package/dist/src/storage/domain-schema.d.ts

@@ -2,7 +2,11 @@ import { type SqlConnection } from "./domain-rows.ts";
 export declare const baselineVersion = 1;
 export declare const adoptedVersion = 2;
 export declare const decidedVersion = 3;
-export declare const currentVersion = 4;
+export declare const effectedVersion = 4;
+export declare const waitingVersion = 5;
+export declare const checkedVersion = 6;
+export declare const spendingVersion = 7;
+export declare const currentVersion = 8;
 export declare const baselineSchema = "\nCREATE TABLE schema_migrations (\n  version INTEGER PRIMARY KEY,\n  checksum TEXT NOT NULL\n) STRICT;\nCREATE TABLE events (\n  sequence INTEGER PRIMARY KEY,\n  type TEXT NOT NULL,\n  run_id TEXT NOT NULL,\n  command_id TEXT NOT NULL UNIQUE,\n  recorded_at TEXT NOT NULL,\n  request TEXT NOT NULL,\n  payload TEXT NOT NULL\n) STRICT;\nCREATE TABLE definitions (\n  pin TEXT PRIMARY KEY,\n  manifest TEXT NOT NULL\n) STRICT;\nCREATE TABLE runs (\n  run_id TEXT PRIMARY KEY,\n  status TEXT NOT NULL,\n  revision INTEGER NOT NULL,\n  workflow TEXT NOT NULL REFERENCES definitions (pin) DEFERRABLE INITIALLY DEFERRED,\n  paused_from TEXT,\n  gates TEXT NOT NULL,\n  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE commands (\n  command_id TEXT PRIMARY KEY,\n  request TEXT NOT NULL,\n  sequence INTEGER NOT NULL UNIQUE REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE outbox (\n  operation_id TEXT PRIMARY KEY,\n  kind TEXT NOT NULL,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  created_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  released_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\n";
 export type SchemaRefusal = {
     readonly kind: "refused";
@@ -17,6 +21,14 @@ export type SchemaState = {
     readonly kind: "adopted";
 } | {
     readonly kind: "decided";
+} | {
+    readonly kind: "effected";
+} | {
+    readonly kind: "waiting";
+} | {
+    readonly kind: "checked";
+} | {
+    readonly kind: "indexed";
 } | {
     readonly kind: "current";
 } | SchemaRefusal;

package/dist/src/storage/domain-schema.js

@@ -1,11 +1,16 @@
 import { createHash, randomUUID } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 import { integer, optionalInteger, optionalText, text, } from "./domain-rows.js";
-import { effectSchema } from "./effect-schema.js";
+import { commandWaitSchema, commandWaitCheckSchema, } from "./command-wait-rows.js";
+import { effectSchema, spendingIndexes } from "./effect-schema.js";
 export const baselineVersion = 1;
 export const adoptedVersion = 2;
 export const decidedVersion = 3;
-export const currentVersion = 4;
+export const effectedVersion = 4;
+export const waitingVersion = 5;
+export const checkedVersion = 6;
+export const spendingVersion = 7;
+export const currentVersion = 8;
 export const baselineSchema = `
 CREATE TABLE schema_migrations (
   version INTEGER PRIMARY KEY,
@@ -102,9 +107,27 @@ CREATE TABLE documents (
   body TEXT NOT NULL
 ) STRICT;
 `;
-const schemas = [baselineSchema, adoption, decisions, effectSchema];
+const schemas = [
+    baselineSchema,
+    adoption,
+    decisions,
+    effectSchema,
+    commandWaitSchema,
+    commandWaitCheckSchema,
+    spendingIndexes,
+    "CREATE INDEX events_run_type_sequence ON events (run_id, type, sequence);",
+];
 const checksums = schemas.map((schema) => createHash("sha256").update(schema).digest("hex"));
-const versionKinds = ["baseline", "adopted", "decided", "current"];
+const versionKinds = [
+    "baseline",
+    "adopted",
+    "decided",
+    "effected",
+    "waiting",
+    "checked",
+    "indexed",
+    "current",
+];
 export async function inspectSchema(connection) {
     const version = integer(await connection.get("PRAGMA user_version"), "user_version");
     const detail = String(version);
@@ -132,6 +155,10 @@ export async function createSchema(connection) {
     await recordVersion(connection, baselineVersion);
     await adoptSchema(connection, null);
     await upgradeSchema(connection, decidedVersion);
+    await upgradeSchema(connection, effectedVersion);
+    await upgradeSchema(connection, waitingVersion);
+    await upgradeSchema(connection, checkedVersion);
+    await upgradeSchema(connection, spendingVersion);
     await upgradeSchema(connection, currentVersion);
 }
 export async function upgradeSchema(connection, version) {

package/dist/src/storage/effect-schema.d.ts

@@ -1 +1,2 @@
 export declare const effectSchema = "\nCREATE TABLE run_budgets (\n  run_id TEXT PRIMARY KEY REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  effect_limit INTEGER NOT NULL,\n  spent INTEGER NOT NULL CHECK (spent <= effect_limit),\n  capabilities TEXT NOT NULL,\n  exhausted_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE operations (\n  operation_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  capability TEXT NOT NULL,\n  method TEXT NOT NULL,\n  target TEXT NOT NULL,\n  payload TEXT NOT NULL,\n  input_digest TEXT NOT NULL,\n  units INTEGER NOT NULL,\n  lease_key TEXT NOT NULL,\n  recovery_limit INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  reason TEXT,\n  attempts INTEGER NOT NULL,\n  receipt TEXT,\n  worker TEXT,\n  result TEXT,\n  requested_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  wait_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  settled_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE INDEX operations_run ON operations (run_id);\nCREATE INDEX operations_waiting ON operations (wait_sequence) WHERE status = 'waiting';\nCREATE TABLE leases (\n  resource_key TEXT PRIMARY KEY,\n  operation_id TEXT NOT NULL REFERENCES operations (operation_id) DEFERRABLE INITIALLY DEFERRED,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  expires_at TEXT NOT NULL,\n  state TEXT NOT NULL CHECK (state IN ('held', 'expired', 'released')),\n  granted_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE INDEX leases_due ON leases (expires_at) WHERE state = 'held';\nCREATE TABLE effect_evidence (\n  sequence INTEGER PRIMARY KEY REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  run_id TEXT NOT NULL,\n  operation_id TEXT NOT NULL,\n  disposition TEXT NOT NULL,\n  reason TEXT\n) STRICT;\nCREATE TABLE stopped_operations (\n  operation_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE dispatch_attempts (\n  effect_id TEXT PRIMARY KEY REFERENCES deliveries (effect_id) DEFERRABLE INITIALLY DEFERRED,\n  purpose TEXT NOT NULL,\n  lease_generation INTEGER,\n  authority_epoch INTEGER NOT NULL\n) STRICT;\n";
+export declare const spendingIndexes = "\nCREATE INDEX events_spend_window ON events (julianday(recorded_at));\nCREATE INDEX operations_worker_settled ON operations (settled_sequence) WHERE capability = 'claude';\nCREATE INDEX operations_worker_open ON operations (requested_sequence) WHERE capability = 'claude' AND settled_sequence IS NULL AND status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled');\n";

package/dist/src/storage/effect-schema.js

@@ -57,3 +57,8 @@ CREATE TABLE dispatch_attempts (
   authority_epoch INTEGER NOT NULL
 ) STRICT;
 `;
+export const spendingIndexes = `
+CREATE INDEX events_spend_window ON events (julianday(recorded_at));
+CREATE INDEX operations_worker_settled ON operations (settled_sequence) WHERE capability = 'claude';
+CREATE INDEX operations_worker_open ON operations (requested_sequence) WHERE capability = 'claude' AND settled_sequence IS NULL AND status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled');
+`;

package/dist/src/submission.d.ts

@@ -5,6 +5,9 @@ export type SubmissionField = {
 } | {
     readonly type: "boolean";
     readonly optional?: boolean;
+} | {
+    readonly type: "ticket";
+    readonly optional?: boolean;
 } | {
     readonly type: "integer";
     readonly optional?: boolean;
@@ -15,6 +18,7 @@ export interface SubmissionContract {
     readonly maximumBytes: number;
     readonly fields: Readonly<Record<string, "string" | SubmissionField>>;
 }
+export declare function hasTicketField(contract: SubmissionContract | undefined): boolean;
 export type SubmissionCheck = {
     readonly kind: "valid";
     readonly normalized: string;

package/dist/src/submission.js

@@ -1,4 +1,8 @@
 import { record } from "./protocol.js";
+export function hasTicketField(contract) {
+    const rule = contract?.fields["ticket"];
+    return rule !== undefined && rule !== "string" && rule.type === "ticket";
+}
 function rejected(code, detail) {
     return { kind: "rejected", code, detail };
 }
@@ -14,11 +18,11 @@ function invalidField(contract, submission) {
     return Object.entries(contract.fields).find(([key, rule]) => {
         if (rule !== "string" && rule.optional && !Object.hasOwn(submission, key))
             return false;
-        return !validValue(rule, submission[key]);
+        return !validValue(rule === "string" ? { type: "string" } : rule, submission[key]);
     })?.[0];
 }
 function validValue(rule, value) {
-    if (rule === "string" || rule.type === "string")
+    if (rule.type === "string" || rule.type === "ticket")
         return typeof value === "string" && value.trim().length > 0;
     if (rule.type === "boolean")
         return typeof value === "boolean";

package/dist/src/testing-requests.d.ts

@@ -0,0 +1,15 @@
+import type { ProtectedRequest, GateRequest, HandoffRequest, RunWaitRequest, CommandWaitRequest } from "./step-bridge.ts";
+export type ScenarioRequest = readonly ["effect", ProtectedRequest] | readonly ["gate", GateRequest] | readonly ["waitForDecision", GateRequest] | readonly ["handoff", HandoffRequest] | readonly ["waitForRun", RunWaitRequest] | readonly ["waitForCommand", CommandWaitRequest] | readonly [
+    "sleep",
+    {
+        readonly seconds: number;
+    } | {
+        readonly until: string;
+    }
+];
+export interface ScenarioResult {
+    readonly spent?: number;
+    readonly outcome: unknown;
+    readonly requests: readonly ScenarioRequest[];
+}
+export declare function scenarioResult(value: unknown): value is ScenarioResult;

package/dist/src/testing-requests.js

@@ -0,0 +1,93 @@
+import { isInstant } from "./authority/instants.js";
+import { isCommandWaitRequest } from "./command-wait.js";
+import { record } from "./protocol.js";
+export function scenarioResult(value) {
+    const result = record(value);
+    return (result !== undefined &&
+        Object.hasOwn(result, "outcome") &&
+        Array.isArray(result["requests"]) &&
+        result["requests"].every(scenarioRequest) &&
+        (result["spent"] === undefined || typeof result["spent"] === "number"));
+}
+function scenarioRequest(value) {
+    if (!requestPair(value))
+        return false;
+    const request = record(value[1]);
+    if (request === undefined)
+        return false;
+    switch (value[0]) {
+        case "effect":
+            return protectedRequest(request);
+        case "gate":
+        case "waitForDecision":
+            return gateRequest(request);
+        case "handoff":
+            return handoffRequest(request);
+        case "waitForRun":
+            return runWaitRequest(request);
+        case "waitForCommand":
+            return isCommandWaitRequest(request);
+        case "sleep":
+            return sleepRequest(request);
+        default:
+            return false;
+    }
+}
+function requestPair(value) {
+    return Array.isArray(value) && value.length === 2;
+}
+function runWaitRequest(request) {
+    return (typeof request["runId"] === "string" &&
+        typeof request["maximumWaitSeconds"] === "number");
+}
+function sleepRequest(request) {
+    if (typeof request["until"] === "string")
+        return isInstant(request["until"]);
+    const seconds = request["seconds"];
+    return (typeof seconds === "number" &&
+        Number.isInteger(seconds) &&
+        seconds >= 1 &&
+        seconds <= 86400);
+}
+function gateRequest(request) {
+    return (typeof request["gateId"] === "string" &&
+        (request["kind"] === "question" || request["kind"] === "approval") &&
+        typeof request["prompt"] === "string" &&
+        optionalText(request["expiresAt"]));
+}
+function handoffRequest(request) {
+    const input = record(request["input"]);
+    return (typeof request["workflowId"] === "string" &&
+        input !== undefined &&
+        Object.values(input).every(handoffValue));
+}
+function protectedRequest(request) {
+    return (protectedScope(request["scope"]) &&
+        ["capability", "method", "target", "payload"].every((key) => typeof request[key] === "string") &&
+        typeof request["units"] === "number" &&
+        optionalText(request["resource"]));
+}
+function protectedScope(value) {
+    const scope = record(value);
+    if (scope === undefined)
+        return false;
+    const stage = record(scope["stage"]);
+    return (typeof scope["phase"] === "string" &&
+        typeof scope["operation"] === "string" &&
+        typeof scope["round"] === "number" &&
+        optionalText(scope["key"]) &&
+        (scope["stage"] === undefined ||
+            (stage !== undefined &&
+                ["id", "visit", "branch"].every((key) => typeof stage[key] === "string"))));
+}
+function optionalText(value) {
+    return value === undefined || typeof value === "string";
+}
+function handoffValue(value) {
+    if (value === null || ["string", "boolean", "number"].includes(typeof value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(handoffValue);
+    const fields = record(value);
+    return fields !== undefined && Object.values(fields).every(handoffValue);
+}

package/dist/src/testing.d.ts

@@ -0,0 +1,23 @@
+import { type ScenarioRequest, type ScenarioResult } from "./testing-requests.ts";
+import { type HandoffValue, type ProtectedResult, type GateResult, type DecisionResult, type RunWaitOutcome, type CommandWaitProgress } from "./step-bridge.ts";
+export interface StepScenario {
+    readonly commandWaits?: Readonly<Record<string, readonly CommandWaitProgress[]>>;
+    readonly turn?: ProtectedResult;
+    readonly effects?: Readonly<Record<string, readonly ProtectedResult[]>>;
+    readonly gate?: GateResult;
+    readonly waits?: readonly RunWaitOutcome[];
+    readonly decisions?: readonly DecisionResult[];
+    readonly effectLimit?: number;
+}
+export interface WorkflowScenario extends StepScenario {
+    readonly workflow: string;
+    readonly exportName: string;
+    readonly input: HandoffValue;
+}
+export type { ScenarioRequest, ScenarioResult } from "./testing-requests.ts";
+export declare function fakeStepBridge(scenario: StepScenario): {
+    requests: ScenarioRequest[];
+    readonly spent: number;
+    [Symbol.dispose](): void;
+};
+export declare function runScenario(scenario: WorkflowScenario): Promise<ScenarioResult>;