cloving 1.3.0 → 1.5.0

package/dist/src/authority/instants.js

@@ -36,3 +36,24 @@ export function notBefore(value, bound) {
 export function isAfter(value, bound) {
     return notBefore(value, bound) && !notBefore(bound, value);
 }
+function leapDaysBefore(year) {
+    const previous = year - 1;
+    return (Math.floor(previous / 4) -
+        Math.floor(previous / 100) +
+        Math.floor(previous / 400));
+}
+export function instantMilliseconds(value) {
+    if (!isInstant(value))
+        throw new Error("invalid-instant");
+    const year = Number(value.slice(0, 4));
+    const month = Number(value.slice(5, 7));
+    let days = Number(value.slice(8, 10)) - 1;
+    for (let preceding = 1; preceding < month; preceding += 1)
+        days += daysIn(year, preceding);
+    days += 365 * (year - 1970) + leapDaysBefore(year) - leapDaysBefore(1970);
+    return (days * 86_400_000 +
+        Number(value.slice(11, 13)) * 3_600_000 +
+        Number(value.slice(14, 16)) * 60_000 +
+        Number(value.slice(17, 19)) * 1000 +
+        Number(value.slice(20, 23)));
+}

package/dist/src/authority/reduction-state.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitsState } from "./command-waits.ts";
 import { type RunDetails } from "./details.ts";
 import { type GateState } from "./gates.ts";
 import { type Disposition, type EffectState } from "./operations.ts";
@@ -20,6 +21,7 @@ export interface Recorded {
 }
 export interface Change extends Recorded {
     readonly moved?: RunState;
+    readonly commandWaits?: CommandWaitsState;
     readonly gates?: readonly GateState[];
     readonly added?: readonly EffectIntent[];
     readonly questions?: number;

package/dist/src/authority/reduction-state.js

@@ -1,3 +1,4 @@
+import { closedCommandWaits } from "./command-waits.js";
 import { operationIdentity } from "../operation-identity.js";
 import { continued } from "./details.js";
 import { gateKey } from "./gates.js";
@@ -40,12 +41,16 @@ function nextDetails(change) {
 }
 export function applied(state, change) {
     const { event } = change;
+    const waits = change.commandWaits ?? state.commandWaits;
     return {
         kind: "applied",
         ...(change.disposition === undefined
             ? {}
             : { disposition: change.disposition }),
         state: {
+            ...(waits === undefined
+                ? {}
+                : { commandWaits: closedCommandWaits(waits, event) }),
             sequence: event.sequence,
             runs: change.moved
                 ? { ...state.runs, [event.runId]: change.moved }

package/dist/src/authority/reduction.js

@@ -1,3 +1,6 @@
+import { checkedCommandWait } from "./command-wait-checks.js";
+import { waitEffectTime, waitEffectChange } from "./command-wait-results.js";
+import { commandWaitKey, commandWaitsAfter, validCommandWaitTime, } from "./command-waits.js";
 import { admittedDetails, observed } from "./details.js";
 import { settled } from "./gates.js";
 import { admittedBudgets } from "./budgets.js";
@@ -57,6 +60,8 @@ function dispatched(state, recorded) {
 function effect(rule) {
     return (state, recorded) => {
         const { event, run } = recorded;
+        if (!waitEffectTime(state.commandWaits ?? {}, event))
+            return invalid("invalid-recorded-time");
         const result = rule(state.effects, { event, runStatus: run.status });
         if (result.kind === "invalid")
             return result;
@@ -64,6 +69,7 @@ function effect(rule) {
         return applied(state, {
             ...recorded,
             effects: result.effects,
+            ...waitEffectChange(state, { event, result }),
             ...(result.released === undefined ? {} : { released: result.released }),
             ...(result.disposition === undefined
                 ? {}
@@ -78,8 +84,24 @@ function effect(rule) {
         });
     };
 }
+const changeCommandWait = (state, recorded) => {
+    const { event, run } = recorded;
+    const waits = state.commandWaits ?? {};
+    const key = commandWaitKey(event.runId, event.payload["waitName"] ?? "");
+    if (event.type === "command-wait.opened" &&
+        waits[key] === undefined &&
+        run.status !== "running")
+        return invalid("command-wait-run-not-running");
+    const result = commandWaitsAfter(waits, event);
+    return result.kind === "invalid"
+        ? result
+        : applied(state, { ...recorded, commandWaits: result.waits });
+};
 const handlers = {
     "schedule.skipped": applied,
+    "command-wait.opened": changeCommandWait,
+    "command-wait.checked": checkedCommandWait,
+    "command-wait.expired": changeCommandWait,
     "effect.requested": effect(requested),
     "lease.granted": effect(granted),
     "lease.expired": effect(leaseExpired),
@@ -146,6 +168,8 @@ function created(state, recorded) {
     };
 }
 export function reduce(state, event) {
+    if (!validCommandWaitTime(state.commandWaits ?? {}, event))
+        return invalid("invalid-command-wait-time");
     if (event.sequence !== state.sequence + 1)
         return invalid("sequence-gap");
     if (state.commands[event.commandId])

package/dist/src/authority/status-input.d.ts

@@ -1,3 +1,4 @@
+import type { CommandWaitView } from "./command-wait-view.ts";
 import type { RunDetails } from "./details.ts";
 import type { GateState } from "./gates.ts";
 import type { RunClosure } from "./stop-sequence.ts";
@@ -21,6 +22,7 @@ export interface BudgetSummary {
     readonly spent: number;
 }
 export interface StatusInput {
+    readonly commandWaits: readonly CommandWaitView[];
     readonly run: RunState;
     readonly details: RunDetails | undefined;
     readonly gates: readonly GateState[];

package/dist/src/authority/status.d.ts

@@ -1,3 +1,4 @@
+import type { CommandWaitView } from "./command-wait-view.ts";
 import { type EffectView, type Recovery } from "./status-effects.ts";
 import { type BudgetSummary, type StatusInput } from "./status-input.ts";
 import type { RunStatus } from "./transitions.ts";
@@ -5,6 +6,7 @@ export { unresolved, unresolvedEffects } from "./status-closure.ts";
 export type { EffectView } from "./status-effects.ts";
 export type { Assessment, BudgetSummary, EffectSummary, OperationSummary, StatusInput, } from "./status-input.ts";
 export interface RunView {
+    readonly commandWaits: readonly CommandWaitView[];
     readonly runId: string;
     readonly workflow: string;
     readonly state: RunStatus;

package/dist/src/authority/status.js

@@ -266,6 +266,7 @@ export function runView(input) {
             attempts: observation?.attempt ?? 0,
             limit: observation?.limit ?? null,
         },
+        commandWaits: input.commandWaits,
         budget: input.budget,
         effects: effectViews(input.effects),
         nextAction: assessment.nextAction,

package/dist/src/authority/stop-sequence.d.ts

@@ -5,6 +5,7 @@ export interface AttemptSummary {
     readonly stagedSequence: number;
 }
 export interface StopSubject {
+    readonly stopSequence?: number;
     readonly operationId: string;
     readonly kind: string;
     readonly attempts: readonly AttemptSummary[];

package/dist/src/authority/stop-sequence.js

@@ -39,7 +39,8 @@ const stopPurposes = ["stop", "reconcile"];
 export function stopCount(subject, cancelledSequence) {
     return subject.attempts.filter((attempt) => attempt.outcome !== null &&
         stopPurposes.includes(attempt.purpose) &&
-        attempt.stagedSequence >= cancelledSequence).length;
+        attempt.stagedSequence >=
+            Math.max(cancelledSequence, subject.stopSequence ?? 0)).length;
 }
 const uncertainStatuses = ["recovering", "blocked"];
 function uncertain(subject) {

package/dist/src/authority/transitions.d.ts

@@ -1,3 +1,4 @@
+import type { CommandWaitsState } from "./command-waits.ts";
 import type { RunDetails } from "./details.ts";
 import type { GateState } from "./gates.ts";
 import type { EffectState } from "./operations.ts";
@@ -26,9 +27,10 @@ export interface AuthorityState {
     readonly gates: Readonly<Record<string, GateState>>;
     readonly details: Readonly<Record<string, RunDetails>>;
     readonly questions: number;
+    readonly commandWaits?: CommandWaitsState;
     readonly effects: EffectState;
 }
-export declare const eventTypes: readonly ["run.created", "run.started", "gate.opened", "gate.wait-registered", "gate.decided", "gate.expired", "run.paused", "run.resumed", "run.completed", "run.failed", "run.cancelled", "run.observed", "step.dispatched", "effect.requested", "lease.granted", "lease.expired", "effect.reported", "operation.reconciled", "schedule.skipped"];
+export declare const eventTypes: readonly ["run.created", "run.started", "gate.opened", "gate.wait-registered", "gate.decided", "gate.expired", "run.paused", "run.resumed", "run.completed", "run.failed", "run.cancelled", "run.observed", "step.dispatched", "effect.requested", "lease.granted", "lease.expired", "effect.reported", "operation.reconciled", "schedule.skipped", "command-wait.opened", "command-wait.checked", "command-wait.expired"];
 export type EventType = (typeof eventTypes)[number];
 export interface AuthorityEvent {
     readonly sequence: number;
@@ -39,8 +41,8 @@ export interface AuthorityEvent {
     readonly request: string;
     readonly payload: Readonly<Record<string, string>>;
 }
-export declare const numberFields: readonly ["expectedRevision", "expectedObservation", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity", "slot"];
-export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "workflowId", "submission", "input", "resolver", "gateId", "gateKind", "waitMode", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result", "actor"];
+export declare const numberFields: readonly ["expectedRevision", "expectedObservation", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity", "slot", "maximumWaitSeconds", "pollEverySeconds"];
+export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "workflowId", "submission", "input", "resolver", "gateId", "gateKind", "waitMode", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result", "actor", "waitName", "commandOutput"];
 export type NumberField = (typeof numberFields)[number];
 export type TextField = (typeof textFields)[number];
 export type AuthorityCommand = {
@@ -48,7 +50,7 @@ export type AuthorityCommand = {
     readonly commandId: string;
     readonly runId: string;
 } & Readonly<Partial<Record<NumberField, number>>> & Readonly<Partial<Record<TextField, string>>>;
-export type Move = Exclude<EventType, "run.created" | "step.dispatched" | "gate.wait-registered" | "run.observed" | "effect.requested" | "lease.granted" | "lease.expired" | "effect.reported" | "operation.reconciled" | "schedule.skipped">;
+export type Move = Exclude<EventType, "run.created" | "step.dispatched" | "gate.wait-registered" | "run.observed" | "effect.requested" | "lease.granted" | "lease.expired" | "effect.reported" | "operation.reconciled" | "schedule.skipped" | "command-wait.opened" | "command-wait.checked" | "command-wait.expired">;
 export declare const terminal: readonly RunStatus[];
 export type Transition = {
     readonly kind: "moved";

package/dist/src/authority/transitions.js

@@ -18,6 +18,9 @@ export const eventTypes = [
     "effect.reported",
     "operation.reconciled",
     "schedule.skipped",
+    "command-wait.opened",
+    "command-wait.checked",
+    "command-wait.expired",
 ];
 export const numberFields = [
     "expectedRevision",
@@ -32,6 +35,8 @@ export const numberFields = [
     "sourceGeneration",
     "capacity",
     "slot",
+    "maximumWaitSeconds",
+    "pollEverySeconds",
 ];
 export const textFields = [
     "parentRunId",
@@ -72,6 +77,8 @@ export const textFields = [
     "issueUpdate",
     "result",
     "actor",
+    "waitName",
+    "commandOutput",
 ];
 export const terminal = [
     "completed",

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

@@ -0,0 +1,9 @@
+import type { Logger } from "solid-objects";
+export interface AuthorityHealth {
+    readonly refresh: () => Promise<void>;
+    readonly condition: () => string | null;
+}
+export declare function authorityHealth(source: {
+    readonly condition: () => Promise<string | undefined>;
+    readonly logger: Logger;
+}): AuthorityHealth;

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

@@ -0,0 +1,24 @@
+export function authorityHealth(source) {
+    const state = { condition: null, checks: 0, checked: 0 };
+    return {
+        refresh: async () => {
+            state.checks += 1;
+            const check = state.checks;
+            const detected = (await source.condition()) ?? null;
+            if (check < state.checked)
+                return;
+            state.checked = check;
+            changed(state, { detected, logger: source.logger });
+        },
+        condition: () => state.condition,
+    };
+}
+function changed(state, change) {
+    const { detected, logger } = change;
+    const previous = state.condition;
+    state.condition = detected;
+    if (previous === null && detected !== null)
+        logger.warn({ event: "authority-unhealthy", condition: detected });
+    if (previous !== null && detected === null)
+        logger.info({ event: "authority-recovered", condition: previous });
+}

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

@@ -33,6 +33,7 @@ export interface CompletionCursor {
     readonly terminal?: boolean;
 }
 export interface RunRecord extends RunState {
+    readonly admissionCommandId: string | null;
     readonly sequence: number;
 }
 export interface AuthorityQueries {
@@ -43,7 +44,7 @@ export interface AuthorityQueries {
     readonly eventsAfter: (cursor: EventCursor) => Promise<EventPage>;
     readonly latestCompletion: (cursor: CompletionCursor) => Promise<PublishedEvent | undefined>;
     readonly sequences: () => Promise<Sequences>;
-    readonly workflowIds: () => Promise<Readonly<Record<string, string>>>;
+    readonly workflowIds: (runIds?: readonly string[]) => Promise<Readonly<Record<string, string>>>;
     readonly runOrigins: () => Promise<RunOrigins>;
     readonly runLinks: () => Promise<Readonly<Record<string, RunLinks>>>;
 }

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

@@ -6,11 +6,15 @@ import { storedEvents, storedRun } from "../authority-restore.js";
 import { documentDigest } from "../decision-restore.js";
 import { runLinks, } from "../../authority/handoff-chain.js";
 async function run(connection, runId) {
-    const row = await connection.get("SELECT run_id, status, revision, workflow, paused_from, gates, sequence FROM runs WHERE run_id = ?", [runId]);
+    const row = await connection.get("SELECT r.run_id, r.status, r.revision, r.workflow, r.paused_from, r.gates, r.sequence, c.command_id AS admission_command_id FROM runs r LEFT JOIN events c ON c.run_id = r.run_id AND c.type = 'run.created' WHERE r.run_id = ? ORDER BY c.sequence LIMIT 1", [runId]);
     if (row === undefined)
         return undefined;
     const record = runRow(row);
-    return { ...storedRun(record), sequence: record.sequence };
+    return {
+        ...storedRun(record),
+        sequence: record.sequence,
+        admissionCommandId: optionalText(row, "admission_command_id"),
+    };
 }
 async function runOrigins(connection, cursor) {
     const rows = await connection.all("SELECT run_id, json_extract(payload, '$.parentRunId') AS parent_run_id, coalesce(json_extract(payload, '$.chainId'), run_id) AS chain_id FROM events WHERE type = 'run.created' AND sequence > ? AND sequence <= ? ORDER BY sequence", [cursor.after, cursor.through]);
@@ -84,8 +88,13 @@ async function sequences(connection) {
         times: Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "recorded_at")])),
     };
 }
-async function workflowIds(connection) {
-    const rows = await connection.all("SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'");
+async function workflowIds(connection, runIds) {
+    if (runIds?.length === 0)
+        return {};
+    const scoped = runIds === undefined
+        ? ""
+        : ` AND d.run_id IN (${runIds.map(() => "?").join(", ")})`;
+    const rows = await connection.all(`SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'${scoped}`, runIds);
     return Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "workflow_id")]));
 }
 function cachedOrigins(read) {
@@ -142,7 +151,7 @@ export function authorityQueries(read) {
         eventsAfter: (cursor) => read((connection) => eventsAfter(connection, cursor)),
         latestCompletion: (cursor) => read((connection) => latestCompletion(connection, cursor)),
         sequences: () => read(sequences),
-        workflowIds: () => read(workflowIds),
+        workflowIds: (runIds) => read((connection) => workflowIds(connection, runIds)),
         runOrigins: origins,
         runLinks: currentLinks,
     };

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

@@ -24,7 +24,7 @@ export function oversized(request) {
         command["kind"] === "report-effect" &&
         command["worker"] === "command";
     const limit = report
-        ? maximumRequestBytes + commandLimits.stdoutBytes * 6
+        ? maximumRequestBytes + commandLimits.stdoutBytes * 12
         : maximumRequestBytes;
     return Buffer.byteLength(JSON.stringify(request)) > limit;
 }

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

@@ -1,8 +1,9 @@
-import { type Database, type InstrumentationEvent, type JsonObject, type SolidObjectsRuntime } from "solid-objects";
+import { type Database, type InstrumentationEvent, type JsonObject, type Logger, type SolidObjectsRuntime } from "solid-objects";
 import { type SequenceListener } from "./authority-changes.ts";
 import { type SchemaState } from "../../storage/domain-schema.ts";
 import { type AvailableManifest, type Delivery } from "./authority-delivery.ts";
 import { type AuthorityTiming, type EffectSettings } from "./authority-settings.ts";
+import { type ProjectionMemory } from "./projection-memory.ts";
 export interface AuthorityOptions {
     readonly delivery?: Delivery;
     readonly timing?: AuthorityTiming;
@@ -44,11 +45,12 @@ export interface SessionLimits {
 export interface AuthorityRuntime {
     readonly runtime: SolidObjectsRuntime;
     readonly reader: Database;
+    readonly memory: ProjectionMemory;
     readonly invoker: (actorId: string, idempotencyKey?: string) => AuthorityInvoker;
     readonly stop: () => Promise<void>;
     readonly handlersSettled: () => Promise<boolean>;
     readonly setEpoch: (epoch: number) => void;
-    readonly unhealthy: () => string | undefined;
+    readonly logger: Logger;
     readonly watchMilliseconds: number;
     readonly limits: SessionLimits;
     readonly releaseEarlierOwners: () => Promise<void>;

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

@@ -11,9 +11,10 @@ import { sequenceSubscriber, } from "./authority-changes.js";
 import { contentionMilliseconds, lockContention, lockExclusively, observeSettings, requiredSettingsViolation, takeOwnership, } from "./authority-connection.js";
 import { inspectSchema, } from "../../storage/domain-schema.js";
 import { deliveryHandler, } from "./authority-delivery.js";
-import { authorityTiming, effectConfiguration, } from "./authority-settings.js";
+import { authorityLogger, authorityTiming, effectConfiguration, } from "./authority-settings.js";
 import { failureCounter, registeredRuntime, runtimeSettings, wallClock, } from "./runtime-parts.js";
 import { strandingWatchdog, } from "./authority-watchdog.js";
+import { projectionMemory, } from "./projection-memory.js";
 export { authorityTiming } from "./authority-settings.js";
 export function refused(reason, error) {
     return {
@@ -78,13 +79,6 @@ export async function recoverDeliveries(invoker) {
             return staged;
     }
 }
-function unhealthy(watchdog) {
-    const dead = watchdog.deadLettered();
-    if (dead !== undefined)
-        return `dead-lettered message ${dead}`;
-    const stranded = watchdog.stranded();
-    return stranded === undefined ? undefined : `stranded message ${stranded}`;
-}
 const deliveryCallbacks = ["deliveryCompleted", "deliveryFailed"];
 async function retryDeliveryCallbacks(retry) {
     const administration = { authorizationContext: retry.broker };
@@ -131,11 +125,18 @@ async function storedActorRefusal(check) {
     return sequence === latest ? undefined : actorSequenceMismatch;
 }
 async function condition(watch) {
-    const { runtime, broker, watchdog } = watch;
-    const dead = watchdog.deadLettered();
-    if (dead === undefined)
-        return unhealthy(watchdog);
-    return `dead-lettered message ${dead}: ${await deadLetterCause({ runtime, broker, messageId: dead })}`;
+    const { runtime, broker, database, watchdog } = watch;
+    const report = await watchdog.report((messageIds) => messageRuns(database, messageIds));
+    if (report === undefined)
+        return undefined;
+    const { kind, messageId } = report;
+    if (kind === "stranded")
+        return `stranded message ${messageId}`;
+    return `dead-lettered message ${messageId}: ${await deadLetterCause({ runtime, broker, messageId })}`;
+}
+async function messageRuns(database, messageIds) {
+    const rows = await database.connection((connection) => connection.all(`SELECT messages.id AS message_id, runs.status AS status FROM solid_messages AS messages JOIN runs ON runs.run_id = coalesce(json_extract(messages.arguments, '$.command.runId'), json_extract(messages.arguments, '$.arguments.runId')) WHERE messages.id IN (${messageIds.map(() => "?").join(", ")})`, messageIds));
+    return new Map(rows.map((row) => [text(row, "message_id"), text(row, "status")]));
 }
 async function deadLetterCause(lookup) {
     const { runtime, broker, messageId } = lookup;
@@ -150,6 +151,14 @@ async function deadLetterCause(lookup) {
         return "unreadable cause";
     }
 }
+function invokerOf(parts) {
+    const { runtime, actor, broker, timing } = parts;
+    return (actorId, idempotencyKey) => runtime.ref(actor, actorId).with({
+        authorizationContext: broker,
+        timeoutMilliseconds: timing.callTimeoutMilliseconds,
+        ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+    });
+}
 export function authorityRuntime(database, options) {
     const timing = options.timing ?? authorityTiming;
     const reader = guardApplicationDatabase(database);
@@ -159,6 +168,8 @@ export function authorityRuntime(database, options) {
         boundMilliseconds: timing.callTimeoutMilliseconds,
     });
     const effects = effectConfiguration(options);
+    const logger = authorityLogger(options.log);
+    const memory = projectionMemory({ logger });
     const shared = { reader, effects, clock: options.clock ?? wallClock };
     const ClovingAuthority = authorityActor({
         ...shared,
@@ -168,6 +179,7 @@ export function authorityRuntime(database, options) {
         database,
         actor: ClovingAuthority,
         settings: runtimeSettings({ timing, options, broker, watchdog }),
+        record: memory.record,
     });
     const delivery = trackedDelivery({
         runtime,
@@ -183,22 +195,19 @@ export function authorityRuntime(database, options) {
     return {
         runtime,
         reader,
-        invoker: (actorId, idempotencyKey) => runtime.ref(ClovingAuthority, actorId).with({
-            authorizationContext: broker,
-            timeoutMilliseconds: timing.callTimeoutMilliseconds,
-            ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
-        }),
+        memory,
+        invoker: invokerOf({ runtime, actor: ClovingAuthority, broker, timing }),
         ...delivery,
         setEpoch: (value) => {
             epoch = value;
         },
-        unhealthy: () => unhealthy(watchdog),
+        logger,
         watchMilliseconds: timing.leaseMilliseconds,
         limits: effects,
         releaseEarlierOwners: () => releaseEarlierOwners({ runtime, broker, timing }),
         retryDeliveryCallbacks: () => retryDeliveryCallbacks({ runtime, broker }),
         storedActorRefusal: (actorId) => storedActorRefusal({ database, actor: ClovingAuthority, actorId }),
-        condition: () => condition({ runtime, broker, watchdog }),
+        condition: () => condition({ runtime, broker, database, watchdog }),
         subscribe: sequenceSubscriber({ realtime: runtime.realtime, broker }),
     };
 }

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

@@ -1,35 +1,22 @@
-import type { Database, JsonObject } from "solid-objects";
-import { type AuthorityEvent, type EffectIntent } from "../../authority/reducer.ts";
-import { type ProjectionSnapshot } from "../../storage/decision-snapshots.ts";
+import type { Database, JsonObject, Logger } from "solid-objects";
+import type { AuthorityEvent, EffectIntent } from "../../authority/reducer.ts";
 import type { AdmissionResult, ExecutionManifest } from "../../workflow-admission.ts";
 import { type StoredState } from "../authority-restore.ts";
 import { type SequenceChanges, type SequenceListener } from "./authority-changes.ts";
 import { type AuthorityQueries } from "./authority-queries.ts";
 import { type EffectQueries } from "./effect-queries.ts";
+import type { OperationRecord, ProjectionMemory } from "./projection-memory.ts";
 import { type ConnectionSettings } from "./authority-connection.ts";
 import { type StoreReceipt } from "./authority-receipts.ts";
 export type { StoreReceipt } from "./authority-receipts.ts";
 export type { StoredState } from "../authority-restore.ts";
+export { operationRecords, type OperationRecord } from "./projection-memory.ts";
 export interface CommandContext {
     readonly recordedAt: string;
     readonly manifest?: ExecutionManifest;
     readonly epoch?: number;
     readonly documents?: readonly string[];
 }
-export interface OperationRecord {
-    readonly operationId: string;
-    readonly kind: EffectIntent["kind"];
-    readonly runId: string;
-    readonly createdSequence: number;
-    readonly releasedSequence: number | null;
-    readonly deliveries: readonly {
-        readonly effectId: string;
-        readonly outcome: string | null;
-        readonly receipt: string | null;
-        readonly purpose: string;
-        readonly epoch: number | null;
-    }[];
-}
 export interface Authority {
     readonly execute: (command: unknown, context: CommandContext) => Promise<StoreReceipt>;
     readonly state: () => Promise<StoredState>;
@@ -50,6 +37,7 @@ export interface Authority {
 export interface SessionParts {
     readonly database: Database;
     readonly reader: Database;
+    readonly memory: ProjectionMemory;
     readonly execute: (request: JsonObject) => Promise<unknown>;
     readonly run: (signal: AbortSignal) => Promise<void>;
     readonly stop: () => Promise<void>;
@@ -58,10 +46,9 @@ export interface SessionParts {
     readonly epoch: number;
     readonly stopLimit: number;
     readonly recoveryLimit: number;
-    readonly unhealthy: () => string | undefined;
     readonly condition: () => Promise<string | undefined>;
+    readonly logger: Logger;
     readonly watchMilliseconds: number;
     readonly subscribe: (listener: SequenceListener) => () => void;
 }
 export declare function authoritySession(parts: SessionParts): Authority;
-export declare function operationRecords(snapshot: Pick<ProjectionSnapshot, "outbox" | "deliveries">): readonly OperationRecord[];