cloving 0.3.19 → 1.0.1

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

@@ -0,0 +1,85 @@
+export interface SqlConnection {
+    readonly run: (sql: string, parameters?: readonly unknown[]) => Promise<unknown>;
+    readonly get: (sql: string, parameters?: readonly unknown[]) => Promise<unknown>;
+    readonly all: (sql: string, parameters?: readonly unknown[]) => Promise<readonly unknown[]>;
+}
+export interface EventRow {
+    readonly sequence: number;
+    readonly type: string;
+    readonly runId: string;
+    readonly commandId: string;
+    readonly recordedAt: string;
+    readonly request: string;
+    readonly payload: string;
+}
+export interface RunRow {
+    readonly runId: string;
+    readonly status: string;
+    readonly revision: number;
+    readonly workflow: string;
+    readonly pausedFrom: string | null;
+    readonly gates: string;
+    readonly sequence: number;
+}
+export interface CommandRow {
+    readonly commandId: string;
+    readonly request: string;
+    readonly sequence: number;
+}
+export interface IntentRow {
+    readonly operationId: string;
+    readonly kind: string;
+    readonly runId: string;
+    readonly createdSequence: number;
+}
+export interface OutboxRow extends IntentRow {
+    readonly releasedSequence: number | null;
+}
+export interface DefinitionRow {
+    readonly pin: string;
+    readonly manifest: string;
+}
+export interface DeliveryRow {
+    readonly effectId: string;
+    readonly operationId: string;
+    readonly inputDigest: string;
+    readonly stagedSequence: number;
+    readonly outcome: string | null;
+    readonly receipt: string | null;
+}
+export interface AttemptRow extends DeliveryRow {
+    readonly purpose: string;
+    readonly leaseGeneration: number | null;
+    readonly epoch: number | null;
+}
+export interface AuthoritySnapshot {
+    readonly definitions: readonly DefinitionRow[];
+    readonly events: readonly EventRow[];
+    readonly runs: readonly RunRow[];
+    readonly commands: readonly CommandRow[];
+    readonly outbox: readonly OutboxRow[];
+}
+export interface DomainSnapshot extends AuthoritySnapshot {
+    readonly deliveries: readonly DeliveryRow[];
+}
+export declare const attemptColumns = "d.effect_id, d.operation_id, d.input_digest, d.staged_sequence, d.outcome, d.receipt, coalesce(a.purpose, 'dispatch') AS purpose, a.lease_generation, a.authority_epoch";
+export declare const attemptSource = "deliveries d LEFT JOIN dispatch_attempts a ON a.effect_id = d.effect_id";
+export declare function loadAttempts(connection: SqlConnection): Promise<readonly AttemptRow[]>;
+export declare function attemptRow(row: unknown): AttemptRow;
+export type ProjectionRows = Omit<AuthoritySnapshot, "events">;
+export declare function loadSnapshot(connection: SqlConnection): Promise<DomainSnapshot>;
+export declare function loadBaseline(connection: SqlConnection): Promise<AuthoritySnapshot>;
+export declare function loadEvents(connection: SqlConnection): Promise<readonly EventRow[]>;
+export declare function loadDeliveries(connection: SqlConnection): Promise<readonly DeliveryRow[]>;
+export declare function projectionRows(connection: SqlConnection): Promise<ProjectionRows>;
+export declare function latestSequence(connection: SqlConnection): Promise<number>;
+export declare function definitionRow(row: unknown): DefinitionRow;
+export declare function eventRow(row: unknown): EventRow;
+export declare function runRow(row: unknown): RunRow;
+export declare function commandRow(row: unknown): CommandRow;
+export declare function outboxRow(row: unknown): OutboxRow;
+export declare function deliveryRow(row: unknown): DeliveryRow;
+export declare function text(row: unknown, name: string): string;
+export declare function optionalText(row: unknown, name: string): string | null;
+export declare function integer(row: unknown, name: string): number;
+export declare function optionalInteger(row: unknown, name: string): number | null;

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

@@ -0,0 +1,129 @@
+export const attemptColumns = "d.effect_id, d.operation_id, d.input_digest, d.staged_sequence, d.outcome, d.receipt, coalesce(a.purpose, 'dispatch') AS purpose, a.lease_generation, a.authority_epoch";
+export const attemptSource = "deliveries d LEFT JOIN dispatch_attempts a ON a.effect_id = d.effect_id";
+export async function loadAttempts(connection) {
+    return (await connection.all(`SELECT ${attemptColumns} FROM ${attemptSource} ORDER BY d.staged_sequence, d.rowid`)).map(attemptRow);
+}
+export function attemptRow(row) {
+    return {
+        ...deliveryRow(row),
+        purpose: text(row, "purpose"),
+        leaseGeneration: optionalInteger(row, "lease_generation"),
+        epoch: optionalInteger(row, "authority_epoch"),
+    };
+}
+export async function loadSnapshot(connection) {
+    return {
+        ...(await loadBaseline(connection)),
+        deliveries: await loadDeliveries(connection),
+    };
+}
+export async function loadBaseline(connection) {
+    return {
+        ...(await projectionRows(connection)),
+        events: await loadEvents(connection),
+    };
+}
+export async function loadEvents(connection) {
+    return (await connection.all("SELECT sequence, type, run_id, command_id, recorded_at, request, payload FROM events ORDER BY sequence")).map(eventRow);
+}
+export async function loadDeliveries(connection) {
+    return (await connection.all("SELECT effect_id, operation_id, input_digest, staged_sequence, outcome, receipt FROM deliveries ORDER BY staged_sequence, rowid")).map(deliveryRow);
+}
+export async function projectionRows(connection) {
+    const rows = (sql) => connection.all(sql);
+    return {
+        definitions: (await rows("SELECT pin, manifest FROM definitions ORDER BY pin")).map(definitionRow),
+        runs: (await rows("SELECT run_id, status, revision, workflow, paused_from, gates, sequence FROM runs ORDER BY run_id")).map(runRow),
+        commands: (await rows("SELECT command_id, request, sequence FROM commands ORDER BY sequence")).map(commandRow),
+        outbox: (await rows("SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox ORDER BY created_sequence, rowid")).map(outboxRow),
+    };
+}
+export async function latestSequence(connection) {
+    return integer(await connection.get("SELECT coalesce(max(sequence), 0) AS sequence FROM events"), "sequence");
+}
+export function definitionRow(row) {
+    return { pin: text(row, "pin"), manifest: text(row, "manifest") };
+}
+export function eventRow(row) {
+    return {
+        sequence: integer(row, "sequence"),
+        type: text(row, "type"),
+        runId: text(row, "run_id"),
+        commandId: text(row, "command_id"),
+        recordedAt: text(row, "recorded_at"),
+        request: text(row, "request"),
+        payload: text(row, "payload"),
+    };
+}
+export function runRow(row) {
+    return {
+        runId: text(row, "run_id"),
+        status: text(row, "status"),
+        revision: integer(row, "revision"),
+        workflow: text(row, "workflow"),
+        pausedFrom: optionalText(row, "paused_from"),
+        gates: text(row, "gates"),
+        sequence: integer(row, "sequence"),
+    };
+}
+export function commandRow(row) {
+    return {
+        commandId: text(row, "command_id"),
+        request: text(row, "request"),
+        sequence: integer(row, "sequence"),
+    };
+}
+export function outboxRow(row) {
+    return {
+        operationId: text(row, "operation_id"),
+        kind: text(row, "kind"),
+        runId: text(row, "run_id"),
+        createdSequence: integer(row, "created_sequence"),
+        releasedSequence: optionalInteger(row, "released_sequence"),
+    };
+}
+export function deliveryRow(row) {
+    return {
+        effectId: text(row, "effect_id"),
+        operationId: text(row, "operation_id"),
+        inputDigest: text(row, "input_digest"),
+        stagedSequence: integer(row, "staged_sequence"),
+        outcome: optionalText(row, "outcome"),
+        receipt: optionalText(row, "receipt"),
+    };
+}
+function column(row, field) {
+    const { name, accepts } = field;
+    const value = Reflect.get(Object(row), name);
+    if (!accepts(value))
+        throw new Error(`invalid-column: ${name}`);
+    return value;
+}
+function isText(value) {
+    return typeof value === "string";
+}
+function isOptionalText(value) {
+    return value === null || typeof value === "string";
+}
+function isSafeInteger(value) {
+    if (typeof value === "bigint")
+        return (value >= BigInt(Number.MIN_SAFE_INTEGER) &&
+            value <= BigInt(Number.MAX_SAFE_INTEGER));
+    return Number.isSafeInteger(value);
+}
+function isOptionalSafeInteger(value) {
+    return value === null || isSafeInteger(value);
+}
+export function text(row, name) {
+    return column(row, { name, accepts: isText });
+}
+export function optionalText(row, name) {
+    return column(row, { name, accepts: isOptionalText });
+}
+export function integer(row, name) {
+    return Number(column(row, { name, accepts: isSafeInteger }));
+}
+export function optionalInteger(row, name) {
+    const value = column(row, { name, accepts: isOptionalSafeInteger });
+    return value === null ? null : Number(value);
+}

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

@@ -0,0 +1,32 @@
+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 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";
+    readonly reason: "unsupported-schema" | "foreign-database" | "schema-mismatch";
+    readonly detail: string;
+};
+export type SchemaState = {
+    readonly kind: "new";
+} | {
+    readonly kind: "baseline";
+} | {
+    readonly kind: "adopted";
+} | {
+    readonly kind: "decided";
+} | {
+    readonly kind: "current";
+} | SchemaRefusal;
+export declare function inspectSchema(connection: SqlConnection): Promise<SchemaState>;
+export declare function createSchema(connection: SqlConnection): Promise<void>;
+export declare function upgradeSchema(connection: SqlConnection, version: number): Promise<void>;
+export declare function adoptSchema(connection: SqlConnection, pendingSequence: number | null): Promise<void>;
+export interface AuthorityIdentity {
+    readonly actorId: string;
+    readonly pendingAdoption: number | null;
+}
+export declare function backupInto(connection: SqlConnection, target: string): Promise<void>;
+export declare function authorityIdentity(connection: SqlConnection): Promise<AuthorityIdentity>;

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

@@ -0,0 +1,193 @@
+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";
+export const baselineVersion = 1;
+export const adoptedVersion = 2;
+export const decidedVersion = 3;
+export const currentVersion = 4;
+export const baselineSchema = `
+CREATE TABLE schema_migrations (
+  version INTEGER PRIMARY KEY,
+  checksum TEXT NOT NULL
+) STRICT;
+CREATE TABLE events (
+  sequence INTEGER PRIMARY KEY,
+  type TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  command_id TEXT NOT NULL UNIQUE,
+  recorded_at TEXT NOT NULL,
+  request TEXT NOT NULL,
+  payload TEXT NOT NULL
+) STRICT;
+CREATE TABLE definitions (
+  pin TEXT PRIMARY KEY,
+  manifest TEXT NOT NULL
+) STRICT;
+CREATE TABLE runs (
+  run_id TEXT PRIMARY KEY,
+  status TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  workflow TEXT NOT NULL REFERENCES definitions (pin) DEFERRABLE INITIALLY DEFERRED,
+  paused_from TEXT,
+  gates TEXT NOT NULL,
+  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED
+) STRICT;
+CREATE TABLE commands (
+  command_id TEXT PRIMARY KEY,
+  request TEXT NOT NULL,
+  sequence INTEGER NOT NULL UNIQUE REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED
+) STRICT;
+CREATE TABLE outbox (
+  operation_id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,
+  created_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,
+  released_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED
+) STRICT;
+`;
+const adoption = `
+CREATE TABLE authority_identity (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  actor_id TEXT NOT NULL,
+  adoption_sequence INTEGER
+) STRICT;
+CREATE TABLE deliveries (
+  effect_id TEXT PRIMARY KEY,
+  operation_id TEXT NOT NULL REFERENCES outbox (operation_id) DEFERRABLE INITIALLY DEFERRED,
+  input_digest TEXT NOT NULL,
+  staged_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,
+  outcome TEXT,
+  receipt TEXT
+) STRICT;
+CREATE UNIQUE INDEX deliveries_open ON deliveries (operation_id) WHERE outcome IS NULL;
+`;
+const decisions = `
+CREATE TABLE gates (
+  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,
+  gate_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  label INTEGER,
+  subject TEXT,
+  prompt TEXT,
+  expires_at TEXT,
+  generation INTEGER NOT NULL,
+  revision INTEGER NOT NULL,
+  wait TEXT NOT NULL,
+  decision TEXT,
+  answer TEXT,
+  decided_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,
+  opened_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,
+  continuation TEXT,
+  PRIMARY KEY (run_id, gate_id)
+) STRICT;
+CREATE TABLE run_details (
+  run_id TEXT PRIMARY KEY REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,
+  generation INTEGER NOT NULL,
+  submission TEXT,
+  input TEXT,
+  resolver TEXT,
+  condition TEXT,
+  reason TEXT,
+  evidence TEXT,
+  retry_at TEXT,
+  attempt INTEGER,
+  attempt_limit INTEGER,
+  observed_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,
+  observed_at TEXT,
+  observed_operation TEXT
+) STRICT;
+CREATE TABLE documents (
+  digest TEXT PRIMARY KEY,
+  body TEXT NOT NULL
+) STRICT;
+`;
+const schemas = [baselineSchema, adoption, decisions, effectSchema];
+const checksums = schemas.map((schema) => createHash("sha256").update(schema).digest("hex"));
+const versionKinds = ["baseline", "adopted", "decided", "current"];
+export async function inspectSchema(connection) {
+    const version = integer(await connection.get("PRAGMA user_version"), "user_version");
+    const detail = String(version);
+    if (version === 0)
+        return emptyDatabase(connection, detail);
+    const kind = versionKinds[version - 1];
+    if (kind === undefined)
+        return { kind: "refused", reason: "unsupported-schema", detail };
+    const intact = (await structure(connection)) ===
+        expectedStructure(schemas.slice(0, version)) &&
+        (await recordedChecksums(connection)) ===
+            JSON.stringify(checksums.slice(0, version));
+    if (!intact)
+        return { kind: "refused", reason: "schema-mismatch", detail };
+    return { kind };
+}
+async function emptyDatabase(connection, detail) {
+    const objects = integer(await connection.get("SELECT count(*) AS count FROM sqlite_schema"), "count");
+    return objects === 0
+        ? { kind: "new" }
+        : { kind: "refused", reason: "foreign-database", detail };
+}
+export async function createSchema(connection) {
+    await execute(connection, baselineSchema);
+    await recordVersion(connection, baselineVersion);
+    await adoptSchema(connection, null);
+    await upgradeSchema(connection, decidedVersion);
+    await upgradeSchema(connection, currentVersion);
+}
+export async function upgradeSchema(connection, version) {
+    await execute(connection, schemas[version - 1] ?? "");
+    await recordVersion(connection, version);
+    await connection.run(`PRAGMA user_version = ${String(version)}`);
+}
+export async function adoptSchema(connection, pendingSequence) {
+    await execute(connection, adoption);
+    await recordVersion(connection, adoptedVersion);
+    await connection.run("INSERT INTO authority_identity (singleton, actor_id, adoption_sequence) VALUES (1, ?, ?)", [randomUUID(), pendingSequence]);
+    await connection.run(`PRAGMA user_version = ${String(adoptedVersion)}`);
+}
+export async function backupInto(connection, target) {
+    await connection.run("VACUUM INTO ?", [target]);
+}
+export async function authorityIdentity(connection) {
+    const row = await connection.get("SELECT actor_id, adoption_sequence FROM authority_identity WHERE singleton = 1");
+    return {
+        actorId: text(row, "actor_id"),
+        pendingAdoption: optionalInteger(row, "adoption_sequence"),
+    };
+}
+async function execute(connection, schema) {
+    for (const statement of statements(schema))
+        await connection.run(statement);
+}
+function recordVersion(connection, version) {
+    return connection.run("INSERT INTO schema_migrations (version, checksum) VALUES (?, ?)", [version, checksums[version - 1]]);
+}
+function statements(schema) {
+    return schema
+        .split(";")
+        .map((statement) => statement.trim())
+        .filter((statement) => statement.length > 0);
+}
+const structureQuery = "SELECT type, name, tbl_name, sql FROM sqlite_schema WHERE type IN ('table', 'index') AND tbl_name NOT LIKE 'solid\\_%' ESCAPE '\\' ORDER BY type, name";
+function structureOf(rows) {
+    return JSON.stringify(rows.map((row) => [
+        text(row, "type"),
+        text(row, "name"),
+        text(row, "tbl_name"),
+        optionalText(row, "sql"),
+    ]));
+}
+async function structure(connection) {
+    return structureOf(await connection.all(structureQuery));
+}
+function expectedStructure(schemas) {
+    const memory = new DatabaseSync(":memory:");
+    for (const schema of schemas)
+        memory.exec(schema);
+    const value = structureOf(memory.prepare(structureQuery).all());
+    memory.close();
+    return value;
+}
+async function recordedChecksums(connection) {
+    return JSON.stringify((await connection.all("SELECT checksum FROM schema_migrations ORDER BY version")).map((row) => text(row, "checksum")));
+}

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

@@ -0,0 +1,5 @@
+import type { SqlConnection } from "./domain-rows.ts";
+import { type EffectRows } from "./effect-rows.ts";
+import { type Statement } from "./statements.ts";
+export declare function effectStatements(rows: EffectRows): readonly Statement[];
+export declare function persistEffects(connection: SqlConnection, rows: EffectRows): Promise<void>;

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

@@ -0,0 +1,105 @@
+import { budgetColumns, evidenceColumns, leaseColumns, operationColumns, stopColumns, } from "./effect-rows.js";
+import { upsert } from "./statements.js";
+const budgetUpsert = upsert({
+    table: "run_budgets",
+    names: budgetColumns.split(", "),
+    key: 1,
+});
+const operationUpsert = upsert({
+    table: "operations",
+    names: operationColumns.split(", "),
+    key: 1,
+});
+const leaseUpsert = upsert({
+    table: "leases",
+    names: leaseColumns.split(", "),
+    key: 1,
+});
+const stopUpsert = upsert({
+    table: "stopped_operations",
+    names: stopColumns.split(", "),
+    key: 1,
+});
+const evidenceInsert = `INSERT INTO effect_evidence (${evidenceColumns}) VALUES (?, ?, ?, ?, ?)`;
+function budgetParameters(row) {
+    return [
+        row.runId,
+        row.effectLimit,
+        row.spent,
+        row.capabilities,
+        row.exhaustedSequence,
+    ];
+}
+function operationParameters(row) {
+    return [
+        row.operationId,
+        row.runId,
+        row.capability,
+        row.method,
+        row.target,
+        row.payload,
+        row.inputDigest,
+        row.units,
+        row.leaseKey,
+        row.recoveryLimit,
+        row.status,
+        row.reason,
+        row.attempts,
+        row.receipt,
+        row.worker,
+        row.result,
+        row.requestedSequence,
+        row.waitSequence,
+        row.settledSequence,
+    ];
+}
+function leaseParameters(row) {
+    return [
+        row.resourceKey,
+        row.operationId,
+        row.generation,
+        row.expiresAt,
+        row.state,
+        row.grantedSequence,
+    ];
+}
+function evidenceParameters(row) {
+    return [
+        row.sequence,
+        row.runId,
+        row.operationId,
+        row.disposition,
+        row.reason,
+    ];
+}
+function stopParameters(row) {
+    return [row.operationId, row.runId, row.sequence];
+}
+export function effectStatements(rows) {
+    return [
+        ...rows.budgets.map((row) => ({
+            sql: budgetUpsert,
+            parameters: budgetParameters(row),
+        })),
+        ...rows.operations.map((row) => ({
+            sql: operationUpsert,
+            parameters: operationParameters(row),
+        })),
+        ...rows.leases.map((row) => ({
+            sql: leaseUpsert,
+            parameters: leaseParameters(row),
+        })),
+        ...rows.evidence.map((row) => ({
+            sql: evidenceInsert,
+            parameters: evidenceParameters(row),
+        })),
+        ...rows.stops.map((row) => ({
+            sql: stopUpsert,
+            parameters: stopParameters(row),
+        })),
+    ];
+}
+export async function persistEffects(connection, rows) {
+    for (const statement of effectStatements(rows))
+        await connection.run(statement.sql, statement.parameters);
+}

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

@@ -0,0 +1,67 @@
+import { type SqlConnection } from "./domain-rows.ts";
+export interface BudgetRow {
+    readonly runId: string;
+    readonly effectLimit: number;
+    readonly spent: number;
+    readonly capabilities: string;
+    readonly exhaustedSequence: number | null;
+}
+export interface OperationRow {
+    readonly operationId: string;
+    readonly runId: string;
+    readonly capability: string;
+    readonly method: string;
+    readonly target: string;
+    readonly payload: string;
+    readonly inputDigest: string;
+    readonly units: number;
+    readonly leaseKey: string;
+    readonly recoveryLimit: number;
+    readonly status: string;
+    readonly reason: string | null;
+    readonly attempts: number;
+    readonly receipt: string | null;
+    readonly worker: string | null;
+    readonly result: string | null;
+    readonly requestedSequence: number;
+    readonly waitSequence: number | null;
+    readonly settledSequence: number | null;
+}
+export interface LeaseRow {
+    readonly resourceKey: string;
+    readonly operationId: string;
+    readonly generation: number;
+    readonly expiresAt: string;
+    readonly state: string;
+    readonly grantedSequence: number;
+}
+export interface EvidenceRow {
+    readonly sequence: number;
+    readonly runId: string;
+    readonly operationId: string;
+    readonly disposition: string;
+    readonly reason: string | null;
+}
+export interface StopRow {
+    readonly operationId: string;
+    readonly runId: string;
+    readonly sequence: number;
+}
+export interface EffectRows {
+    readonly budgets: readonly BudgetRow[];
+    readonly operations: readonly OperationRow[];
+    readonly leases: readonly LeaseRow[];
+    readonly evidence: readonly EvidenceRow[];
+    readonly stops: readonly StopRow[];
+}
+export declare const budgetColumns = "run_id, effect_limit, spent, capabilities, exhausted_sequence";
+export declare const operationColumns = "operation_id, run_id, capability, method, target, payload, input_digest, units, lease_key, recovery_limit, status, reason, attempts, receipt, worker, result, requested_sequence, wait_sequence, settled_sequence";
+export declare const leaseColumns = "resource_key, operation_id, generation, expires_at, state, granted_sequence";
+export declare const evidenceColumns = "sequence, run_id, operation_id, disposition, reason";
+export declare const stopColumns = "operation_id, run_id, sequence";
+export declare function budgetRow(row: unknown): BudgetRow;
+export declare function operationRow(row: unknown): OperationRow;
+export declare function leaseRow(row: unknown): LeaseRow;
+export declare function evidenceRow(row: unknown): EvidenceRow;
+export declare function stopRow(row: unknown): StopRow;
+export declare function loadEffects(connection: SqlConnection): Promise<EffectRows>;