cloving 0.3.20 → 1.0.1

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

@@ -0,0 +1,126 @@
+import { documentDigest } from "../broker/decision-restore.js";
+import { effectInputDigest } from "../broker/effect-restore.js";
+import { operationIdentity } from "../operation-identity.js";
+function reference(text) {
+    return typeof text === "string" ? documentDigest(text) : null;
+}
+function sequenceOf(receipt) {
+    const committed = receipt.kind === "accepted" || receipt.kind === "duplicate";
+    return committed ? receipt.sequence : undefined;
+}
+async function stored(authority, answer) {
+    const { receipt, operationId } = answer;
+    if (receipt.kind === "failed")
+        return { receipt, disposition: null, operation: null };
+    const sequence = sequenceOf(receipt);
+    try {
+        const disposition = sequence === undefined
+            ? undefined
+            : await authority.effects.disposition(sequence);
+        return {
+            receipt,
+            disposition: disposition ?? null,
+            operation: (await authority.effects.operation(operationId)) ?? null,
+        };
+    }
+    catch {
+        return { receipt, disposition: null, operation: null };
+    }
+}
+function texts(values) {
+    return values.every((value) => typeof value === "string");
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function unanswered(reason) {
+    return {
+        receipt: { kind: "rejected", reason },
+        disposition: null,
+        operation: null,
+    };
+}
+function effectPort(parts) {
+    const { gateway, authority } = parts;
+    return {
+        requestEffect: async (request) => {
+            if (!isObject(request))
+                return unanswered("invalid-command");
+            const { scope, payload, epoch, ...rest } = request;
+            if (!texts([payload, rest.capability, rest.method, rest.target]))
+                return unanswered("invalid-command");
+            const identity = operationIdentity({ ...scope, run: request.runId });
+            if (identity.kind !== "valid")
+                return unanswered(identity.reason);
+            const operationId = identity.value;
+            const digest = documentDigest(payload);
+            const receipt = await gateway.execute({
+                principal: "worker",
+                command: {
+                    kind: "request-effect",
+                    ...rest,
+                    operationId,
+                    payload: digest,
+                    inputDigest: effectInputDigest({
+                        capability: request.capability,
+                        method: request.method,
+                        target: request.target,
+                        payload: digest,
+                    }),
+                    recoveryLimit: authority.recoveryLimit,
+                },
+                documents: [payload],
+                epoch: epoch ?? authority.epoch,
+            });
+            return stored(authority, { receipt, operationId });
+        },
+        reportEffect: async (report) => {
+            if (!isObject(report))
+                return unanswered("invalid-command");
+            const { result, epoch, ...rest } = report;
+            const given = result === undefined ? [] : [result];
+            if (!texts([report.operationId, ...given]))
+                return unanswered("invalid-command");
+            const receipt = await gateway.execute({
+                principal: "worker",
+                command: {
+                    kind: "report-effect",
+                    ...rest,
+                    ...(result === undefined ? {} : { result: documentDigest(result) }),
+                },
+                documents: result === undefined ? [] : [result],
+                epoch: epoch ?? authority.epoch,
+            });
+            return stored(authority, {
+                receipt,
+                operationId: report.operationId,
+            });
+        },
+    };
+}
+export function workerPort(parts) {
+    const { gateway } = parts;
+    const submit = (command, documents) => gateway.execute({
+        principal: "worker",
+        command,
+        ...(documents === undefined ? {} : { documents }),
+    });
+    return {
+        submit,
+        started: (run) => submit({ kind: "mark-started", ...run }),
+        openGate: (opening) => {
+            const { kind, prompt, ...rest } = opening;
+            return submit({
+                kind: "open-gate",
+                ...rest,
+                gateKind: kind,
+                prompt: reference(prompt),
+            }, [prompt]);
+        },
+        registerWait: (wait) => submit({ kind: "register-wait", ...wait }),
+        observe: (report) => submit({ kind: "report-observation", ...report }),
+        completed: (run) => submit({ kind: "complete-run", ...run }),
+        failed: (run) => submit({ kind: "fail-run", ...run }),
+        ...effectPort(parts),
+    };
+}

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

@@ -0,0 +1,57 @@
+export declare const stepBridgeKey = "cloving.step-bridge/v1";
+export interface ProtectedScope {
+    readonly phase: string;
+    readonly operation: string;
+    readonly round: number;
+    readonly key?: string;
+    readonly stage?: {
+        readonly id: string;
+        readonly visit: string;
+        readonly branch: string;
+    };
+}
+export interface ProtectedRequest {
+    readonly scope: ProtectedScope;
+    readonly capability: string;
+    readonly method: string;
+    readonly target: string;
+    readonly payload: string;
+    readonly units: number;
+    readonly resource?: string;
+}
+export type ProtectedResult = {
+    readonly kind: "completed";
+    readonly operationId: string;
+    readonly receipt: string | null;
+    readonly result: string | null;
+} | {
+    readonly kind: "failed" | "stopped" | "blocked" | "cancelled";
+    readonly operationId: string;
+    readonly reason: string | null;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+} | {
+    readonly kind: "unavailable";
+    readonly reason: string;
+};
+export interface GateRequest {
+    readonly gateId: string;
+    readonly kind: "question" | "approval";
+    readonly prompt: string;
+}
+export type GateResult = {
+    readonly kind: "opened";
+    readonly decisionId: string;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+} | {
+    readonly kind: "unavailable";
+    readonly reason: string;
+};
+export interface StepBridge {
+    readonly effect: (request: ProtectedRequest) => Promise<ProtectedResult>;
+    readonly gate: (request: GateRequest) => Promise<GateResult>;
+}
+export declare function isStepBridge(value: unknown): value is StepBridge;

package/dist/src/step-bridge.js

@@ -0,0 +1,4 @@
+export const stepBridgeKey = "cloving.step-bridge/v1";
+export function isStepBridge(value) {
+    return ["effect", "gate"].every((member) => typeof Reflect.get(Object(value), member) === "function");
+}

package/dist/src/steps/decision-gate.d.ts

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

package/dist/src/steps/decision-gate.js

@@ -0,0 +1,8 @@
+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);
+}

package/dist/src/steps/load-cycle.d.ts

@@ -0,0 +1,10 @@
+import type { DevelopmentInput } from "../workflow-contracts.ts";
+export type CycleLoad = {
+    readonly kind: "unavailable";
+    readonly reason: "cloving-host-unavailable";
+    readonly cycleId: string;
+} | {
+    readonly kind: "invalid";
+    readonly reason: "invalid-development-input";
+};
+export declare function loadCycle(input: DevelopmentInput): Promise<CycleLoad>;

package/dist/src/steps/load-cycle.js

@@ -0,0 +1,11 @@
+import { validateDevelopmentInput } from "../workflow-contracts.js";
+export async function loadCycle(input) {
+    "use step";
+    return Promise.resolve(validateDevelopmentInput(input).kind === "invalid"
+        ? { kind: "invalid", reason: "invalid-development-input" }
+        : {
+            kind: "unavailable",
+            reason: "cloving-host-unavailable",
+            cycleId: input.cycleId,
+        });
+}

package/dist/src/steps/protected-effect.d.ts

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

package/dist/src/steps/protected-effect.js

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

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

@@ -0,0 +1,54 @@
+import { type SqlConnection } from "./domain-rows.ts";
+export interface GateRow {
+    readonly runId: string;
+    readonly gateId: string;
+    readonly kind: string;
+    readonly label: number | null;
+    readonly subject: string | null;
+    readonly prompt: string | null;
+    readonly expiresAt: string | null;
+    readonly generation: number;
+    readonly revision: number;
+    readonly wait: string;
+    readonly decision: string | null;
+    readonly answer: string | null;
+    readonly decidedSequence: number | null;
+    readonly openedSequence: number;
+    readonly continuation: string | null;
+}
+export interface DetailRow {
+    readonly runId: string;
+    readonly generation: number;
+    readonly submission: string | null;
+    readonly input: string | null;
+    readonly resolver: string | null;
+    readonly condition: string | null;
+    readonly reason: string | null;
+    readonly evidence: string | null;
+    readonly retryAt: string | null;
+    readonly attempt: number | null;
+    readonly attemptLimit: number | null;
+    readonly observedSequence: number | null;
+    readonly observedAt: string | null;
+    readonly observedOperation: string | null;
+}
+export interface DocumentRow {
+    readonly digest: string;
+    readonly body: string;
+}
+export interface DecisionRows {
+    readonly gates: readonly GateRow[];
+    readonly details: readonly DetailRow[];
+}
+export declare const gateColumns = "run_id, gate_id, kind, label, subject, prompt, expires_at, generation, revision, wait, decision, answer, decided_sequence, opened_sequence, continuation";
+export declare const detailColumns = "run_id, generation, submission, input, resolver, condition, reason, evidence, retry_at, attempt, attempt_limit, observed_sequence, observed_at, observed_operation";
+export declare function gateRow(row: unknown): GateRow;
+export declare function detailRow(row: unknown): DetailRow;
+export declare function documentRow(row: unknown): DocumentRow;
+export declare function loadDecisions(connection: SqlConnection): Promise<DecisionRows>;
+export declare function loadDocuments(connection: SqlConnection): Promise<readonly DocumentRow[]>;
+export declare function runDecisions(connection: SqlConnection, runId: string): Promise<DecisionRows & {
+    readonly questions: number;
+}>;
+export declare function storedDigests(connection: SqlConnection, digests: readonly string[]): Promise<readonly string[]>;
+export declare function documentBody(connection: SqlConnection, digest: string): Promise<string | undefined>;

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

@@ -0,0 +1,72 @@
+import { integer, optionalInteger, optionalText, text, } from "./domain-rows.js";
+export const gateColumns = "run_id, gate_id, kind, label, subject, prompt, expires_at, generation, revision, wait, decision, answer, decided_sequence, opened_sequence, continuation";
+export const detailColumns = "run_id, generation, submission, input, resolver, condition, reason, evidence, retry_at, attempt, attempt_limit, observed_sequence, observed_at, observed_operation";
+export function gateRow(row) {
+    return {
+        runId: text(row, "run_id"),
+        gateId: text(row, "gate_id"),
+        kind: text(row, "kind"),
+        label: optionalInteger(row, "label"),
+        subject: optionalText(row, "subject"),
+        prompt: optionalText(row, "prompt"),
+        expiresAt: optionalText(row, "expires_at"),
+        generation: integer(row, "generation"),
+        revision: integer(row, "revision"),
+        wait: text(row, "wait"),
+        decision: optionalText(row, "decision"),
+        answer: optionalText(row, "answer"),
+        decidedSequence: optionalInteger(row, "decided_sequence"),
+        openedSequence: integer(row, "opened_sequence"),
+        continuation: optionalText(row, "continuation"),
+    };
+}
+export function detailRow(row) {
+    return {
+        runId: text(row, "run_id"),
+        generation: integer(row, "generation"),
+        submission: optionalText(row, "submission"),
+        input: optionalText(row, "input"),
+        resolver: optionalText(row, "resolver"),
+        condition: optionalText(row, "condition"),
+        reason: optionalText(row, "reason"),
+        evidence: optionalText(row, "evidence"),
+        retryAt: optionalText(row, "retry_at"),
+        attempt: optionalInteger(row, "attempt"),
+        attemptLimit: optionalInteger(row, "attempt_limit"),
+        observedSequence: optionalInteger(row, "observed_sequence"),
+        observedAt: optionalText(row, "observed_at"),
+        observedOperation: optionalText(row, "observed_operation"),
+    };
+}
+export function documentRow(row) {
+    return { digest: text(row, "digest"), body: text(row, "body") };
+}
+export async function loadDecisions(connection) {
+    return {
+        gates: (await connection.all(`SELECT ${gateColumns} FROM gates ORDER BY opened_sequence, gate_id`)).map(gateRow),
+        details: (await connection.all(`SELECT ${detailColumns} FROM run_details ORDER BY run_id`)).map(detailRow),
+    };
+}
+export async function loadDocuments(connection) {
+    return (await connection.all("SELECT digest, body FROM documents ORDER BY digest")).map(documentRow);
+}
+export async function runDecisions(connection, runId) {
+    return {
+        gates: (await connection.all(`SELECT ${gateColumns} FROM gates WHERE run_id = ? ORDER BY opened_sequence, gate_id`, [runId])).map(gateRow),
+        details: (await connection.all(`SELECT ${detailColumns} FROM run_details WHERE run_id = ?`, [runId])).map(detailRow),
+        questions: integer(await connection.get("SELECT coalesce(max(label), 0) AS questions FROM gates"), "questions"),
+    };
+}
+export async function storedDigests(connection, digests) {
+    const found = [];
+    for (const digest of digests) {
+        const row = await connection.get("SELECT digest FROM documents WHERE digest = ?", [digest]);
+        if (row !== undefined)
+            found.push(digest);
+    }
+    return found;
+}
+export async function documentBody(connection, digest) {
+    const row = await connection.get("SELECT body FROM documents WHERE digest = ?", [digest]);
+    return row === undefined ? undefined : text(row, "body");
+}

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

@@ -0,0 +1,17 @@
+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";
+export interface ProjectionSnapshot extends ProjectionRows, DecisionRows {
+    readonly deliveries: readonly AttemptRow[];
+    readonly pending: readonly string[];
+    readonly sequence: number;
+}
+export interface DecidedSnapshot extends DomainSnapshot, DecisionRows {
+    readonly documents: readonly DocumentRow[];
+}
+export interface CurrentSnapshot extends DecidedSnapshot {
+    readonly effects: EffectRows;
+}
+export declare function loadProjections(connection: SqlConnection): Promise<ProjectionSnapshot>;
+export declare function loadDecided(connection: SqlConnection): Promise<DecidedSnapshot>;
+export declare function loadCurrent(connection: SqlConnection): Promise<CurrentSnapshot>;

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

@@ -0,0 +1,25 @@
+import { loadDecisions, loadDocuments, } from "./decision-rows.js";
+import { latestSequence, loadAttempts, loadSnapshot, projectionRows, text, } from "./domain-rows.js";
+import { loadEffects } from "./effect-rows.js";
+export async function loadProjections(connection) {
+    return {
+        ...(await projectionRows(connection)),
+        ...(await loadDecisions(connection)),
+        deliveries: await loadAttempts(connection),
+        pending: (await connection.all("SELECT operation_id FROM operations WHERE status = 'dispatch-pending' ORDER BY operation_id")).map((row) => text(row, "operation_id")),
+        sequence: await latestSequence(connection),
+    };
+}
+export async function loadDecided(connection) {
+    return {
+        ...(await loadSnapshot(connection)),
+        ...(await loadDecisions(connection)),
+        documents: await loadDocuments(connection),
+    };
+}
+export async function loadCurrent(connection) {
+    return {
+        ...(await loadDecided(connection)),
+        effects: await loadEffects(connection),
+    };
+}

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

@@ -0,0 +1,48 @@
+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";
+import { type Statement } from "./statements.ts";
+export interface StagedDelivery {
+    readonly effectId: string;
+    readonly operationId: string;
+    readonly inputDigest: string;
+    readonly purpose: string;
+    readonly leaseGeneration: number | null;
+    readonly authorityEpoch: number;
+}
+export interface ClosedDelivery {
+    readonly effectId: string;
+    readonly outcome: string;
+    readonly receipt: string | null;
+}
+export interface AddedIntent {
+    readonly operationId: string;
+    readonly kind: string;
+    readonly runId: string;
+    readonly createdSequence: number;
+}
+export interface ReleasedIntent {
+    readonly operationId: string;
+    readonly releasedSequence: number;
+}
+export interface DomainChange extends EffectRows {
+    readonly previous: number;
+    readonly sequence: number;
+    readonly definitions: readonly DefinitionRow[];
+    readonly events: readonly EventRow[];
+    readonly runs: readonly RunRow[];
+    readonly commands: readonly CommandRow[];
+    readonly added: readonly AddedIntent[];
+    readonly released: readonly ReleasedIntent[];
+    readonly staged: readonly StagedDelivery[];
+    readonly closed: readonly ClosedDelivery[];
+    readonly gates: readonly GateRow[];
+    readonly details: readonly DetailRow[];
+    readonly documents: readonly DocumentRow[];
+    readonly completesAdoption: boolean;
+}
+export declare function persistChange(value: unknown, connection: SqlConnection): Promise<void>;
+export declare function gateParameters(row: GateRow): readonly unknown[];
+export declare function detailParameters(row: DetailRow): readonly unknown[];
+export declare function decisionStatements(change: Pick<DomainChange, "gates" | "details" | "documents">): readonly Statement[];
+export declare function persistDecisions(connection: SqlConnection, rows: Pick<DomainChange, "gates" | "details" | "documents">): Promise<void>;

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

@@ -0,0 +1,213 @@
+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";
+import { budgetRow, evidenceRow, leaseRow, operationRow, stopRow, } from "./effect-rows.js";
+import { upsert } from "./statements.js";
+export async function persistChange(value, connection) {
+    const change = parseChange(value);
+    if ((await latestSequence(connection)) !== change.previous)
+        throw new Error("stale-authority-sequence");
+    for (const statement of statements(change))
+        await connection.run(statement.sql, statement.parameters);
+}
+function statements(change) {
+    return [
+        ...change.definitions.map((row) => ({
+            sql: "INSERT INTO definitions (pin, manifest) VALUES (?, ?) ON CONFLICT (pin) DO NOTHING",
+            parameters: [row.pin, row.manifest],
+        })),
+        ...change.events.map((row) => ({
+            sql: "INSERT INTO events (sequence, type, run_id, command_id, recorded_at, request, payload) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            parameters: [
+                row.sequence,
+                row.type,
+                row.runId,
+                row.commandId,
+                row.recordedAt,
+                row.request,
+                row.payload,
+            ],
+        })),
+        ...change.runs.map((row) => ({
+            sql: "INSERT INTO runs (run_id, status, revision, workflow, paused_from, gates, sequence) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT (run_id) DO UPDATE SET status = excluded.status, revision = excluded.revision, workflow = excluded.workflow, paused_from = excluded.paused_from, gates = excluded.gates, sequence = excluded.sequence",
+            parameters: [
+                row.runId,
+                row.status,
+                row.revision,
+                row.workflow,
+                row.pausedFrom,
+                row.gates,
+                row.sequence,
+            ],
+        })),
+        ...change.commands.map((row) => ({
+            sql: "INSERT INTO commands (command_id, request, sequence) VALUES (?, ?, ?)",
+            parameters: [row.commandId, row.request, row.sequence],
+        })),
+        ...intentStatements(change),
+        ...deliveryStatements(change),
+        ...decisionStatements(change),
+        ...effectStatements(change),
+        ...(change.completesAdoption
+            ? [
+                {
+                    sql: "UPDATE authority_identity SET adoption_sequence = NULL WHERE singleton = 1 AND adoption_sequence = ?",
+                    parameters: [change.sequence],
+                },
+            ]
+            : []),
+    ];
+}
+function intentStatements(change) {
+    return [
+        ...change.added.map((row) => ({
+            sql: "INSERT INTO outbox (operation_id, kind, run_id, created_sequence) VALUES (?, ?, ?, ?)",
+            parameters: [row.operationId, row.kind, row.runId, row.createdSequence],
+        })),
+        ...change.released.map((row) => ({
+            sql: "UPDATE outbox SET released_sequence = ? WHERE operation_id = ? AND released_sequence IS NULL",
+            parameters: [row.releasedSequence, row.operationId],
+        })),
+    ];
+}
+function deliveryStatements(change) {
+    return [
+        ...change.closed.map((row) => ({
+            sql: "UPDATE deliveries SET outcome = ?, receipt = ? WHERE effect_id = ? AND outcome IS NULL",
+            parameters: [row.outcome, row.receipt, row.effectId],
+        })),
+        ...change.staged.flatMap((row) => [
+            {
+                sql: "INSERT INTO deliveries (effect_id, operation_id, input_digest, staged_sequence) VALUES (?, ?, ?, ?)",
+                parameters: [
+                    row.effectId,
+                    row.operationId,
+                    row.inputDigest,
+                    change.sequence,
+                ],
+            },
+            {
+                sql: "INSERT INTO dispatch_attempts (effect_id, purpose, lease_generation, authority_epoch) VALUES (?, ?, ?, ?)",
+                parameters: [
+                    row.effectId,
+                    row.purpose,
+                    row.leaseGeneration,
+                    row.authorityEpoch,
+                ],
+            },
+        ]),
+    ];
+}
+const gateNames = gateColumns.split(", ");
+const detailNames = detailColumns.split(", ");
+const gateUpsert = upsert({ table: "gates", names: gateNames, key: 2 });
+const detailUpsert = upsert({
+    table: "run_details",
+    names: detailNames,
+    key: 1,
+});
+export function gateParameters(row) {
+    return [
+        row.runId,
+        row.gateId,
+        row.kind,
+        row.label,
+        row.subject,
+        row.prompt,
+        row.expiresAt,
+        row.generation,
+        row.revision,
+        row.wait,
+        row.decision,
+        row.answer,
+        row.decidedSequence,
+        row.openedSequence,
+        row.continuation,
+    ];
+}
+export function detailParameters(row) {
+    return [
+        row.runId,
+        row.generation,
+        row.submission,
+        row.input,
+        row.resolver,
+        row.condition,
+        row.reason,
+        row.evidence,
+        row.retryAt,
+        row.attempt,
+        row.attemptLimit,
+        row.observedSequence,
+        row.observedAt,
+        row.observedOperation,
+    ];
+}
+export function decisionStatements(change) {
+    return [
+        ...change.gates.map((row) => ({
+            sql: gateUpsert,
+            parameters: gateParameters(row),
+        })),
+        ...change.details.map((row) => ({
+            sql: detailUpsert,
+            parameters: detailParameters(row),
+        })),
+        ...change.documents.map((row) => ({
+            sql: "INSERT INTO documents (digest, body) VALUES (?, ?) ON CONFLICT (digest) DO NOTHING",
+            parameters: [row.digest, row.body],
+        })),
+    ];
+}
+export async function persistDecisions(connection, rows) {
+    for (const statement of decisionStatements(rows))
+        await connection.run(statement.sql, statement.parameters);
+}
+function parseChange(value) {
+    return {
+        previous: integer(value, "previous"),
+        sequence: integer(value, "sequence"),
+        definitions: list(value, "definitions").map(definitionRow),
+        events: list(value, "events").map(eventRow),
+        runs: list(value, "runs").map(runRow),
+        commands: list(value, "commands").map(commandRow),
+        added: list(value, "added").map((row) => ({
+            operationId: text(row, "operation_id"),
+            kind: text(row, "kind"),
+            runId: text(row, "run_id"),
+            createdSequence: integer(row, "created_sequence"),
+        })),
+        released: list(value, "released").map((row) => ({
+            operationId: text(row, "operation_id"),
+            releasedSequence: integer(row, "released_sequence"),
+        })),
+        staged: list(value, "staged").map((row) => ({
+            effectId: text(row, "effect_id"),
+            operationId: text(row, "operation_id"),
+            inputDigest: text(row, "input_digest"),
+            purpose: text(row, "purpose"),
+            leaseGeneration: optionalInteger(row, "lease_generation"),
+            authorityEpoch: integer(row, "authority_epoch"),
+        })),
+        closed: list(value, "closed").map((row) => ({
+            effectId: text(row, "effect_id"),
+            outcome: text(row, "outcome"),
+            receipt: optionalText(row, "receipt"),
+        })),
+        gates: list(value, "gates").map(gateRow),
+        details: list(value, "details").map(detailRow),
+        documents: list(value, "documents").map(documentRow),
+        budgets: list(value, "budgets").map(budgetRow),
+        operations: list(value, "operations").map(operationRow),
+        leases: list(value, "leases").map(leaseRow),
+        evidence: list(value, "evidence").map(evidenceRow),
+        stops: list(value, "stops").map(stopRow),
+        completesAdoption: Reflect.get(Object(value), "completes_adoption") === true,
+    };
+}
+function list(value, name) {
+    const items = Reflect.get(Object(value), name);
+    if (!Array.isArray(items))
+        throw new Error(`invalid-column: ${name}`);
+    return items;
+}