cloving 0.3.20 → 1.0.1

package/dist/src/broker/actor/turn-state.js

@@ -0,0 +1,208 @@
+import { parseCommand } from "../../authority/commands.js";
+import { readExecutionManifest } from "../../execution-pin.js";
+import { operationScope } from "../../operation-identity.js";
+import { gateColumns, gateRow, runDecisions, storedDigests, } from "../../storage/decision-rows.js";
+import { deliveryRow, integer, latestSequence, optionalInteger, outboxRow, runRow, text, } from "../../storage/domain-rows.js";
+import { authorityIdentity } from "../../storage/domain-schema.js";
+import { intentKind, storedRun } from "../authority-restore.js";
+import { decisionState, storedGate } from "../decision-restore.js";
+import { deliveryIntent, gateDecision, } from "./delivery-intents.js";
+import { effectTurn, neighbours, pendingEffect } from "./effect-turn.js";
+import { stopIntents } from "./stop-plan.js";
+import { droppedRuns, turnStopping } from "./stop-turn.js";
+import { documentReferences } from "./turn-plan.js";
+export async function commandTurn(connection, scope) {
+    const { command, sequence, capacity } = scope;
+    const parsed = parseCommand(command);
+    return turnState(connection, {
+        runId: parsed?.runId ?? "",
+        commandId: parsed?.commandId ?? "",
+        kind: parsed?.kind ?? "",
+        sequence,
+        references: documentReferences(parsed),
+        operations: [parsed?.operationId]
+            .filter((operationId) => operationId !== undefined)
+            .filter((operationId) => operationScope(operationId)?.run === parsed?.runId),
+        keys: parsed?.resource === undefined ? [] : [parsed.resource],
+        capacity,
+    });
+}
+export async function stopRecoveries(connection, rule) {
+    const intents = [];
+    const listed = await droppedRuns(connection, {
+        limit: recoveryBatch,
+        stopSupported: rule.stopSupported,
+    });
+    for (const runId of listed) {
+        const turn = await turnState(connection, {
+            runId,
+            commandId: "",
+            kind: "",
+            sequence: 0,
+            references: [],
+            operations: [],
+            keys: [],
+            capacity: rule.capacity,
+        });
+        intents.push(...stopIntents(turn.state, {
+            ...rule,
+            stopping: turn.stopping,
+            runId,
+            closed: [],
+            cancelledNow: [],
+            opening: true,
+            rejected: new Set(),
+        }));
+    }
+    return intents;
+}
+export function recoveryTurn(connection, scope) {
+    return turnState(connection, {
+        ...scope,
+        runId: "",
+        commandId: "",
+        kind: "",
+        references: [],
+        operations: [],
+        keys: [],
+    });
+}
+export const recoveryBatch = 100;
+export async function adoptionTurn(connection) {
+    const identity = await authorityIdentity(connection);
+    const latest = await latestSequence(connection);
+    if (identity.pendingAdoption !== latest)
+        throw new Error("adoption-not-pending");
+    return latest;
+}
+export async function recoverableIntents(connection) {
+    const rows = await connection.all("SELECT o.operation_id, o.kind, o.run_id, r.workflow FROM outbox o JOIN runs r ON r.run_id = o.run_id WHERE o.released_sequence IS NULL AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = o.operation_id AND d.outcome IS NULL) AND ((o.kind = 'start-run' AND r.status = 'queued') OR (o.kind = 'continue-run' AND r.status = 'running') OR (o.kind = 'protected-effect' AND r.status = 'running' AND EXISTS (SELECT 1 FROM operations p WHERE p.operation_id = o.operation_id AND p.status = 'dispatch-pending'))) ORDER BY o.created_sequence, o.rowid LIMIT ?", [recoveryBatch]);
+    const intents = [];
+    for (const row of rows) {
+        const intent = {
+            kind: intentKind(text(row, "kind")),
+            runId: text(row, "run_id"),
+            operationId: text(row, "operation_id"),
+            workflow: text(row, "workflow"),
+        };
+        intents.push(intent.kind === "protected-effect"
+            ? await pendingEffect(connection, { intent, purpose: "dispatch" })
+            : await runIntent(connection, intent));
+    }
+    return [...intents, ...(await uncertainEffects(connection))];
+}
+async function uncertainEffects(connection) {
+    const rows = await connection.all("SELECT p.operation_id, p.run_id, r.workflow FROM operations p JOIN runs r ON r.run_id = p.run_id WHERE p.status IN ('recovering', 'blocked') AND r.status != 'cancelled' AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = p.operation_id AND d.outcome IS NULL) ORDER BY p.requested_sequence LIMIT ?", [recoveryBatch]);
+    const intents = [];
+    for (const row of rows)
+        intents.push(await pendingEffect(connection, {
+            intent: {
+                kind: "protected-effect",
+                runId: text(row, "run_id"),
+                operationId: text(row, "operation_id"),
+                workflow: text(row, "workflow"),
+            },
+            purpose: "reconcile",
+        }));
+    return intents;
+}
+async function runIntent(connection, intent) {
+    const gate = await connection.get(`SELECT ${gateColumns} FROM gates WHERE continuation = ?`, [intent.operationId]);
+    return deliveryIntent({
+        ...intent,
+        ...gateDecision(gate === undefined ? undefined : storedGate(gateRow(gate))),
+    });
+}
+export async function deliveryTurn(connection, scope) {
+    const { effectId, sequence, capacity } = scope;
+    const found = await connection.get("SELECT d.effect_id, d.operation_id, d.input_digest, d.staged_sequence, d.outcome, d.receipt, o.run_id, o.kind, a.lease_generation, coalesce(a.purpose, 'dispatch') AS purpose FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id LEFT JOIN dispatch_attempts a ON a.effect_id = d.effect_id WHERE d.effect_id = ?", [effectId]);
+    if (found === undefined)
+        return undefined;
+    const runId = text(found, "run_id");
+    return {
+        delivery: deliveryRow(found),
+        runId,
+        intent: intentKind(text(found, "kind")),
+        leaseGeneration: optionalInteger(found, "lease_generation"),
+        purpose: text(found, "purpose"),
+        turn: await turnState(connection, {
+            runId,
+            commandId: "",
+            kind: "",
+            sequence,
+            references: [],
+            operations: [text(found, "operation_id")],
+            keys: [],
+            capacity,
+        }),
+    };
+}
+async function attemptSets(connection, runId) {
+    return {
+        held: new Set((await connection.all("SELECT d.operation_id FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id WHERE o.run_id = ? AND (d.outcome IS NULL OR (d.outcome = 'blocked' AND d.rowid = (SELECT max(rowid) FROM deliveries WHERE operation_id = d.operation_id)))", [runId])).map((row) => text(row, "operation_id"))),
+        blocked: new Map((await connection.all("SELECT d.operation_id, d.effect_id FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id WHERE o.run_id = ? AND d.outcome = 'blocked' AND d.rowid = (SELECT max(rowid) FROM deliveries WHERE operation_id = d.operation_id)", [runId])).map((row) => [text(row, "operation_id"), text(row, "effect_id")])),
+    };
+}
+async function turnState(connection, scope) {
+    const { runId, commandId, sequence } = scope;
+    const run = await connection.get("SELECT run_id, status, revision, workflow, paused_from, gates, sequence FROM runs WHERE run_id = ?", [runId]);
+    const stored = run === undefined ? undefined : storedRun(runRow(run));
+    const existing = await connection.get("SELECT request, sequence FROM commands WHERE command_id = ?", [commandId]);
+    const recorded = existing === undefined
+        ? undefined
+        : {
+            request: text(existing, "request"),
+            sequence: integer(existing, "sequence"),
+        };
+    const effects = await effectTurn(connection, scope);
+    const near = await neighbours(connection, { runId, effects });
+    const decisions = decisionState(await runDecisions(connection, runId));
+    const own = await intents(connection, {
+        sql: "SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox WHERE run_id = ? AND released_sequence IS NULL ORDER BY created_sequence, rowid",
+        parameters: [runId],
+    });
+    return {
+        state: {
+            sequence,
+            runs: { ...near.runs, ...(stored ? { [runId]: stored } : {}) },
+            commands: recorded ? { [commandId]: recorded } : {},
+            intents: [...own, ...near.intents],
+            ...decisions,
+            details: { ...near.details, ...decisions.details },
+            effects,
+        },
+        documents: new Set(await storedDigests(connection, scope.references)),
+        definitions: await definitions(connection, stored?.workflow),
+        ...(await attemptSets(connection, runId)),
+        stopping: await turnStopping(connection, {
+            runId,
+            status: stored?.status,
+            kind: scope.kind,
+        }),
+        runId,
+        created: recorded
+            ? await intents(connection, {
+                sql: "SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox WHERE created_sequence = ? ORDER BY rowid",
+                parameters: [recorded.sequence],
+            })
+            : [],
+    };
+}
+async function intents(connection, query) {
+    return (await connection.all(query.sql, query.parameters)).map((row) => {
+        const intent = outboxRow(row);
+        return {
+            kind: intentKind(intent.kind),
+            runId: intent.runId,
+            operationId: intent.operationId,
+        };
+    });
+}
+async function definitions(connection, pin) {
+    if (pin === undefined)
+        return new Map();
+    const row = await connection.get("SELECT manifest FROM definitions WHERE pin = ?", [pin]);
+    return new Map([
+        [pin, readExecutionManifest(JSON.parse(text(row, "manifest")))],
+    ]);
+}

package/dist/src/broker/authority-admission.d.ts

@@ -0,0 +1,21 @@
+import type { AuthorityState } from "../authority/reducer.ts";
+import type { AdmissionResult, ExecutionManifest } from "../workflow-admission.ts";
+export type Definitions = ReadonlyMap<string, ExecutionManifest>;
+export type Admission = {
+    readonly kind: "admissible";
+    readonly definitions: Definitions;
+} | {
+    readonly kind: "rejected";
+    readonly reason: string;
+    readonly detail?: string;
+};
+export declare function admitted(state: AuthorityState, request: {
+    readonly definitions: Definitions;
+    readonly command: unknown;
+    readonly manifest: ExecutionManifest | undefined;
+}): Admission;
+export declare function pinnedResumption(state: Pick<AuthorityState, "runs">, request: {
+    readonly definitions: Definitions;
+    readonly runId: string;
+    readonly available: ExecutionManifest;
+}): AdmissionResult;

package/dist/src/broker/authority-admission.js

@@ -0,0 +1,70 @@
+import { parseCommand } from "../authority/commands.js";
+import { readExecutionManifest, resumePinned } from "../execution-pin.js";
+import { effectInputDigest } from "./effect-restore.js";
+import { workflowPin } from "./workflow-pin.js";
+const admissible = { kind: "admissible", definitions: new Map() };
+const terminal = ["completed", "failed", "cancelled"];
+const unpinned = (_command, context) => context.manifest === undefined
+    ? admissible
+    : { kind: "rejected", reason: "unexpected-manifest" };
+const admission = (command, context) => {
+    const { manifest } = context;
+    if (manifest === undefined)
+        return { kind: "rejected", reason: "missing-manifest" };
+    const stored = readExecutionManifest(manifest);
+    const pin = workflowPin(stored);
+    if (command.workflow !== pin)
+        return { kind: "rejected", reason: "workflow-pin-mismatch" };
+    const capabilities = JSON.stringify([...stored.capabilities].sort());
+    if ((command.capabilities ?? capabilities) !== capabilities)
+        return { kind: "rejected", reason: "capability-pin-mismatch" };
+    return { kind: "admissible", definitions: new Map([[pin, stored]]) };
+};
+const resumption = (command, context) => {
+    const { manifest, state, definitions } = context;
+    if (manifest === undefined)
+        return { kind: "rejected", reason: "missing-manifest" };
+    const resumed = pinnedResumption(state, {
+        definitions,
+        runId: command.runId,
+        available: manifest,
+    });
+    return resumed.kind === "rejected" && resumed.reason !== "unknown-run"
+        ? resumed
+        : admissible;
+};
+const effectRequest = (command, context) => {
+    const computed = effectInputDigest({
+        capability: String(command.capability),
+        method: String(command.method),
+        target: String(command.target),
+        payload: String(command.payload),
+    });
+    return computed === command.inputDigest
+        ? unpinned(command, context)
+        : { kind: "rejected", reason: "input-digest-mismatch" };
+};
+const rules = {
+    "request-effect": effectRequest,
+    "admit-run": admission,
+    "decide-gate": resumption,
+    "resume-run": resumption,
+};
+export function admitted(state, request) {
+    const { definitions, command, manifest } = request;
+    const parsed = parseCommand(command);
+    if (!parsed || state.commands[parsed.commandId])
+        return admissible;
+    const rule = rules[parsed.kind] ?? unpinned;
+    return rule(parsed, { manifest, state, definitions });
+}
+export function pinnedResumption(state, request) {
+    const { definitions, runId, available } = request;
+    const status = state.runs[runId]?.status ?? "";
+    const pinned = definitions.get(state.runs[runId]?.workflow ?? "");
+    if (!pinned)
+        return { kind: "rejected", reason: "unknown-run", detail: runId };
+    if (terminal.includes(status))
+        return { kind: "rejected", reason: "terminal-run", detail: runId };
+    return resumePinned(pinned, available);
+}

package/dist/src/broker/authority-restore.d.ts

@@ -0,0 +1,30 @@
+import type { AuthorityEvent, AuthorityState, EffectIntent, RunState } from "../authority/reducer.ts";
+import type { DecisionRows, DocumentRow } from "../storage/decision-rows.ts";
+import type { EffectRows } from "../storage/effect-rows.ts";
+import type { ProjectionSnapshot } from "../storage/decision-snapshots.ts";
+import type { AuthoritySnapshot, EventRow } from "../storage/domain-rows.ts";
+import type { ExecutionManifest } from "../workflow-admission.ts";
+export type RestoredSnapshot = AuthoritySnapshot & Partial<DecisionRows> & {
+    readonly documents?: readonly DocumentRow[];
+    readonly effects?: EffectRows;
+};
+export type Restoration = {
+    readonly kind: "restored";
+    readonly state: AuthorityState;
+    readonly events: readonly AuthorityEvent[];
+    readonly definitions: ReadonlyMap<string, ExecutionManifest>;
+} | {
+    readonly kind: "refused";
+    readonly reason: "invalid-history" | "projection-mismatch";
+    readonly detail: string;
+};
+export declare function restore(snapshot: RestoredSnapshot): Restoration;
+export declare function storedDefinitions(snapshot: Pick<ProjectionSnapshot, "definitions">): ReadonlyMap<string, ExecutionManifest>;
+type BaseState = Pick<AuthorityState, "sequence" | "runs" | "commands" | "intents">;
+export type StoredState = Omit<AuthorityState, "effects">;
+export declare function currentState(snapshot: ProjectionSnapshot): StoredState;
+export declare function projectedState(snapshot: Pick<ProjectionSnapshot, "runs" | "commands" | "outbox" | "sequence">): BaseState;
+export declare function intentKind(value: string): EffectIntent["kind"];
+export declare function storedRun(row: AuthoritySnapshot["runs"][number]): RunState;
+export declare function storedEvents(rows: readonly EventRow[]): readonly AuthorityEvent[];
+export {};

package/dist/src/broker/authority-restore.js

@@ -0,0 +1,165 @@
+import { isDeepStrictEqual } from "node:util";
+import { parseEvent } from "../authority/events.js";
+import { rebuildHistory } from "../authority/history.js";
+import { readExecutionManifest } from "../execution-pin.js";
+import { decisionRows, decisionState, documentsIntact, referencedDigests, } from "./decision-restore.js";
+import { effectChecks, effectDigests } from "./effect-restore.js";
+import { workflowPin } from "./workflow-pin.js";
+const statuses = [
+    "queued",
+    "running",
+    "waiting_gate",
+    "paused",
+    "completed",
+    "failed",
+    "cancelled",
+];
+export function restore(snapshot) {
+    let events;
+    let history;
+    try {
+        events = storedEvents(snapshot.events);
+        history = rebuildHistory(events);
+    }
+    catch (error) {
+        return { kind: "refused", reason: "invalid-history", detail: text(error) };
+    }
+    let stored;
+    try {
+        stored = {
+            ...history.state,
+            ...projectedState({
+                ...snapshot,
+                sequence: snapshot.events.at(-1)?.sequence ?? 0,
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            kind: "refused",
+            reason: "projection-mismatch",
+            detail: text(error),
+        };
+    }
+    const { state } = history;
+    const definitions = storedDefinitions(snapshot);
+    const checks = [
+        ...projectionParts.map((part) => [part, isDeepStrictEqual(stored[part], state[part])]),
+        ["outbox", isDeepStrictEqual(snapshot.outbox, history.outbox)],
+        [
+            "run-sequences",
+            isDeepStrictEqual(Object.fromEntries(snapshot.runs.map((row) => [row.runId, row.sequence])), history.runSequences),
+        ],
+        ["definitions", definitionsIntact(definitions, state)],
+        ...decisionChecks(snapshot, state),
+        ...(snapshot.effects === undefined
+            ? []
+            : effectChecks(snapshot.effects, {
+                effects: state.effects,
+                evidence: history.evidence,
+            })),
+    ];
+    const failed = checks.find(([, holds]) => !holds);
+    if (failed)
+        return {
+            kind: "refused",
+            reason: "projection-mismatch",
+            detail: failed[0],
+        };
+    return { kind: "restored", state, events, definitions };
+}
+function decisionChecks(snapshot, state) {
+    const { gates, details, documents } = snapshot;
+    if (gates === undefined || details === undefined || documents === undefined)
+        return [];
+    const expected = decisionRows(state);
+    return [
+        ["gates", isDeepStrictEqual(gates, expected.gates)],
+        ["details", isDeepStrictEqual(details, expected.details)],
+        [
+            "documents",
+            documentsIntact(documents, [
+                ...referencedDigests(state),
+                ...effectDigests(state.effects),
+            ]),
+        ],
+    ];
+}
+export function storedDefinitions(snapshot) {
+    return new Map(snapshot.definitions.map((row) => [
+        row.pin,
+        readExecutionManifest(parsed(row.manifest)),
+    ]));
+}
+function definitionsIntact(definitions, state) {
+    const used = new Set(Object.values(state.runs).map((run) => run.workflow));
+    return ([...definitions].every(([pin, manifest]) => workflowPin(manifest) === pin && used.has(pin)) && [...used].every((pin) => definitions.has(pin)));
+}
+const projectionParts = ["sequence", "runs", "commands", "intents"];
+function text(error) {
+    return String(Reflect.get(Object(error), "message"));
+}
+export function currentState(snapshot) {
+    return { ...projectedState(snapshot), ...decisionState(snapshot) };
+}
+export function projectedState(snapshot) {
+    return {
+        sequence: snapshot.sequence,
+        runs: Object.fromEntries(snapshot.runs.map((row) => [row.runId, storedRun(row)])),
+        commands: Object.fromEntries(snapshot.commands.map((row) => [
+            row.commandId,
+            { request: row.request, sequence: row.sequence },
+        ])),
+        intents: snapshot.outbox
+            .filter((row) => row.releasedSequence === null)
+            .map((row) => ({
+            kind: intentKind(row.kind),
+            runId: row.runId,
+            operationId: row.operationId,
+        })),
+    };
+}
+const intentKinds = [
+    "start-run",
+    "continue-run",
+    "protected-effect",
+];
+export function intentKind(value) {
+    const kind = intentKinds.find((candidate) => candidate === value);
+    if (!kind)
+        throw new Error("invalid-outbox-row");
+    return kind;
+}
+export function storedRun(row) {
+    const status = statuses.find((candidate) => candidate === row.status);
+    const pausedFrom = statuses.find((candidate) => candidate === row.pausedFrom);
+    const gates = JSON.parse(row.gates);
+    const unknownPause = row.pausedFrom !== null && pausedFrom === undefined;
+    if (!status || unknownPause || !Array.isArray(gates))
+        throw new Error("invalid-run-row");
+    return {
+        runId: row.runId,
+        status,
+        revision: row.revision,
+        workflow: row.workflow,
+        pausedFrom: pausedFrom ?? null,
+        gates: gates.map(String),
+    };
+}
+export function storedEvents(rows) {
+    return rows.map(storedEvent);
+}
+function storedEvent(row) {
+    const event = parseEvent({ ...row, payload: parsed(row.payload) });
+    if (!event)
+        throw new Error(`invalid-event-row: ${String(row.sequence)}`);
+    return event;
+}
+function parsed(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/broker/decision-restore.d.ts

@@ -0,0 +1,16 @@
+import type { RunDetails } from "../authority/details.ts";
+import { type GateState } from "../authority/gates.ts";
+import type { AuthorityState } from "../authority/reducer.ts";
+import type { DecisionRows, DetailRow, DocumentRow, GateRow } from "../storage/decision-rows.ts";
+export type DecisionState = Pick<AuthorityState, "gates" | "details" | "questions">;
+export declare function documentDigest(body: string): string;
+export declare function gateRecord(gate: GateState): GateRow;
+export declare function detailRecord(details: RunDetails): DetailRow;
+export declare function storedGate(row: GateRow): GateState;
+export declare function storedDetails(row: DetailRow): RunDetails;
+export declare function decisionState(rows: DecisionRows & {
+    readonly questions?: number;
+}): DecisionState;
+export declare function decisionRows(state: DecisionState): DecisionRows;
+export declare function referencedDigests(state: DecisionState): readonly string[];
+export declare function documentsIntact(documents: readonly DocumentRow[], referenced: readonly string[]): boolean;

package/dist/src/broker/decision-restore.js

@@ -0,0 +1,158 @@
+import { createHash } from "node:crypto";
+import { continues, gateKey } from "../authority/gates.js";
+import { gateContinuation } from "../authority/reduction.js";
+const kinds = ["question", "approval", "untyped"];
+const waits = ["registered", "pending"];
+export function documentDigest(body) {
+    return `sha256:${createHash("sha256").update(body).digest("hex")}`;
+}
+export function gateRecord(gate) {
+    return {
+        runId: gate.runId,
+        gateId: gate.gateId,
+        kind: gate.kind,
+        label: gate.label,
+        subject: gate.subject,
+        prompt: gate.prompt,
+        expiresAt: gate.expiresAt,
+        generation: gate.generation,
+        revision: gate.revision,
+        wait: gate.wait,
+        decision: gate.outcome?.decision ?? null,
+        answer: gate.outcome?.answer ?? null,
+        decidedSequence: gate.outcome?.sequence ?? null,
+        openedSequence: gate.openedSequence,
+        continuation: continues(gate) ? gateContinuation(gate).operationId : null,
+    };
+}
+const unobserved = {
+    condition: null,
+    reason: null,
+    evidence: null,
+    retryAt: null,
+    attempt: null,
+    attemptLimit: null,
+    observedSequence: null,
+    observedAt: null,
+    observedOperation: null,
+};
+function observationColumns(observation) {
+    if (observation === null)
+        return unobserved;
+    return {
+        condition: observation.condition,
+        reason: observation.reason,
+        evidence: observation.evidence,
+        retryAt: observation.retryAt,
+        attempt: observation.attempt,
+        attemptLimit: observation.limit,
+        observedSequence: observation.sequence,
+        observedAt: observation.recordedAt,
+        observedOperation: observation.operationId,
+    };
+}
+export function detailRecord(details) {
+    return {
+        runId: details.runId,
+        generation: details.generation,
+        submission: details.submission,
+        input: details.input,
+        resolver: details.resolver,
+        ...observationColumns(details.observation),
+    };
+}
+export function storedGate(row) {
+    const kind = kinds.find((candidate) => candidate === row.kind);
+    const wait = waits.find((candidate) => candidate === row.wait);
+    if (!kind || !wait)
+        throw new Error("invalid-gate-row");
+    const { decidedSequence } = row;
+    return {
+        runId: row.runId,
+        gateId: row.gateId,
+        kind,
+        label: row.label,
+        subject: row.subject,
+        prompt: row.prompt,
+        expiresAt: row.expiresAt,
+        generation: row.generation,
+        revision: row.revision,
+        wait,
+        outcome: decidedSequence === null
+            ? null
+            : {
+                decision: row.decision,
+                answer: row.answer,
+                sequence: decidedSequence,
+            },
+        openedSequence: row.openedSequence,
+    };
+}
+function storedObservation(row) {
+    const { condition, reason, observedSequence, observedAt } = row;
+    if (condition === null ||
+        reason === null ||
+        observedSequence === null ||
+        observedAt === null)
+        return null;
+    return {
+        condition,
+        reason,
+        evidence: row.evidence,
+        retryAt: row.retryAt,
+        operationId: row.observedOperation,
+        attempt: row.attempt,
+        limit: row.attemptLimit,
+        sequence: observedSequence,
+        recordedAt: observedAt,
+    };
+}
+export function storedDetails(row) {
+    return {
+        runId: row.runId,
+        generation: row.generation,
+        submission: row.submission,
+        input: row.input,
+        resolver: row.resolver,
+        observation: storedObservation(row),
+    };
+}
+export function decisionState(rows) {
+    const highest = rows.gates.reduce((label, row) => Math.max(label, row.label ?? 0), 0);
+    return {
+        gates: Object.fromEntries(rows.gates.map((row) => [
+            gateKey(row.runId, row.gateId),
+            storedGate(row),
+        ])),
+        details: Object.fromEntries(rows.details.map((row) => [row.runId, storedDetails(row)])),
+        questions: rows.questions ?? highest,
+    };
+}
+export function decisionRows(state) {
+    return {
+        gates: Object.values(state.gates)
+            .map(gateRecord)
+            .sort((left, right) => left.openedSequence - right.openedSequence ||
+            (left.gateId < right.gateId ? -1 : 1)),
+        details: Object.values(state.details)
+            .map(detailRecord)
+            .sort((left, right) => (left.runId < right.runId ? -1 : 1)),
+    };
+}
+export function referencedDigests(state) {
+    return [
+        ...Object.values(state.gates).flatMap((gate) => [
+            gate.prompt,
+            gate.outcome?.answer ?? null,
+        ]),
+        ...Object.values(state.details).flatMap((details) => [
+            details.submission,
+            details.input,
+        ]),
+    ].filter((digest) => digest !== null);
+}
+export function documentsIntact(documents, referenced) {
+    const stored = new Set(documents.map((row) => row.digest));
+    return (documents.every((row) => documentDigest(row.body) === row.digest) &&
+        referenced.every((digest) => stored.has(digest)));
+}

package/dist/src/broker/decision-upgrade.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from "solid-objects";
+import type { AuthorityState } from "../authority/reducer.ts";
+export declare function upgradeDecisions(database: Database, state: AuthorityState): Promise<void>;