cloving 0.3.20 → 1.1.0

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;
+}

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;