cloving 1.3.0 → 1.5.0

package/dist/src/service/service.js

@@ -4,17 +4,16 @@ import { authorityTiming, openAuthority, } from "../broker/actor/authority.js";
 import { socketAddress } from "../broker/socket-address.js";
 import {} from "../workflow-refusals.js";
 import { changeSignal } from "./changes.js";
-import { decision, questions } from "./decision-handler.js";
-import { events } from "./event-handler.js";
 import { expiryScan } from "./expiry.js";
 import { commandGateway, workerCommandBound } from "./gateway.js";
-import { workflowRegistry, } from "./registry.js";
-import { failed, queryMetadata } from "./replies.js";
-import { runCommand, status } from "./run-handlers.js";
-import { submissionHandler } from "./submission-handler.js";
+import { workflowCatalog, } from "./registry.js";
+import { reloadOperation } from "./workflow-reload.js";
+import { errorMessage, queryMetadata, } from "./replies.js";
+import { dispatcher } from "./dispatcher.js";
 import { connectionLimits, listen, reachable } from "./transport.js";
 import { workerPort } from "./worker-port.js";
 import { runWaitTarget } from "./run-waits.js";
+import { commandWaitPort } from "./command-waits.js";
 export const serviceTiming = {
     authority: authorityTiming,
     expiryScanMilliseconds: 1_000,
@@ -55,30 +54,17 @@ async function endpoint(directory) {
 function wallClock() {
     return new Date().toISOString();
 }
-function dispatcher(context) {
-    const run = submissionHandler(context);
-    const operations = new Map([
-        ["run", (request) => run(request.parameters)],
-        ["status", (request) => status(context, request.parameters)],
-        ["questions", (request) => questions(context, request.parameters)],
-        ["decision", (request) => decision(context, request.parameters)],
-        ["run-command", (request) => runCommand(context, request.parameters)],
-        [
-            "events",
-            (request, connection) => events(context, { parameters: request.parameters, connection }),
-        ],
-    ]);
-    return (request, connection) => {
-        const operation = operations.get(request.operation);
-        if (operation === undefined)
-            return Promise.resolve(failed("unknown-operation", {
-                detail: `The service has no operation ${request.operation}.`,
-            }));
-        return operation(request, connection);
+function catalogContext(options, catalog) {
+    return {
+        registry: catalog.registry,
+        workflowCatalog: catalog,
+        ...(options.reload === undefined
+            ? {}
+            : { reload: reloadOperation({ port: options.reload, catalog }) }),
     };
 }
 async function started(authority, setup) {
-    const { options, path, timing, registry, gateway, host } = setup;
+    const { options, path, timing, catalog, gateway, host } = setup;
     const clock = options.clock ?? wallClock;
     const { textBytes, documentBytes } = options.limits ?? serviceLimits;
     await rm(path, { force: true });
@@ -88,7 +74,7 @@ async function started(authority, setup) {
         limits: { idleMilliseconds: timing.idleMilliseconds },
         handle: dispatcher({
             authority,
-            registry,
+            ...catalogContext(options, catalog),
             ...queryMetadata(options),
             gateway,
             clock,
@@ -136,7 +122,8 @@ export async function startService(options) {
     if (typeof path !== "string")
         return path;
     const timing = options.timing ?? serviceTiming;
-    const registry = workflowRegistry(options.workflows, options);
+    const catalog = workflowCatalog(options);
+    const { registry } = catalog;
     const opening = await openAuthority(options.stateDirectory, {
         delivery: options.delivery,
         timing: timing.authority,
@@ -149,7 +136,7 @@ export async function startService(options) {
     const { authority } = opening;
     const gateway = serviceGateway(authority, { options, registry });
     const worker = workerPort({ gateway, authority });
-    const host = await hosted(options, hostPorts(authority, { worker, registry }));
+    const host = await hosted(options, hostPorts(authority, { worker, registry, gateway }));
     if (host.kind === "refused") {
         await authority.close();
         return host;
@@ -161,7 +148,7 @@ export async function startService(options) {
                 options,
                 path,
                 timing,
-                registry,
+                catalog,
                 gateway,
                 worker,
                 host: host.host,
@@ -169,8 +156,8 @@ export async function startService(options) {
         };
     }
     catch (error) {
-        const unclosed = await released(authority, host.host).then(() => "", (failure) => `; the close failed: ${message(failure)}`);
-        return refused("transport-failure", `${message(error)}${unclosed}`);
+        const unclosed = await released(authority, host.host).then(() => "", (failure) => `; the close failed: ${errorMessage(failure)}`);
+        return refused("transport-failure", `${errorMessage(error)}${unclosed}`);
     }
 }
 function serviceGateway(authority, parts) {
@@ -186,6 +173,7 @@ function serviceGateway(authority, parts) {
 function hostPorts(authority, parts) {
     const { worker, registry } = parts;
     return {
+        commandWait: commandWaitPort({ authority, gateway: parts.gateway }),
         runWait: {
             target: (runId) => runWaitTarget(authority, runId),
             observe: worker.observe,
@@ -217,14 +205,11 @@ function hostPorts(authority, parts) {
         },
     };
 }
-function message(error) {
-    return String(Reflect.get(Object(error), "message"));
-}
 async function hosted(options, ports) {
     try {
         return { kind: "started", host: await options.host?.(ports) };
     }
     catch (error) {
-        return refused("host-unavailable", message(error));
+        return refused("host-unavailable", errorMessage(error));
     }
 }

package/dist/src/service/submission-handler.js

@@ -7,6 +7,7 @@ import { documentDigest } from "../broker/decision-restore.js";
 import { record } from "../protocol.js";
 import { checkResolution, checkSubmission, hasTicketField, normalizedRequest, } from "../submission.js";
 import { activeWorkflow } from "./active-tickets.js";
+import { queueSpend } from "./queue-spend.js";
 import { committed, failed, invalidRequest, publicReceipt, rejection, result, } from "./replies.js";
 export function runIdentity(commandId) {
     return `run-${createHash("sha256").update(commandId).digest("hex").slice(0, 32)}`;
@@ -125,6 +126,9 @@ async function admit(context, admission) {
     const { input } = resolution;
     if (Buffer.byteLength(input) > context.documentBytes)
         return unresolved(context, { kind: "failure", commandId });
+    const held = await spendRefusal(context, admission);
+    if (held !== undefined)
+        return held;
     const receipt = await context.gateway.execute({
         principal: "operator",
         command: {
@@ -155,9 +159,20 @@ async function admit(context, admission) {
         replayed: receipt.kind === "duplicate",
     });
 }
+async function spendRefusal(context, admission) {
+    if (admission.workflow.manifest.queue !== true)
+        return undefined;
+    const spend = record((await queueSpend(context))["spend"]);
+    return spend?.["holding"] === true
+        ? failed("queue-spend-limit", {
+            commandId: admission.commandId,
+            detail: "Queue holding for spend limit.",
+        })
+        : undefined;
+}
 function admissionRefusal(workflow, request) {
-    const { workflowId, commandId, submission, activeTickets } = request;
-    const tickets = workflowId === "develop-issue" || hasTicketField(workflow.submission);
+    const { commandId, submission, activeTickets } = request;
+    const tickets = hasTicketField(workflow.submission);
     if (tickets &&
         typeof submission["ticket"] === "string" &&
         activeTickets.some((input) => input["ticketId"] === submission["ticket"]))
@@ -235,8 +250,7 @@ export function submissionHandler(context) {
     return (parameters) => {
         const keys = [`command:${String(parameters["commandId"])}`];
         const workflowId = String(parameters["workflowId"]);
-        if (workflowId === "develop-issue" ||
-            hasTicketField(context.registry.byId(workflowId)?.submission) ||
+        if (hasTicketField(context.registry.byId(workflowId)?.submission) ||
             context.registry.byId(workflowId)?.admission !== undefined)
             keys.push(`workflow:${workflowId}`);
         const next = () => submitted(context, parameters);

package/dist/src/service/worker-port.js

@@ -86,7 +86,7 @@ function effectPort(parts) {
                 command: {
                     kind: "report-effect",
                     ...rest,
-                    ...(result === undefined ? {} : { result: documentDigest(result) }),
+                    ...reportedResult({ result, worker: report.worker }),
                 },
                 documents: result === undefined ? [] : [result],
                 epoch: epoch ?? authority.epoch,
@@ -124,3 +124,11 @@ export function workerPort(parts) {
         ...effectPort(parts),
     };
 }
+function reportedResult(report) {
+    if (report.result === undefined)
+        return {};
+    return {
+        result: documentDigest(report.result),
+        ...(report.worker === "command" ? { commandOutput: report.result } : {}),
+    };
+}

package/dist/src/service/worker-totals.d.ts

@@ -1,3 +1,9 @@
+import { type Fields } from "../protocol.ts";
 import { type WorkerTotals } from "../worker-usage.ts";
 import type { ServiceContext } from "./replies.ts";
+export declare function reportFields(text: string | undefined): Fields;
 export declare function usageTotals(context: ServiceContext, runId: string): Promise<WorkerTotals>;
+export declare function turnDetailsOf(context: ServiceContext, run: {
+    readonly runId: string;
+    readonly totals: WorkerTotals;
+}): Promise<Fields>;

package/dist/src/service/worker-totals.js

@@ -1,6 +1,6 @@
 import { record } from "../protocol.js";
 import { priceOf, usageOf, attemptsOf, workerTotals, } from "../worker-usage.js";
-function reportFields(text) {
+export function reportFields(text) {
     try {
         return record(JSON.parse(text ?? "null")) ?? {};
     }
@@ -35,3 +35,10 @@ export async function usageTotals(context, runId) {
     }
     return workerTotals(turns);
 }
+export async function turnDetailsOf(context, run) {
+    const details = await context.turnDetails?.({
+        runId: run.runId,
+        operationIds: run.totals.workerTurns.map((turn) => turn.operationId),
+    });
+    return details === undefined ? {} : { turnDetails: details };
+}

package/dist/src/service/workflow-reload.d.ts

@@ -0,0 +1,35 @@
+import type { Fields, Reply } from "../protocol.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
+import type { Registry, WorkflowCatalog, WorkflowRegistration } from "./registry.ts";
+export interface SettingChanges {
+    readonly reloadedFields: readonly string[];
+    readonly restartFields: readonly string[];
+}
+export type WorkflowBundleReload = {
+    readonly kind: "reloaded";
+    readonly bundleDigest: string;
+    readonly workflows: readonly WorkflowRegistration[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+} | {
+    readonly kind: "unchanged";
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+} | {
+    readonly kind: "refused";
+    readonly code: string;
+    readonly detail: string;
+};
+export type WorkflowReload = (Exclude<WorkflowBundleReload, {
+    readonly kind: "refused";
+}> & SettingChanges) | Extract<WorkflowBundleReload, {
+    readonly kind: "refused";
+}>;
+export type WorkflowReloadPort = () => Promise<WorkflowReload>;
+export declare function workflowFields(context: {
+    readonly registry: Registry;
+    readonly workflowCatalog?: WorkflowCatalog;
+}): Fields;
+export declare function reloadOperation(parts: {
+    readonly port: WorkflowReloadPort;
+    readonly catalog: WorkflowCatalog;
+}): () => Promise<Reply>;
+export declare function reloadUnavailable(): Promise<Reply>;

package/dist/src/service/workflow-reload.js

@@ -0,0 +1,52 @@
+import { failed, result } from "./replies.js";
+export function workflowFields(context) {
+    const inventory = context.workflowCatalog?.inventory();
+    const stages = context.registry.workflowStages;
+    return {
+        ...(inventory?.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: inventory.bundleDigest }),
+        workflows: context.registry.workflowIds,
+        workflowRefusals: inventory?.workflowRefusals ?? [],
+        ...(Object.keys(stages).length === 0 ? {} : { workflowStages: stages }),
+    };
+}
+function applied(catalog, reload) {
+    if (reload.kind === "refused")
+        return failed(reload.code, { detail: reload.detail });
+    const previousBundleDigest = catalog.inventory().bundleDigest ?? null;
+    if (reload.kind === "reloaded")
+        catalog.replace(reload);
+    else
+        catalog.replaceRefusals(reload.workflowRefusals);
+    return result("reload", {
+        status: reload.kind,
+        previousBundleDigest,
+        bundleDigest: reload.kind === "reloaded" ? reload.bundleDigest : previousBundleDigest,
+        workflows: catalog.registry.workflowIds,
+        workflowRefusals: reload.workflowRefusals,
+        reloadedFields: reload.reloadedFields,
+        restartFields: reload.restartFields,
+    });
+}
+export function reloadOperation(parts) {
+    let reloading = false;
+    return async () => {
+        if (reloading)
+            return failed("reload-in-progress", {
+                detail: "A reload is in work. Wait for its reply.",
+            });
+        reloading = true;
+        try {
+            return applied(parts.catalog, await parts.port());
+        }
+        finally {
+            reloading = false;
+        }
+    };
+}
+export function reloadUnavailable() {
+    return Promise.resolve(failed("reload-unavailable", {
+        detail: "This service cannot reload the workflow files. Restart it to read them.",
+    }));
+}

package/dist/src/step-bridge.d.ts

@@ -64,6 +64,22 @@ export interface RunWaitOutcome {
     readonly reason: string | null;
     readonly promotionId: string | null;
 }
+export interface CommandWaitRequest {
+    readonly name: string;
+    readonly input: HandoffValue;
+}
+export type CommandWaitOutcome = {
+    readonly kind: "ready";
+    readonly value: HandoffValue;
+} | {
+    readonly kind: "timed-out" | "failed" | "refused" | "unavailable";
+    readonly reason: string;
+};
+export type CommandWaitProgress = CommandWaitOutcome | {
+    readonly kind: "pending";
+    readonly deadline: number;
+    readonly nextCheckAt: number;
+};
 export interface CommandRequest {
     readonly scope: ProtectedScope;
     readonly name: string;
@@ -80,6 +96,10 @@ export type GateResult = {
     readonly reason: string;
 };
 export interface StepBridge {
+    readonly openCommandWait?: (request: CommandWaitRequest) => Promise<CommandWaitProgress>;
+    readonly checkCommandWait?: (request: {
+        readonly name: string;
+    }) => Promise<CommandWaitProgress>;
     readonly effect: (request: ProtectedRequest) => Promise<ProtectedResult>;
     readonly gate: (request: GateRequest) => Promise<GateResult>;
     readonly waitForDecision?: (request: GateRequest) => Promise<DecisionWait>;

package/dist/src/steps/command-wait.d.ts

@@ -0,0 +1,12 @@
+import { type CommandWaitRequest, type CommandWaitProgress } from "../command-wait.ts";
+export declare function openCommandWait(request: CommandWaitRequest): Promise<CommandWaitProgress>;
+export declare namespace openCommandWait {
+    var maxRetries: number;
+}
+export declare function checkCommandWait(request: {
+    readonly name: string;
+}): Promise<CommandWaitProgress>;
+export declare namespace checkCommandWait {
+    var maxRetries: number;
+}
+export declare function commandWaitDate(milliseconds: number): Date;

package/dist/src/steps/command-wait.js

@@ -0,0 +1,26 @@
+import { isStepBridge, stepBridgeKey } from "../step-bridge.js";
+import { isCommandWaitRequest, } from "../command-wait.js";
+export async function openCommandWait(request) {
+    "use step";
+    if (!isCommandWaitRequest(request))
+        return { kind: "refused", reason: "invalid-command-wait-request" };
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.openCommandWait === undefined)
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.openCommandWait({
+        name: request.name,
+        input: request.input,
+    });
+}
+export async function checkCommandWait(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.checkCommandWait === undefined)
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.checkCommandWait({ name: request.name });
+}
+openCommandWait.maxRetries = 0;
+checkCommandWait.maxRetries = 0;
+export function commandWaitDate(milliseconds) {
+    return new Date(milliseconds);
+}

package/dist/src/steps/open-decision-wait.d.ts

@@ -0,0 +1,2 @@
+import { type GateRequest, type DecisionWait } from "../step-bridge.ts";
+export declare function openDecisionWait(request: GateRequest): Promise<DecisionWait>;

package/dist/src/steps/{decision-gate.js → open-decision-wait.js}

@@ -1,11 +1,4 @@
 import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
-export async function decisionGate(request) {
-    "use step";
-    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
-    if (!isStepBridge(bridge))
-        return { kind: "unavailable", reason: "cloving-host-unavailable" };
-    return await bridge.gate(request);
-}
 export async function openDecisionWait(request) {
     "use step";
     const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));

package/dist/src/steps/review-by-person.js

@@ -1,11 +1,14 @@
 import { snapshotReviewSubject } from "./review-subject.js";
 import { waitForDecision } from "./wait-for-decision.js";
 export async function reviewByPerson(request) {
+    let draft = "draft" in request.subject ? request.subject.draft : null;
+    if (draft !== null && request.subject.commit !== undefined)
+        draft = `${request.subject.commit}\n${draft}`;
     const snapshot = await snapshotReviewSubject(request.subject);
     const decision = await waitForDecision({
         gateId: `review:${snapshot.subjectDigest}`,
         kind: "approval",
-        prompt: `Review this subject:\n${snapshot.prompt}`,
+        prompt: `Review this subject:\n${draft ?? snapshot.prompt}`,
     });
     return {
         accepted: decision.decision === "approved",

package/dist/src/steps/wait-for-command.d.ts

@@ -0,0 +1,3 @@
+import { type CommandWaitRequest, type CommandWaitOutcome } from "../command-wait.ts";
+export type { CommandWaitRequest, CommandWaitOutcome, } from "../command-wait.ts";
+export declare function waitForCommand(request: CommandWaitRequest): Promise<CommandWaitOutcome>;

package/dist/src/steps/wait-for-command.js

@@ -0,0 +1,17 @@
+import { sleep } from "workflow";
+import { isCommandWaitRequest, } from "../command-wait.js";
+import { openCommandWait, checkCommandWait, commandWaitDate, } from "./command-wait.js";
+export async function waitForCommand(request) {
+    if (!isCommandWaitRequest(request))
+        return { kind: "refused", reason: "invalid-command-wait-request" };
+    let result = await openCommandWait({
+        name: request.name,
+        input: request.input,
+    });
+    while (result.kind === "pending") {
+        result = await checkCommandWait({ name: request.name });
+        if (result.kind === "pending")
+            await sleep(commandWaitDate(Math.min(result.deadline, result.nextCheckAt)));
+    }
+    return result;
+}

package/dist/src/steps/wait-for-decision.js

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { createHook } from "workflow";
-import { openDecisionWait } from "./decision-gate.js";
+import { openDecisionWait } from "./open-decision-wait.js";
 export async function waitForDecision(request) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {

package/dist/src/storage/command-wait-rows.d.ts

@@ -0,0 +1,30 @@
+import { type SqlConnection } from "./domain-rows.ts";
+import { type Statement } from "./statements.ts";
+export declare const commandWaitSchema = "\nCREATE TABLE command_waits (\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  name TEXT NOT NULL,\n  command TEXT NOT NULL,\n  input_digest TEXT NOT NULL REFERENCES documents (digest) DEFERRABLE INITIALLY DEFERRED,\n  maximum_wait_seconds INTEGER NOT NULL,\n  poll_every_seconds INTEGER NOT NULL,\n  started_at INTEGER NOT NULL,\n  deadline INTEGER NOT NULL,\n  next_check_at INTEGER,\n  state TEXT NOT NULL,\n  settled_at INTEGER,\n  reason TEXT,\n  PRIMARY KEY (run_id, name)\n) STRICT;\n";
+export declare const commandWaitCheckSchema = "\nALTER TABLE command_waits ADD COLUMN check_count INTEGER NOT NULL DEFAULT 0;\nALTER TABLE command_waits ADD COLUMN check_operation TEXT;\nALTER TABLE command_waits ADD COLUMN last_check_settled_at INTEGER;\nALTER TABLE command_waits ADD COLUMN result TEXT;\n";
+export interface CommandWaitRow {
+    readonly runId: string;
+    readonly name: string;
+    readonly command: string;
+    readonly inputDigest: string;
+    readonly maximumWaitSeconds: number;
+    readonly pollEverySeconds: number;
+    readonly startedAt: number;
+    readonly deadline: number;
+    readonly nextCheckAt: number | null;
+    readonly state: string;
+    readonly checkCount: number;
+    readonly checkOperation: string | null;
+    readonly lastCheckSettledAt: number | null;
+    readonly result: string | null;
+    readonly settledAt: number | null;
+    readonly reason: string | null;
+}
+export declare function commandWaitRow(value: unknown): CommandWaitRow;
+export declare function loadCommandWaits(connection: SqlConnection, scope?: {
+    readonly runId?: string;
+    readonly version?: "opened";
+}): Promise<readonly CommandWaitRow[]>;
+export declare function commandWaitStatements(rows: readonly CommandWaitRow[], scope?: {
+    readonly version?: "opened";
+}): readonly Statement[];

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,14 +6,19 @@ 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 declare function loadOperationSnapshot(connection: SqlConnection): Promise<Pick<ProjectionSnapshot, "outbox" | "deliveries">>;
+export interface CurrentSnapshot extends EffectedSnapshot {
+    readonly waits: readonly CommandWaitRow[];
+}
 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>;