cloving 0.3.19 → 1.0.1

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

@@ -0,0 +1,19 @@
+function line(level, entry) {
+    try {
+        return `${JSON.stringify({ level, ...entry })}\n`;
+    }
+    catch {
+        return `${JSON.stringify({ level, event: "unserializable-log-entry" })}\n`;
+    }
+}
+export function lineLogger(write) {
+    const level = (name) => (entry) => {
+        write(line(name, entry));
+    };
+    return {
+        debug: level("debug"),
+        info: level("info"),
+        warn: level("warn"),
+        error: level("error"),
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { AdministrationAuthorizationInput, AuthorizationInput, SubscriptionAuthorizationInput } from "solid-objects";
+export interface BrokerAuthorization {
+    readonly authorizeMessage: (input: AuthorizationInput) => boolean;
+    readonly authorizeQuery: (input: AuthorizationInput) => boolean;
+    readonly authorizeAdministration: (input: AdministrationAuthorizationInput) => boolean;
+    readonly authorizeDestroy: (input: object) => boolean;
+    readonly authorizeSubscription: (input: SubscriptionAuthorizationInput) => boolean;
+}
+export declare function brokerAuthorization(broker: object): BrokerAuthorization;

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

@@ -0,0 +1,11 @@
+const brokerOperations = ["adopt", "beginEpoch", "execute", "recover"];
+export function brokerAuthorization(broker) {
+    return {
+        authorizeMessage: (input) => input.authorizationContext === broker &&
+            brokerOperations.includes(input.operation),
+        authorizeQuery: () => false,
+        authorizeAdministration: (input) => input.authorizationContext === broker,
+        authorizeDestroy: () => false,
+        authorizeSubscription: (input) => input.authorizationContext === broker,
+    };
+}

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

@@ -0,0 +1,45 @@
+import type { Database } from "solid-objects";
+import type { AuthorityCommand, AuthorityEvent } from "../../authority/transitions.ts";
+import { type SqlConnection } from "../../storage/domain-rows.ts";
+export interface CommandRecord {
+    readonly commandId: string;
+    readonly sequence: number;
+    readonly runId: string;
+    readonly recordedAt: string;
+    readonly commandDigest: string;
+    readonly command: AuthorityCommand;
+}
+export type PublishedEvent = Omit<AuthorityEvent, "request">;
+export interface EventPage {
+    readonly events: readonly PublishedEvent[];
+    readonly earliest: number;
+    readonly latest: number;
+}
+export interface EventCursor {
+    readonly after: number;
+    readonly limit: number;
+    readonly runId?: string;
+}
+export interface Sequences {
+    readonly latest: number;
+    readonly runs: Readonly<Record<string, number>>;
+    readonly times: Readonly<Record<string, string>>;
+}
+export interface CompletionCursor {
+    readonly runId: string;
+    readonly atOrBefore: number;
+}
+export interface AuthorityQueries {
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly receipt: (commandId: string) => Promise<CommandRecord | undefined>;
+    readonly eventsAfter: (cursor: EventCursor) => Promise<EventPage>;
+    readonly latestCompletion: (cursor: CompletionCursor) => Promise<PublishedEvent | undefined>;
+    readonly sequences: () => Promise<Sequences>;
+    readonly workflowIds: () => Promise<Readonly<Record<string, string>>>;
+}
+export type Read = <Value>(query: (connection: SqlConnection) => Promise<Value>) => Promise<Value>;
+export declare function guardedRead(access: {
+    readonly reader: Database;
+    readonly ready: () => Promise<void>;
+}): Read;
+export declare function authorityQueries(read: Read): AuthorityQueries;

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

@@ -0,0 +1,85 @@
+import { parseCommand } from "../../authority/commands.js";
+import { documentBody } from "../../storage/decision-rows.js";
+import { integer, latestSequence, text, } from "../../storage/domain-rows.js";
+import { storedEvents } from "../authority-restore.js";
+import { documentDigest } from "../decision-restore.js";
+async function receipt(connection, commandId) {
+    const row = await connection.get("SELECT c.request, c.sequence, e.run_id, e.recorded_at FROM commands c JOIN events e ON e.sequence = c.sequence WHERE c.command_id = ?", [commandId]);
+    if (row === undefined)
+        return undefined;
+    const request = text(row, "request");
+    const command = parseCommand(JSON.parse(request));
+    if (command === null)
+        throw new Error(`invalid-command-row: ${commandId}`);
+    return {
+        commandId,
+        sequence: integer(row, "sequence"),
+        runId: text(row, "run_id"),
+        recordedAt: text(row, "recorded_at"),
+        commandDigest: documentDigest(request),
+        command,
+    };
+}
+async function eventsAfter(connection, cursor) {
+    const scoped = cursor.runId === undefined ? "" : " AND run_id = ?";
+    const parameters = cursor.runId === undefined
+        ? [cursor.after, cursor.limit]
+        : [cursor.after, cursor.runId, cursor.limit];
+    const rows = await connection.all(`SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE sequence > ?${scoped} ORDER BY sequence LIMIT ?`, parameters);
+    return {
+        events: publishedEvents(rows),
+        earliest: integer(await connection.get("SELECT coalesce(min(sequence), 0) AS sequence FROM events"), "sequence"),
+        latest: await latestSequence(connection),
+    };
+}
+function publishedEvents(rows) {
+    return storedEvents(rows.map((row) => ({
+        sequence: integer(row, "sequence"),
+        type: text(row, "type"),
+        runId: text(row, "run_id"),
+        commandId: text(row, "command_id"),
+        recordedAt: text(row, "recorded_at"),
+        request: "",
+        payload: text(row, "payload"),
+    }))).map((event) => ({
+        sequence: event.sequence,
+        type: event.type,
+        runId: event.runId,
+        commandId: event.commandId,
+        recordedAt: event.recordedAt,
+        payload: event.payload,
+    }));
+}
+async function latestCompletion(connection, cursor) {
+    const row = await connection.get("SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND type = 'run.completed' AND sequence <= ? ORDER BY sequence DESC LIMIT 1", [cursor.runId, cursor.atOrBefore]);
+    return row === undefined ? undefined : publishedEvents([row])[0];
+}
+async function sequences(connection) {
+    const rows = await connection.all("SELECT r.run_id, r.sequence, e.recorded_at FROM runs r JOIN events e ON e.sequence = r.sequence ORDER BY r.run_id");
+    return {
+        latest: await latestSequence(connection),
+        runs: Object.fromEntries(rows.map((row) => [text(row, "run_id"), integer(row, "sequence")])),
+        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'");
+    return Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "workflow_id")]));
+}
+export function guardedRead(access) {
+    const { reader, ready } = access;
+    return async (query) => {
+        await ready();
+        return reader.connection(query);
+    };
+}
+export function authorityQueries(read) {
+    return {
+        document: (digest) => read((connection) => documentBody(connection, digest)),
+        receipt: (commandId) => read((connection) => receipt(connection, commandId)),
+        eventsAfter: (cursor) => read((connection) => eventsAfter(connection, cursor)),
+        latestCompletion: (cursor) => read((connection) => latestCompletion(connection, cursor)),
+        sequences: () => read(sequences),
+        workflowIds: () => read(workflowIds),
+    };
+}

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

@@ -0,0 +1,28 @@
+import type { JsonObject } from "solid-objects";
+import type { EffectIntent } from "../../authority/reducer.ts";
+export type StoreReceipt = {
+    readonly kind: "accepted" | "duplicate";
+    readonly sequence: number;
+    readonly intents: readonly EffectIntent[];
+    readonly disposition?: string;
+} | {
+    readonly kind: "rejected";
+    readonly reason: string;
+    readonly detail?: string;
+} | {
+    readonly kind: "failed";
+    readonly reason: "storage-failure" | "storage-unavailable" | "authority-unavailable";
+    readonly detail: string;
+};
+export declare const unserializable: StoreReceipt;
+export declare const invalidCommand: StoreReceipt;
+export declare const maximumRequestBytes = 900000;
+export declare const tooLarge: StoreReceipt;
+export declare function oversized(request: JsonObject): boolean;
+export declare function failed(error: unknown): Extract<StoreReceipt, {
+    kind: "failed";
+}>;
+export declare function storeReceipt(value: unknown): StoreReceipt;
+export declare function json(value: unknown): JsonObject;
+export declare function textList(value: unknown): readonly string[] | undefined;
+export declare function serializable(value: unknown): JsonObject | undefined;

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

@@ -0,0 +1,84 @@
+import { integer, text } from "../../storage/domain-rows.js";
+import { intentKind } from "../authority-restore.js";
+export const unserializable = {
+    kind: "rejected",
+    reason: "invalid-command",
+    detail: "unserializable-command",
+};
+export const invalidCommand = {
+    kind: "rejected",
+    reason: "invalid-command",
+};
+export const maximumRequestBytes = 900_000;
+export const tooLarge = {
+    kind: "rejected",
+    reason: "request-too-large",
+    detail: `A request has at most ${String(maximumRequestBytes)} bytes.`,
+};
+export function oversized(request) {
+    return Buffer.byteLength(JSON.stringify(request)) > maximumRequestBytes;
+}
+export function failed(error) {
+    const name = String(Reflect.get(Object(error), "name"));
+    if (name === "MessageFailed")
+        return {
+            kind: "failed",
+            reason: "storage-failure",
+            detail: String(Reflect.get(Object(Reflect.get(Object(error), "details")), "message")),
+        };
+    return {
+        kind: "failed",
+        reason: "authority-unavailable",
+        detail: `${name}: ${String(Reflect.get(Object(error), "message"))}`,
+    };
+}
+export function storeReceipt(value) {
+    const kind = text(value, "kind");
+    if (kind === "rejected") {
+        const detail = Reflect.get(Object(value), "detail");
+        return {
+            kind,
+            reason: text(value, "reason"),
+            ...(typeof detail === "string" ? { detail } : {}),
+        };
+    }
+    if (kind !== "accepted" && kind !== "duplicate")
+        throw new Error(`invalid-receipt: ${kind}`);
+    const intents = Reflect.get(Object(value), "intents");
+    if (!Array.isArray(intents))
+        throw new Error("invalid-receipt: intents");
+    const disposition = Reflect.get(Object(value), "disposition");
+    return {
+        kind,
+        sequence: integer(value, "sequence"),
+        intents: intents.map((intent) => ({
+            kind: intentKind(text(intent, "kind")),
+            runId: text(intent, "runId"),
+            operationId: text(intent, "operationId"),
+        })),
+        ...(typeof disposition === "string" ? { disposition } : {}),
+    };
+}
+export function json(value) {
+    const copy = JSON.parse(JSON.stringify(value));
+    if (!isJsonObject(copy))
+        throw new Error("invalid-json-object");
+    return copy;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function textList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const items = value;
+    return items.every((item) => typeof item === "string") ? items : undefined;
+}
+export function serializable(value) {
+    try {
+        return json(value);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { Database, SolidObjectsRuntime } from "solid-objects";
+import type { deliveryHandler } from "./authority-delivery.ts";
+export interface DeliveryRegistration {
+    readonly runtime: Pick<SolidObjectsRuntime, "registerEffect" | "close">;
+    readonly database: Pick<Database, "close">;
+    readonly handle: ReturnType<typeof deliveryHandler>;
+    readonly shutdownMilliseconds: number;
+}
+export interface TrackedDelivery {
+    readonly stop: () => Promise<void>;
+    readonly handlersSettled: () => Promise<boolean>;
+}
+export declare function trackedDelivery(registration: DeliveryRegistration): TrackedDelivery;

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

@@ -0,0 +1,69 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { deliverEffect } from "./authority-actor.js";
+export function trackedDelivery(registration) {
+    const { runtime, database, handle, shutdownMilliseconds } = registration;
+    const handlers = new Set();
+    runtime.registerEffect(deliverEffect, (argumentsValue, context) => tracked(handlers, handle(argumentsValue, context)));
+    let released;
+    return {
+        handlersSettled: async () => {
+            await settledWithin([...handlers], shutdownMilliseconds);
+            return handlers.size === 0;
+        },
+        stop: () => {
+            const libraryWaited = released === undefined && handlers.size > 0;
+            released ??= Promise.allSettled([...handlers]).then(() => closedInOrder([() => runtime.close(), () => database.close()]));
+            return releasedWithin({
+                released,
+                handlers,
+                milliseconds: libraryWaited ? 0 : shutdownMilliseconds,
+            });
+        },
+    };
+}
+async function closedInOrder(closers) {
+    const attempts = [];
+    for (const close of closers) {
+        const attempt = close();
+        attempts.push(attempt);
+        await attempt.catch(() => undefined);
+    }
+    await Promise.all(attempts);
+}
+async function settledWithin(handlers, milliseconds) {
+    if (handlers.length === 0)
+        return;
+    const limit = new AbortController();
+    try {
+        await Promise.race([
+            Promise.allSettled(handlers),
+            delay(milliseconds, undefined, { signal: limit.signal }).catch(() => undefined),
+        ]);
+    }
+    finally {
+        limit.abort();
+    }
+}
+function tracked(handlers, handling) {
+    handlers.add(handling);
+    const remove = () => {
+        handlers.delete(handling);
+    };
+    void handling.then(remove, remove);
+    return handling;
+}
+async function releasedWithin(waiting) {
+    const { released, handlers, milliseconds } = waiting;
+    let timer;
+    const timedOut = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error(`authority-close-timeout: in-flight delivery handlers: ${String(handlers.size)}`));
+        }, milliseconds);
+    });
+    try {
+        await Promise.race([released, timedOut]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

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

@@ -0,0 +1,60 @@
+import { type Database, type InstrumentationEvent, type JsonObject, 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";
+export interface AuthorityOptions {
+    readonly delivery?: Delivery;
+    readonly timing?: AuthorityTiming;
+    readonly effects?: Partial<EffectSettings>;
+    readonly clock?: () => string;
+    readonly instrumentation?: (event: InstrumentationEvent) => void;
+    readonly log?: (line: string) => void;
+    readonly available?: AvailableManifest;
+}
+export interface Refusal {
+    readonly kind: "refused";
+    readonly reason: string;
+    readonly detail: string;
+}
+export { authorityTiming } from "./authority-settings.ts";
+export type { AuthorityTiming } from "./authority-settings.ts";
+export declare function refused(reason: string, error: unknown): Refusal;
+export interface Owned {
+    readonly kind: "owned";
+    readonly database: Database;
+    readonly schema: Exclude<SchemaState, Refusal>;
+}
+export declare function ownedDatabase(directory: string): Promise<Owned | Refusal>;
+export interface OwnedRuntime extends Owned {
+    readonly parts: AuthorityRuntime;
+}
+export declare function ownedRuntime(directory: string, options: AuthorityOptions): Promise<OwnedRuntime | Refusal>;
+export interface AuthorityInvoker {
+    readonly beginEpoch: () => Promise<unknown>;
+    readonly execute: (request: JsonObject) => Promise<unknown>;
+    readonly adopt: () => Promise<unknown>;
+    readonly recover: () => Promise<unknown>;
+}
+export declare function recoverDeliveries(invoker: AuthorityInvoker): Promise<number>;
+export interface SessionLimits {
+    readonly stopLimit: number;
+    readonly recoveryLimit: number;
+}
+export interface AuthorityRuntime {
+    readonly runtime: SolidObjectsRuntime;
+    readonly reader: Database;
+    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 watchMilliseconds: number;
+    readonly limits: SessionLimits;
+    readonly releaseEarlierOwners: () => Promise<void>;
+    readonly retryDeliveryCallbacks: () => Promise<void>;
+    readonly storedActorRefusal: (actorId: string) => Promise<Refusal | undefined>;
+    readonly condition: () => Promise<string | undefined>;
+    readonly subscribe: (actorId: string, listener: SequenceListener) => () => void;
+}
+export declare function authorityRuntime(database: Database, options: AuthorityOptions): AuthorityRuntime;

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

@@ -0,0 +1,204 @@
+import { realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { guardApplicationDatabase, } from "solid-objects";
+import { sqlite } from "solid-objects/database/sqlite";
+import { recoveryBatch } from "./turn-state.js";
+import { integer, latestSequence, text } from "../../storage/domain-rows.js";
+import { trackedDelivery } from "./authority-release.js";
+import { authorityActor } from "./authority-actor.js";
+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 { failureCounter, registeredRuntime, runtimeSettings, wallClock, } from "./runtime-parts.js";
+import { strandingWatchdog, } from "./authority-watchdog.js";
+export { authorityTiming } from "./authority-settings.js";
+export function refused(reason, error) {
+    return {
+        kind: "refused",
+        reason,
+        detail: String(Reflect.get(Object(error), "message")),
+    };
+}
+export async function ownedDatabase(directory) {
+    let database;
+    try {
+        database = sqlite({
+            path: join(await realpath(directory), "authority.sqlite"),
+            timeoutMilliseconds: contentionMilliseconds,
+            lockRetryAttempts: 1,
+        });
+    }
+    catch (error) {
+        return refused("storage-failure", error);
+    }
+    const owned = await ownership(database);
+    if (owned.kind === "owned")
+        return owned;
+    await database.close();
+    return owned;
+}
+async function ownership(database) {
+    let schema;
+    try {
+        await lockExclusively(database);
+        schema = await database.connection(inspectSchema);
+        if (schema.kind === "refused")
+            return schema;
+        await takeOwnership(database);
+    }
+    catch (error) {
+        return refused(lockContention(error) ? "authority-held" : "storage-failure", error);
+    }
+    const violation = requiredSettingsViolation(await observeSettings(database));
+    return violation === null
+        ? { kind: "owned", database, schema }
+        : { kind: "refused", reason: "storage-failure", detail: violation };
+}
+export async function ownedRuntime(directory, options) {
+    const owned = await ownedDatabase(directory);
+    if (owned.kind === "refused")
+        return owned;
+    try {
+        return { ...owned, parts: authorityRuntime(owned.database, options) };
+    }
+    catch (error) {
+        await owned.database.close();
+        return refused("invalid-configuration", error);
+    }
+}
+export async function recoverDeliveries(invoker) {
+    let staged = 0;
+    for (;;) {
+        const batch = integer(await invoker.recover(), "staged");
+        staged += batch;
+        if (batch < recoveryBatch)
+            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 };
+    const letters = await retry.runtime.deadLetters.all(administration);
+    for (const letter of letters.filter((item) => item.actorType === "ClovingAuthority" &&
+        deliveryCallbacks.includes(item.operation) &&
+        item.retriedMessageId === null))
+        await retry.runtime.deadLetters.retry(letter.id, administration);
+}
+async function releaseEarlierOwners(release) {
+    const { runtime, broker, timing } = release;
+    const administration = { authorizationContext: broker };
+    const bound = timing.aliveThresholdMilliseconds + 2 * timing.heartbeatMilliseconds;
+    for (let waited = 0;; waited += timing.heartbeatMilliseconds) {
+        await runtime.processes.cleanup(administration);
+        const earlier = (await runtime.processes.all(administration)).filter((record) => record.shutdownState !== "stopped");
+        if (earlier.length === 0)
+            return;
+        if (waited > bound)
+            throw new Error(`earlier-owner-not-released: ${earlier.map((record) => record.id).join(",")}`);
+        await delay(timing.heartbeatMilliseconds);
+    }
+}
+const actorSequenceMismatch = {
+    kind: "refused",
+    reason: "projection-mismatch",
+    detail: "actor-sequence",
+};
+async function storedActorRefusal(check) {
+    const { database, actor, actorId } = check;
+    const supported = actor.stateVersion ?? 1;
+    const { row, latest } = await database.connection(async (connection) => ({
+        row: await connection.get("SELECT state_version, state FROM solid_instances WHERE actor_type = ? AND actor_id = ?", [actor.actorType, actorId]),
+        latest: await latestSequence(connection),
+    }));
+    const version = row === undefined ? supported : integer(row, "state_version");
+    if (version > supported)
+        return {
+            kind: "refused",
+            reason: "incompatible-state-version",
+            detail: `stored state version ${String(version)} is newer than code version ${String(supported)}`,
+        };
+    const sequence = row === undefined ? 0 : integer(JSON.parse(text(row, "state")), "sequence");
+    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 })}`;
+}
+async function deadLetterCause(lookup) {
+    const { runtime, broker, messageId } = lookup;
+    try {
+        const letters = await runtime.deadLetters.all({
+            authorizationContext: broker,
+        });
+        const letter = letters.find((item) => item.messageId === messageId);
+        return String(Reflect.get(Object(letter?.error), "message"));
+    }
+    catch {
+        return "unreadable cause";
+    }
+}
+export function authorityRuntime(database, options) {
+    const timing = options.timing ?? authorityTiming;
+    const reader = guardApplicationDatabase(database);
+    const broker = {};
+    let epoch = 0;
+    const watchdog = strandingWatchdog({
+        boundMilliseconds: timing.callTimeoutMilliseconds,
+    });
+    const effects = effectConfiguration(options);
+    const shared = { reader, effects, clock: options.clock ?? wallClock };
+    const ClovingAuthority = authorityActor({
+        ...shared,
+        failed: failureCounter(),
+    });
+    const runtime = registeredRuntime({
+        database,
+        actor: ClovingAuthority,
+        settings: runtimeSettings({ timing, options, broker, watchdog }),
+    });
+    const delivery = trackedDelivery({
+        runtime,
+        database,
+        shutdownMilliseconds: timing.shutdownMilliseconds,
+        handle: deliveryHandler({
+            ...shared,
+            delivery: options.delivery,
+            epoch: () => epoch,
+            available: options.available,
+        }),
+    });
+    return {
+        runtime,
+        reader,
+        invoker: (actorId, idempotencyKey) => runtime.ref(ClovingAuthority, actorId).with({
+            authorizationContext: broker,
+            timeoutMilliseconds: timing.callTimeoutMilliseconds,
+            ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+        }),
+        ...delivery,
+        setEpoch: (value) => {
+            epoch = value;
+        },
+        unhealthy: () => unhealthy(watchdog),
+        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 }),
+        subscribe: sequenceSubscriber({ realtime: runtime.realtime, broker }),
+    };
+}