cloving 0.3.20 → 1.1.0

package/dist/src/broker/actor/adapter-outcomes.js

@@ -0,0 +1,80 @@
+import { isIdentifier } from "../../authority/commands.js";
+function unknown(reason) {
+    return { kind: "unknown", reason };
+}
+const malformed = unknown("invalid-adapter-reply");
+function field(value, name) {
+    return Reflect.get(Object(value), name);
+}
+function accepted(reply) {
+    const receipt = field(reply, "receipt");
+    const worker = field(reply, "worker");
+    if (!isIdentifier(receipt) || !isIdentifier(worker))
+        return malformed;
+    return { kind: "accepted", receipt, worker };
+}
+function optionalIdentifier(value) {
+    if (value === undefined || value === null)
+        return null;
+    return isIdentifier(value) ? value : undefined;
+}
+function identity(reply) {
+    const receipt = optionalIdentifier(field(reply, "receipt"));
+    const worker = optionalIdentifier(field(reply, "worker"));
+    if (receipt === undefined || worker === undefined)
+        return undefined;
+    return { receipt, worker };
+}
+function completed(reply, resultBytes) {
+    const result = field(reply, "result");
+    const given = identity(reply);
+    if (typeof result !== "string" || given?.receipt == null)
+        return malformed;
+    const { receipt, worker } = given;
+    const large = Buffer.byteLength(result) > resultBytes;
+    return {
+        kind: "completed",
+        receipt,
+        worker,
+        result: large ? null : result,
+        reason: large ? "result-too-large" : null,
+    };
+}
+function failed(reply, resultBytes) {
+    const reason = field(reply, "reason");
+    const result = field(reply, "result");
+    const given = identity(reply);
+    if (!isIdentifier(reason) || given === undefined)
+        return malformed;
+    const kept = typeof result === "string" && Buffer.byteLength(result) <= resultBytes;
+    return { kind: "failed", ...given, reason, ...(kept ? { result } : {}) };
+}
+function stopped(reply) {
+    const given = identity(reply);
+    return given === undefined ? malformed : { kind: "stopped", ...given };
+}
+const mappings = {
+    absent: () => ({ kind: "absent" }),
+    accepted,
+    completed,
+    failed,
+    stopped,
+    unknown: () => unknown("adapter-unknown"),
+};
+const failures = {
+    thrown: unknown("adapter-failure"),
+    overdue: unknown("time-limit"),
+};
+function mappingOf(reply) {
+    const kind = field(reply, "kind");
+    if (kind === undefined)
+        return accepted;
+    const known = typeof kind === "string" && Object.hasOwn(mappings, kind);
+    return known ? mappings[kind] : undefined;
+}
+export function settlement(result, resultBytes) {
+    if (result.kind !== "replied")
+        return failures[result.kind];
+    const mapping = mappingOf(result.reply);
+    return mapping === undefined ? malformed : mapping(result.reply, resultBytes);
+}

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

@@ -0,0 +1,25 @@
+import { Actor, type ActorClass, type Database, type JsonObject } from "solid-objects";
+import type { PlanSettings } from "./authority-settings.ts";
+export declare const deliverEffect = "cloving.deliver";
+export declare const persistAction = "cloving.persist";
+export interface ActorParts {
+    readonly reader: Database;
+    readonly effects: PlanSettings;
+    readonly clock: () => string;
+    readonly failed: (delivery: {
+        readonly operationId: string;
+        readonly effectId: string;
+    }) => number;
+}
+export declare function authorityActor(parts: ActorParts): AuthorityActorClass;
+export type AuthorityActorClass = ActorClass<Actor & {
+    sequence: number;
+    epoch: number;
+    beginEpoch: () => JsonObject;
+    execute: (request: JsonObject) => Promise<JsonObject>;
+    adopt: () => Promise<JsonObject>;
+    recover: () => Promise<JsonObject>;
+    deliveryCompleted: (payload: JsonObject) => Promise<JsonObject>;
+    deliveryFailed: (payload: JsonObject) => Promise<JsonObject>;
+}>;
+export declare function checkedRequest(given: JsonObject): JsonObject | undefined;

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

@@ -0,0 +1,169 @@
+import { Actor, broadcastValue, } from "solid-objects";
+import { optionalInteger, text } from "../../storage/domain-rows.js";
+import { parseCommand } from "../../authority/commands.js";
+import { readExecutionManifest } from "../../execution-pin.js";
+import { documentDigest } from "../decision-restore.js";
+import { planAdoption, planCommand, planDelivery, planRecovery, } from "./turn-plan.js";
+import { json, textList } from "./authority-receipts.js";
+import { completedOutcome, thrownOutcome, } from "./delivery-results.js";
+import { adoptionTurn, commandTurn, deliveryTurn, recoverableIntents, recoveryTurn, stopRecoveries, } from "./turn-state.js";
+export const deliverEffect = "cloving.deliver";
+export const persistAction = "cloving.persist";
+export function authorityActor(parts) {
+    const { reader } = parts;
+    return class ClovingAuthority extends Actor {
+        static actorType = "ClovingAuthority";
+        static stateVersion = 1;
+        sequence = 0;
+        epoch = 0;
+        observables() {
+            return { sequence: broadcastValue(this.sequence) };
+        }
+        beginEpoch() {
+            this.epoch += 1;
+            return { epoch: this.epoch, sequence: this.sequence };
+        }
+        execute(request) {
+            return executeCommand(this, { parts, request });
+        }
+        async adopt() {
+            return applyPlan(this, planAdoption(await reader.connection(adoptionTurn)));
+        }
+        recover() {
+            return recoverTurn(this, parts);
+        }
+        deliveryCompleted(payload) {
+            return settleDelivery(this, {
+                parts,
+                outcome: completedOutcome(payload, present(this, parts)),
+            });
+        }
+        deliveryFailed(payload) {
+            return settleDelivery(this, {
+                parts,
+                outcome: thrownOutcome(payload, present(this, parts)),
+            });
+        }
+    };
+}
+async function recoverTurn(actor, parts) {
+    const scope = { sequence: actor.sequence, capacity: parts.effects.capacity };
+    return applyPlan(actor, planRecovery({
+        ...(await parts.reader.connection(async (connection) => ({
+            intents: [
+                ...(await recoverableIntents(connection)),
+                ...(await stopRecoveries(connection, {
+                    capacity: parts.effects.capacity,
+                    stopLimit: parts.effects.stopLimit,
+                    stopSupported: parts.effects.stopSupported,
+                })),
+            ],
+            turn: await recoveryTurn(connection, scope),
+        }))),
+        effects: parts.effects,
+        recordedAt: parts.clock(),
+    }));
+}
+async function executeCommand(actor, input) {
+    const { parts, request } = input;
+    const turn = await parts.reader.connection((connection) => commandTurn(connection, {
+        command: request["command"],
+        sequence: actor.sequence,
+        capacity: parts.effects.capacity,
+    }));
+    return applyPlan(actor, planCommand({
+        turn,
+        request: turnRequest(request),
+        epoch: actor.epoch,
+        effects: parts.effects,
+    }));
+}
+async function settleDelivery(actor, input) {
+    const { parts, outcome } = input;
+    const found = await parts.reader.connection((connection) => deliveryTurn(connection, {
+        effectId: outcome.effectId,
+        sequence: actor.sequence,
+        capacity: parts.effects.capacity,
+    }));
+    if (found?.delivery.outcome !== null ||
+        found.delivery.operationId !== outcome.operationId ||
+        found.delivery.inputDigest !== outcome.inputDigest)
+        actor.reject("stale_callback", {
+            message: "the callback does not match an open delivery",
+        });
+    return applyPlan(actor, planDelivery({
+        turn: found.turn,
+        delivery: {
+            ...outcome,
+            runId: found.runId,
+            intent: found.intent,
+            leaseGeneration: found.leaseGeneration,
+            purpose: found.purpose,
+            attempts: failures(parts, outcome),
+        },
+        epoch: actor.epoch,
+        effects: parts.effects,
+    }));
+}
+function failures(parts, outcome) {
+    return outcome.outcome === "thrown" ? parts.failed(outcome) : 0;
+}
+function applyPlan(actor, plan) {
+    if (plan.kind === "answer")
+        return json(plan.receipt);
+    const staged = plan.stage.map((intent) => ({
+        effect_id: actor.emit(deliverEffect, {
+            arguments: { ...intent },
+            onSuccess: "deliveryCompleted",
+            onFailure: "deliveryFailed",
+        }).id,
+        operation_id: intent.operationId,
+        input_digest: intent.inputDigest,
+        purpose: intent.purpose,
+        lease_generation: intent.leaseGeneration ?? null,
+        authority_epoch: actor.epoch,
+    }));
+    actor.commitAction(persistAction, { ...plan.change, staged });
+    actor.sequence = plan.change.sequence;
+    return json(plan.receipt);
+}
+function present(actor, parts) {
+    return { epoch: actor.epoch, recordedAt: parts.clock() };
+}
+export function checkedRequest(given) {
+    const bodies = textList(given["documents"]);
+    if (bodies === undefined || parseCommand(given["command"]) === null)
+        return undefined;
+    const documents = bodies.map((body) => ({
+        digest: documentDigest(body),
+        body,
+    }));
+    try {
+        const request = turnRequest({ ...given, documents });
+        return json({
+            ...request,
+            manifest: request.manifest ?? null,
+            epoch: request.epoch ?? null,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function turnRequest(request) {
+    const manifest = request["manifest"];
+    const epoch = optionalInteger(request, "epoch");
+    const documents = request["documents"];
+    return {
+        command: request["command"],
+        recordedAt: text(request, "recordedAt"),
+        documents: (Array.isArray(documents) ? documents : []).map((document) => ({
+            digest: text(document, "digest"),
+            body: text(document, "body"),
+        })),
+        ...(manifest === undefined || manifest === null
+            ? {}
+            : { manifest: readExecutionManifest(manifest) }),
+        ...(epoch === null ? {} : { epoch }),
+    };
+}

package/dist/src/broker/actor/authority-changes.d.ts

@@ -0,0 +1,31 @@
+export type SequenceListener = (sequence: number) => void;
+interface Envelope {
+    readonly kind: string;
+    readonly observables?: Readonly<Record<string, unknown>>;
+}
+export interface Realtime {
+    connect(options: {
+        readonly authorizationContext: unknown;
+        readonly send: (envelope: Envelope) => void;
+    }): {
+        receive(request: unknown): Promise<void>;
+        close(): void;
+    };
+}
+export interface SequenceSource {
+    readonly realtime: Realtime;
+    readonly broker: object;
+    readonly actorType: string;
+    readonly actorId: string;
+}
+export declare function sequenceChanges(source: SequenceSource, listener: SequenceListener): () => void;
+export declare function sequenceSubscriber(source: Pick<SequenceSource, "realtime" | "broker">): (actorId: string, listener: SequenceListener) => () => void;
+export interface SequenceChanges {
+    readonly subscribe: (listener: SequenceListener) => () => void;
+}
+export interface Subscriptions {
+    readonly add: (listener: SequenceListener) => () => void;
+    readonly close: () => void;
+}
+export declare function subscriptions(subscribe: (listener: SequenceListener) => () => void): Subscriptions;
+export {};

package/dist/src/broker/actor/authority-changes.js

@@ -0,0 +1,46 @@
+export function sequenceChanges(source, listener) {
+    let last = -1;
+    const session = source.realtime.connect({
+        authorizationContext: source.broker,
+        send: (envelope) => {
+            const sequence = envelope.observables?.["sequence"];
+            if (typeof sequence !== "number" || sequence <= last)
+                return;
+            last = sequence;
+            listener(sequence);
+        },
+    });
+    const request = {
+        version: 1,
+        action: "subscribe",
+        actorType: source.actorType,
+        actorId: source.actorId,
+    };
+    session.receive(request).then(undefined, () => {
+        session.close();
+    });
+    return () => {
+        session.close();
+    };
+}
+export function sequenceSubscriber(source) {
+    return (actorId, listener) => sequenceChanges({ ...source, actorType: "ClovingAuthority", actorId }, listener);
+}
+export function subscriptions(subscribe) {
+    const open = new Set();
+    return {
+        add: (listener) => {
+            const close = subscribe(listener);
+            open.add(close);
+            return () => {
+                open.delete(close);
+                close();
+            };
+        },
+        close: () => {
+            for (const close of open)
+                close();
+            open.clear();
+        },
+    };
+}

package/dist/src/broker/actor/authority-connection.d.ts

@@ -0,0 +1,15 @@
+import type { Database } from "solid-objects";
+export declare const contentionMilliseconds = 250;
+export interface ConnectionSettings {
+    readonly schemaVersion: number;
+    readonly journalMode: string;
+    readonly synchronous: number;
+    readonly foreignKeys: number;
+    readonly lockingMode: string;
+    readonly busyTimeoutMilliseconds: number;
+}
+export declare function lockExclusively(database: Database): Promise<void>;
+export declare function takeOwnership(database: Database): Promise<void>;
+export declare function observeSettings(database: Database): Promise<ConnectionSettings>;
+export declare function requiredSettingsViolation(settings: ConnectionSettings): string | null;
+export declare function lockContention(error: unknown): boolean;

package/dist/src/broker/actor/authority-connection.js

@@ -0,0 +1,44 @@
+import { integer, text } from "../../storage/domain-rows.js";
+export const contentionMilliseconds = 250;
+const required = {
+    journalMode: "wal",
+    synchronous: 2,
+    foreignKeys: 1,
+    lockingMode: "exclusive",
+    busyTimeoutMilliseconds: contentionMilliseconds,
+};
+export async function lockExclusively(database) {
+    await database.connection(async (connection) => {
+        await connection.run("PRAGMA locking_mode = EXCLUSIVE");
+    });
+}
+export async function takeOwnership(database) {
+    await database.connection(async (connection) => {
+        await connection.run("PRAGMA journal_mode = WAL");
+        await connection.run("PRAGMA synchronous = FULL");
+        await connection.run("PRAGMA foreign_keys = ON");
+    });
+    await database.transaction(() => Promise.resolve());
+}
+export function observeSettings(database) {
+    return database.connection(async (connection) => {
+        const pragma = async (name) => connection.get(`PRAGMA ${name}`);
+        return {
+            schemaVersion: integer(await pragma("user_version"), "user_version"),
+            journalMode: text(await pragma("journal_mode"), "journal_mode"),
+            synchronous: integer(await pragma("synchronous"), "synchronous"),
+            foreignKeys: integer(await pragma("foreign_keys"), "foreign_keys"),
+            lockingMode: text(await pragma("locking_mode"), "locking_mode"),
+            busyTimeoutMilliseconds: integer(await pragma("busy_timeout"), "timeout"),
+        };
+    });
+}
+export function requiredSettingsViolation(settings) {
+    const key = Object.keys(required).find((name) => Reflect.get(settings, name) !== Reflect.get(required, name));
+    return key === undefined
+        ? null
+        : `${key}=${String(Reflect.get(settings, key))}`;
+}
+export function lockContention(error) {
+    return (Number(Reflect.get(Object(error), "errcode")) & 0xff) === 5;
+}

package/dist/src/broker/actor/authority-conversion.d.ts

@@ -0,0 +1,10 @@
+import { type AuthorityOptions, type Refusal } from "./authority-runtime.ts";
+export interface ConversionOptions extends Pick<AuthorityOptions, "instrumentation" | "timing"> {
+    readonly progress?: (step: string) => void;
+}
+export type Conversion = {
+    readonly kind: "converted";
+    readonly sequence: number;
+    readonly staged: number;
+} | Refusal;
+export declare function convertAuthority(directory: string, options?: ConversionOptions): Promise<Conversion>;

package/dist/src/broker/actor/authority-conversion.js

@@ -0,0 +1,72 @@
+import { integer, latestSequence, loadBaseline, } from "../../storage/domain-rows.js";
+import { adoptSchema, authorityIdentity } from "../../storage/domain-schema.js";
+import { restore } from "../authority-restore.js";
+import { upgradeSteps } from "./authority-upgrades.js";
+import { ownedRuntime, recoverDeliveries, refused, } from "./authority-runtime.js";
+const adoptionKey = "cloving-adoption";
+export async function convertAuthority(directory, options = {}) {
+    const owned = await ownedRuntime(directory, {
+        ...(options.instrumentation === undefined
+            ? {}
+            : { instrumentation: options.instrumentation }),
+        ...(options.timing === undefined ? {} : { timing: options.timing }),
+    });
+    if (owned.kind === "refused")
+        return owned;
+    let conversion;
+    try {
+        conversion = await converted(owned, options);
+    }
+    catch (error) {
+        conversion = refused("storage-failure", error);
+    }
+    await owned.parts.stop();
+    return conversion;
+}
+async function converted(owned, options) {
+    const { database, schema } = owned;
+    const progress = options.progress ?? (() => undefined);
+    if (schema.kind === "new")
+        return { kind: "refused", reason: "nothing-to-convert", detail: "0" };
+    const restored = restore(await database.connection(loadBaseline));
+    if (restored.kind === "refused")
+        return restored;
+    progress("baseline-validated");
+    if (schema.kind === "baseline") {
+        await database.transaction((connection) => adoptSchema(connection, restored.state.sequence));
+        progress("schema-adopted");
+    }
+    const from = schema.kind === "baseline" ? "adopted" : schema.kind;
+    for (const step of upgradeSteps(from)) {
+        const stored = restore(await database.connection(step.load));
+        if (stored.kind === "refused")
+            return stored;
+        await step.apply(database, stored.state);
+    }
+    if (schema.kind !== "current")
+        progress("schema-upgraded");
+    const identity = await database.connection(authorityIdentity);
+    if (identity.pendingAdoption === null)
+        return {
+            kind: "converted",
+            sequence: await database.connection(latestSequence),
+            staged: 0,
+        };
+    return adopted({
+        parts: owned.parts,
+        actorId: identity.actorId,
+        progress: options.progress,
+    });
+}
+async function adopted(adoption) {
+    const { parts, actorId, progress } = adoption;
+    await parts.runtime.install();
+    await parts.releaseEarlierOwners();
+    progress?.("library-installed");
+    const result = await parts.invoker(actorId, adoptionKey).adopt();
+    return {
+        kind: "converted",
+        sequence: integer(result, "sequence"),
+        staged: await recoverDeliveries(parts.invoker(actorId)),
+    };
+}

package/dist/src/broker/actor/authority-delivery.d.ts

@@ -0,0 +1,13 @@
+import type { Database, EffectContext, JsonObject } from "solid-objects";
+import { type AvailableManifest, type Delivery } from "./delivery-intents.ts";
+import type { EffectSettings } from "./authority-settings.ts";
+export type { AdapterOutcome, AvailableManifest, Delivery, DeliveryIntent, Reconciliation, } from "./delivery-intents.ts";
+export interface DeliveryParts {
+    readonly reader: Database;
+    readonly delivery: Delivery | undefined;
+    readonly epoch: () => number;
+    readonly clock: () => string;
+    readonly available: AvailableManifest | undefined;
+    readonly effects: EffectSettings;
+}
+export declare function deliveryHandler(parts: DeliveryParts): (argumentsValue: JsonObject, context: EffectContext) => Promise<JsonObject>;

package/dist/src/broker/actor/authority-delivery.js

@@ -0,0 +1,162 @@
+import { isIdentifier } from "../../authority/commands.js";
+import { optionalInteger, optionalText, text, } from "../../storage/domain-rows.js";
+import { intentKind } from "../authority-restore.js";
+import { intentDigest, } from "./delivery-intents.js";
+import { adapterCalls, } from "./adapter-calls.js";
+import { deliverEffect, protectedArguments } from "./effect-delivery.js";
+import { pinned } from "./pin-check.js";
+const eligibleStatus = {
+    "start-run": "queued",
+    "continue-run": "running",
+};
+function admission(parts, attempt) {
+    const { intent, effectId } = attempt;
+    return parts.reader.connection(async (connection) => {
+        const row = await connection.get("SELECT d.outcome, d.input_digest, o.released_sequence, r.status, r.workflow FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id JOIN runs r ON r.run_id = o.run_id WHERE d.effect_id = ? AND d.operation_id = ?", [effectId, intent.operationId]);
+        if (!current(row, intent))
+            return "stale";
+        if (!eligible(row, intent))
+            return "withheld";
+        const admitted = await pinned(connection, {
+            workflow: intent.workflow,
+            available: parts.available,
+        });
+        return admitted ? "sent" : "blocked";
+    });
+}
+async function called(attempt, name) {
+    const { intent, delivery, calls } = attempt;
+    const result = await calls.call(intent.operationId, (signal) => delivery[name](intent, signal));
+    if (result.kind === "replied")
+        return result.reply;
+    throw new Error(result.kind === "thrown" ? result.message : "adapter-time-limit");
+}
+const confirmations = ["stopped", "completed", "failed"];
+function observation(result) {
+    if (result.kind !== "replied")
+        return { kind: "unknown" };
+    const kind = Reflect.get(Object(result.reply), "kind");
+    const receipt = Reflect.get(Object(result.reply), "receipt");
+    if (typeof kind === "string" && confirmations.includes(kind))
+        return { kind: "stopped" };
+    if (kind === "absent")
+        return { kind: "absent" };
+    return kind === "accepted" && isIdentifier(receipt)
+        ? { kind: "sent", receipt }
+        : { kind: "unknown" };
+}
+async function observed(attempt, name) {
+    const { intent, delivery, calls } = attempt;
+    const call = delivery[name]?.bind(delivery);
+    if (call === undefined)
+        return { kind: "unknown" };
+    return observation(await calls.call(intent.operationId, (signal) => call(intent, signal)));
+}
+async function observeRun(parts, attempt) {
+    const { intent, effectId } = attempt;
+    const open = await parts.reader.connection(async (connection) => current(await connection.get("SELECT d.outcome, d.input_digest, r.workflow FROM deliveries d JOIN outbox o ON o.operation_id = d.operation_id JOIN runs r ON r.run_id = o.run_id WHERE d.effect_id = ? AND d.operation_id = ?", [effectId, intent.operationId]), intent));
+    const result = open ? await requested(attempt) : { kind: "withheld" };
+    return {
+        receipt: null,
+        ...result,
+        epoch: parts.epoch(),
+        recordedAt: parts.clock(),
+    };
+}
+async function requested(attempt) {
+    if (attempt.intent.purpose !== "stop")
+        return observed(attempt, "reconcile");
+    const stopped = await observed(attempt, "stop");
+    return stopped.kind === "stopped" ? stopped : observed(attempt, "reconcile");
+}
+async function deliverRun(parts, attempt) {
+    if (attempt.intent.purpose !== "dispatch")
+        return observeRun(parts, attempt);
+    const first = await admission(parts, attempt);
+    const settled = { epoch: parts.epoch(), recordedAt: parts.clock() };
+    const unsent = (kind) => ({
+        kind: kind === "stale" ? "withheld" : kind,
+        receipt: null,
+        ...settled,
+    });
+    if (first === "stale")
+        return unsent(first);
+    const known = acceptedReceipt(await called(attempt, "reconcile"));
+    if (known !== undefined)
+        return { kind: "sent", receipt: known, ...settled };
+    if (first !== "sent")
+        return unsent(first);
+    const second = await admission(parts, attempt);
+    if (second !== "sent")
+        return unsent(second);
+    const receipt = sentReceipt(await called(attempt, "deliver"));
+    return { kind: "sent", receipt, ...settled };
+}
+export function deliveryHandler(parts) {
+    const calls = adapterCalls(parts.effects.adapterMilliseconds);
+    return async (argumentsValue, context) => {
+        const { delivery } = parts;
+        if (delivery === undefined)
+            throw new Error("delivery-unconfigured");
+        const intent = argumentsIntent(argumentsValue);
+        if (intent.kind !== "protected-effect")
+            return deliverRun(parts, {
+                intent,
+                effectId: context.id,
+                delivery,
+                calls,
+            });
+        return deliverEffect({ ...parts, delivery, calls }, {
+            intent: { ...intent, ...protectedArguments(argumentsValue) },
+            effectId: context.id,
+        });
+    };
+}
+function acceptedReceipt(value) {
+    const kind = Reflect.get(Object(value), "kind");
+    if (kind === "absent")
+        return undefined;
+    const receipt = Reflect.get(Object(value), "receipt");
+    if (kind !== "accepted" || !isIdentifier(receipt))
+        throw new Error("invalid-reconciliation");
+    return receipt;
+}
+function sentReceipt(value) {
+    const receipt = Reflect.get(Object(value), "receipt");
+    if (!isIdentifier(receipt))
+        throw new Error("invalid-delivery-receipt");
+    return receipt;
+}
+function current(row, intent) {
+    return (row !== undefined &&
+        Reflect.get(Object(row), "outcome") === null &&
+        text(row, "input_digest") === intent.inputDigest &&
+        intentDigest(intent) === intent.inputDigest &&
+        text(row, "workflow") === intent.workflow);
+}
+function eligible(row, intent) {
+    return (optionalInteger(row, "released_sequence") === null &&
+        text(row, "status") === eligibleStatus[intent.kind]);
+}
+const purposes = ["reconcile", "stop"];
+function purposeOf(value) {
+    return purposes.find((purpose) => purpose === value) ?? "dispatch";
+}
+function argumentsIntent(value) {
+    const base = {
+        kind: intentKind(text(value, "kind")),
+        runId: text(value, "runId"),
+        operationId: text(value, "operationId"),
+        workflow: text(value, "workflow"),
+        inputDigest: text(value, "inputDigest"),
+        purpose: purposeOf(value["purpose"]),
+    };
+    if (value["gateId"] === undefined)
+        return base;
+    return {
+        ...base,
+        gateId: text(value, "gateId"),
+        decision: text(value, "decision"),
+        answer: optionalText(value, "answer"),
+    };
+}

package/dist/src/broker/actor/authority-logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from "solid-objects";
+export declare function lineLogger(write: (text: string) => void): Logger;