@torkbot/sledge 0.1.0

package/dist/ledger/database-ledger-engine.js

@@ -0,0 +1,798 @@
+import { randomUUID } from "node:crypto";
+import { Value } from "@sinclair/typebox/value";
+export function createDatabaseLedger(input) {
+    return openDatabaseLedgerEngine({
+        boundModel: input.boundModel,
+        timing: input.timing,
+        database: input.database,
+        leaseMs: input.leaseMs,
+        defaultRetryDelayMs: input.defaultRetryDelayMs,
+        maxInFlight: input.maxInFlight,
+        maxBusyRetries: input.maxBusyRetries,
+        maxBusyRetryDelayMs: input.maxBusyRetryDelayMs,
+    });
+}
+class RuntimeBuilder {
+    projectorsByEvent = new Map();
+    materializersByEvent = new Map();
+    handlersByQueue = new Map();
+    project(eventName, projector) {
+        const key = String(eventName);
+        const existing = this.projectorsByEvent.get(key) ?? [];
+        existing.push(projector);
+        this.projectorsByEvent.set(key, existing);
+        return this;
+    }
+    materialize(eventName, materializer) {
+        const key = String(eventName);
+        const existing = this.materializersByEvent.get(key) ?? [];
+        existing.push(materializer);
+        this.materializersByEvent.set(key, existing);
+        return this;
+    }
+    handle(queueName, handler) {
+        const key = String(queueName);
+        if (this.handlersByQueue.has(key)) {
+            throw new Error(`duplicate queue handler registration: ${key}`);
+        }
+        this.handlersByQueue.set(key, handler);
+        return this;
+    }
+}
+function parseJson(value, context) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`invalid JSON at ${context}`, {
+            cause: error,
+        });
+    }
+}
+function isSqliteBusyError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const maybeCode = error.code;
+    if (maybeCode === "SQLITE_BUSY") {
+        return true;
+    }
+    return error.message.includes("SQLITE_BUSY");
+}
+function computeBusyRetryDelayMs(attempt, maxDelayMs) {
+    return Math.min(maxDelayMs, 2 ** attempt);
+}
+async function sleepMs(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function readNumberField(row, field) {
+    const value = row[field];
+    if (typeof value !== "number") {
+        throw new Error(`expected numeric field ${field}`);
+    }
+    return value;
+}
+function readNullableNumberField(row, field) {
+    const value = row[field];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== "number") {
+        throw new Error(`expected nullable numeric field ${field}`);
+    }
+    return value;
+}
+function readStringField(row, field) {
+    const value = row[field];
+    if (typeof value !== "string") {
+        throw new Error(`expected string field ${field}`);
+    }
+    return value;
+}
+function readNullableStringField(row, field) {
+    const value = row[field];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`expected nullable string field ${field}`);
+    }
+    return value;
+}
+function openDatabaseLedgerEngine(input) {
+    const builder = new RuntimeBuilder();
+    const clock = input.timing.clock;
+    const scheduler = input.timing.scheduler;
+    const database = input.database;
+    const model = input.boundModel.model;
+    const implementations = input.boundModel.implementations;
+    const register = input.boundModel.register;
+    register(builder);
+    const leaseMs = input.leaseMs ?? 1_000;
+    const defaultRetryDelayMs = input.defaultRetryDelayMs ?? 1_000;
+    const maxInFlight = input.maxInFlight ?? 16;
+    const maxBusyRetries = input.maxBusyRetries ?? 8;
+    const maxBusyRetryDelayMs = input.maxBusyRetryDelayMs ?? 50;
+    if (!Number.isInteger(maxInFlight) || maxInFlight <= 0) {
+        throw new Error(`maxInFlight must be a positive integer, received ${maxInFlight}`);
+    }
+    if (!Number.isInteger(maxBusyRetries) || maxBusyRetries < 0) {
+        throw new Error(`maxBusyRetries must be a non-negative integer, received ${maxBusyRetries}`);
+    }
+    if (!Number.isInteger(maxBusyRetryDelayMs) || maxBusyRetryDelayMs <= 0) {
+        throw new Error(`maxBusyRetryDelayMs must be a positive integer, received ${maxBusyRetryDelayMs}`);
+    }
+    let closed = false;
+    let dispatchLoopActive = false;
+    let dispatchLoopQueued = false;
+    let scheduledDispatch = null;
+    const inFlight = new Set();
+    const leaseAbortControllers = new Map();
+    const leaseExpiryTasks = new Map();
+    const leaseHeartbeatTasks = new Map();
+    let mutationTail = Promise.resolve();
+    const startup = (async () => {
+        await withBusyRetry(async () => {
+            await database.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        event_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        ts_ms INTEGER NOT NULL,
+        event_name TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        causation_event_id INTEGER,
+        dedupe_key TEXT UNIQUE
+      );
+
+      CREATE TABLE IF NOT EXISTS work (
+        work_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        queue_name TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        source_event_id INTEGER NOT NULL,
+        attempt INTEGER NOT NULL DEFAULT 0,
+        available_at_ms INTEGER NOT NULL,
+        dead INTEGER NOT NULL DEFAULT 0,
+        lease_id TEXT,
+        lease_acquired_at_ms INTEGER,
+        lease_expires_at_ms INTEGER,
+        last_error TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_work_due
+        ON work(dead, lease_id, available_at_ms, work_id);
+    `);
+        });
+        await releaseExpiredLeases();
+        await scheduleNextDispatchFromStore();
+    })();
+    function runSerialized(run) {
+        const operation = mutationTail.then(run, run);
+        mutationTail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async function withBusyRetry(run) {
+        let attempt = 0;
+        while (true) {
+            try {
+                return await run();
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= maxBusyRetries) {
+                    throw error;
+                }
+                attempt += 1;
+                await sleepMs(computeBusyRetryDelayMs(attempt, maxBusyRetryDelayMs));
+            }
+        }
+    }
+    async function runInTransaction(run) {
+        return await runSerialized(async () => {
+            return await withBusyRetry(async () => {
+                let began = false;
+                try {
+                    await database.exec("BEGIN IMMEDIATE");
+                    began = true;
+                    const result = await run();
+                    await database.exec("COMMIT");
+                    return result;
+                }
+                catch (error) {
+                    if (began) {
+                        try {
+                            await database.exec("ROLLBACK");
+                        }
+                        catch {
+                            // Suppress rollback failures to preserve the root cause.
+                        }
+                    }
+                    throw error;
+                }
+            });
+        });
+    }
+    function decodeEventPayload(eventName, payload) {
+        const schema = model.events[eventName];
+        if (schema === undefined) {
+            throw new Error(`unknown event name: ${String(eventName)}`);
+        }
+        return Value.Decode(schema, payload);
+    }
+    async function appendEventInTransaction(eventInput) {
+        const eventName = eventInput.eventName;
+        const eventSchema = model.events[eventName];
+        if (eventSchema === undefined) {
+            throw new Error(`unknown event name: ${eventInput.eventName}`);
+        }
+        const decodedPayload = decodeEventPayload(eventName, eventInput.payload);
+        const encodedPayload = Value.Encode(eventSchema, decodedPayload);
+        const payloadJson = JSON.stringify(encodedPayload);
+        let created = false;
+        let eventId = 0;
+        if (eventInput.dedupeKey === undefined) {
+            const eventInsert = await database
+                .prepare(`INSERT INTO events (ts_ms, event_name, payload_json, causation_event_id, dedupe_key)
+           VALUES (?, ?, ?, ?, NULL)`)
+                .run(eventInput.nowMs, eventInput.eventName, payloadJson, eventInput.causationEventId);
+            created = true;
+            eventId = Number(eventInsert.lastInsertRowid);
+        }
+        else {
+            const eventInsert = await database
+                .prepare(`INSERT INTO events (ts_ms, event_name, payload_json, causation_event_id, dedupe_key)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(dedupe_key) DO NOTHING`)
+                .run(eventInput.nowMs, eventInput.eventName, payloadJson, eventInput.causationEventId, eventInput.dedupeKey);
+            if (eventInsert.changes > 0) {
+                created = true;
+                eventId = Number(eventInsert.lastInsertRowid);
+            }
+            else {
+                const existing = await database
+                    .prepare(`SELECT event_id FROM events WHERE dedupe_key = ?`)
+                    .get(eventInput.dedupeKey);
+                if (existing === undefined) {
+                    throw new Error(`dedupe conflict resolved without durable winner for key ${eventInput.dedupeKey}`);
+                }
+                eventId = readNumberField(existing, "event_id");
+            }
+        }
+        if (!created) {
+            return {
+                eventId,
+                created: false,
+            };
+        }
+        const envelope = {
+            eventId,
+            tsMs: eventInput.nowMs,
+            eventName,
+            payload: decodedPayload,
+            causationEventId: eventInput.causationEventId,
+            dedupeKey: eventInput.dedupeKey ?? null,
+        };
+        const projectors = builder.projectorsByEvent.get(eventInput.eventName) ?? [];
+        for (const projector of projectors) {
+            await projector({
+                event: envelope,
+                actions: {
+                    index: async (indexName, indexInput) => {
+                        const schema = model.indexers[indexName];
+                        const implementation = implementations.indexers[indexName];
+                        if (schema === undefined || implementation === undefined) {
+                            throw new Error(`unknown indexer: ${String(indexName)}`);
+                        }
+                        const decodedInput = Value.Decode(schema, indexInput);
+                        const encodedInput = Value.Encode(schema, decodedInput);
+                        const canonicalInput = Value.Decode(schema, encodedInput);
+                        await implementation(canonicalInput);
+                    },
+                },
+            });
+        }
+        const materializers = builder.materializersByEvent.get(eventInput.eventName) ?? [];
+        for (const materializer of materializers) {
+            const queued = [];
+            await materializer({
+                event: envelope,
+                actions: {
+                    enqueue: (queueName, payload, options) => {
+                        const queueSchema = model.queues[queueName];
+                        if (queueSchema === undefined) {
+                            throw new Error(`unknown queue: ${String(queueName)}`);
+                        }
+                        const decodedQueuePayload = Value.Decode(queueSchema, payload);
+                        const encodedQueuePayload = Value.Encode(queueSchema, decodedQueuePayload);
+                        queued.push({
+                            queueName: String(queueName),
+                            payload: encodedQueuePayload,
+                            availableAtMs: options?.availableAtMs ?? eventInput.nowMs,
+                        });
+                    },
+                },
+            });
+            for (const work of queued) {
+                await database
+                    .prepare(`INSERT INTO work (
+              queue_name,
+              payload_json,
+              source_event_id,
+              attempt,
+              available_at_ms,
+              dead,
+              lease_id,
+              lease_acquired_at_ms,
+              lease_expires_at_ms,
+              last_error
+            ) VALUES (?, ?, ?, 0, ?, 0, NULL, NULL, NULL, NULL)`)
+                    .run(work.queueName, JSON.stringify(work.payload), eventId, work.availableAtMs);
+            }
+        }
+        return {
+            eventId,
+            created,
+        };
+    }
+    async function releaseExpiredLeases() {
+        await runInTransaction(async () => {
+            await database
+                .prepare(`UPDATE work
+           SET
+             lease_id = NULL,
+             lease_acquired_at_ms = NULL,
+             lease_expires_at_ms = NULL,
+             available_at_ms = ?
+           WHERE dead = 0
+             AND lease_id IS NOT NULL
+             AND lease_expires_at_ms IS NOT NULL
+             AND lease_expires_at_ms < ?`)
+                .run(clock.nowMs(), clock.nowMs());
+        });
+    }
+    function scheduleDispatchAt(targetAtMs) {
+        if (closed) {
+            return;
+        }
+        if (scheduledDispatch !== null && scheduledDispatch.dueAtMs <= targetAtMs) {
+            return;
+        }
+        scheduledDispatch?.cancel();
+        const delayMs = Math.max(0, targetAtMs - clock.nowMs());
+        const task = scheduler.scheduleOnce(delayMs, () => {
+            scheduledDispatch = null;
+            requestDispatchRun();
+        });
+        scheduledDispatch = {
+            dueAtMs: clock.nowMs() + delayMs,
+            cancel: () => task.cancel(),
+        };
+    }
+    async function scheduleNextDispatchFromStore() {
+        const row = await database
+            .prepare(`SELECT available_at_ms
+         FROM work
+         WHERE dead = 0
+           AND lease_id IS NULL
+         ORDER BY available_at_ms ASC
+         LIMIT 1`)
+            .get();
+        if (row === undefined) {
+            return;
+        }
+        scheduleDispatchAt(readNumberField(row, "available_at_ms"));
+    }
+    async function claimNextDueWork() {
+        return await runInTransaction(async () => {
+            const nowMs = clock.nowMs();
+            const candidate = await database
+                .prepare(`SELECT work_id
+           FROM work
+           WHERE dead = 0
+             AND lease_id IS NULL
+             AND available_at_ms <= ?
+           ORDER BY work_id ASC
+           LIMIT 1`)
+                .get(nowMs);
+            if (candidate === undefined) {
+                return null;
+            }
+            const candidateWorkId = readNumberField(candidate, "work_id");
+            const leaseId = randomUUID();
+            const leaseExpiresAtMs = nowMs + leaseMs;
+            const updateResult = await database
+                .prepare(`UPDATE work
+           SET
+             attempt = attempt + 1,
+             lease_id = ?,
+             lease_acquired_at_ms = ?,
+             lease_expires_at_ms = ?
+           WHERE work_id = ?
+             AND dead = 0
+             AND lease_id IS NULL`)
+                .run(leaseId, nowMs, leaseExpiresAtMs, candidateWorkId);
+            if (updateResult.changes <= 0) {
+                return null;
+            }
+            const claimed = await database
+                .prepare(`SELECT
+            work_id,
+            queue_name,
+            payload_json,
+            source_event_id,
+            attempt,
+            lease_id,
+            lease_acquired_at_ms,
+            lease_expires_at_ms
+           FROM work
+           WHERE work_id = ?`)
+                .get(candidateWorkId);
+            if (claimed === undefined) {
+                return null;
+            }
+            if (readNullableStringField(claimed, "lease_id") !== leaseId) {
+                return null;
+            }
+            const leaseAcquiredAtMs = readNullableNumberField(claimed, "lease_acquired_at_ms");
+            const leaseExpiresAtMsValue = readNullableNumberField(claimed, "lease_expires_at_ms");
+            if (leaseAcquiredAtMs === null || leaseExpiresAtMsValue === null) {
+                return null;
+            }
+            return {
+                workId: readNumberField(claimed, "work_id"),
+                queueName: readStringField(claimed, "queue_name"),
+                payloadJson: readStringField(claimed, "payload_json"),
+                sourceEventId: readNumberField(claimed, "source_event_id"),
+                attempt: readNumberField(claimed, "attempt"),
+                leaseId,
+                leaseAcquiredAtMs,
+                leaseExpiresAtMs: leaseExpiresAtMsValue,
+            };
+        });
+    }
+    function requestDispatchRun() {
+        if (closed) {
+            return;
+        }
+        if (dispatchLoopActive) {
+            dispatchLoopQueued = true;
+            return;
+        }
+        dispatchLoopActive = true;
+        void runDispatchLoop().finally(() => {
+            dispatchLoopActive = false;
+            if (dispatchLoopQueued && !closed) {
+                dispatchLoopQueued = false;
+                requestDispatchRun();
+            }
+        });
+    }
+    async function runDispatchLoop() {
+        await startup;
+        if (closed) {
+            return;
+        }
+        while (!closed && inFlight.size < maxInFlight) {
+            const claimed = await claimNextDueWork();
+            if (claimed === null) {
+                await scheduleNextDispatchFromStore();
+                return;
+            }
+            const handler = builder.handlersByQueue.get(claimed.queueName);
+            if (handler === undefined) {
+                await runInTransaction(async () => {
+                    await database
+                        .prepare(`UPDATE work
+               SET
+                 dead = 1,
+                 lease_id = NULL,
+                 lease_acquired_at_ms = NULL,
+                 lease_expires_at_ms = NULL,
+                 last_error = ?
+               WHERE work_id = ?
+                 AND lease_id = ?`)
+                        .run(`no handler for queue ${claimed.queueName}`, claimed.workId, claimed.leaseId);
+                });
+                continue;
+            }
+            const run = processClaimedWork(claimed, handler).finally(() => {
+                inFlight.delete(run);
+                requestDispatchRun();
+            });
+            inFlight.add(run);
+        }
+    }
+    async function processClaimedWork(claimed, handler) {
+        const leaseAbortController = new AbortController();
+        leaseAbortControllers.set(claimed.leaseId, leaseAbortController);
+        let currentLeaseExpiresAtMs = claimed.leaseExpiresAtMs;
+        let activeLeaseHolds = 0;
+        const clearLeaseHeartbeat = () => {
+            leaseHeartbeatTasks.get(claimed.leaseId)?.cancel();
+            leaseHeartbeatTasks.delete(claimed.leaseId);
+        };
+        const releaseLeaseInStore = async () => {
+            await runInTransaction(async () => {
+                await database
+                    .prepare(`UPDATE work
+             SET
+               lease_id = NULL,
+               lease_acquired_at_ms = NULL,
+               lease_expires_at_ms = NULL,
+               available_at_ms = ?
+             WHERE work_id = ?
+               AND lease_id = ?
+               AND dead = 0`)
+                    .run(clock.nowMs(), claimed.workId, claimed.leaseId);
+            });
+        };
+        const abortLease = (reason) => {
+            if (!leaseAbortController.signal.aborted) {
+                leaseAbortController.abort(new Error(reason));
+            }
+        };
+        const scheduleLeaseExpiry = () => {
+            leaseExpiryTasks.get(claimed.leaseId)?.cancel();
+            const delayMs = Math.max(0, currentLeaseExpiresAtMs - clock.nowMs());
+            const expiryTask = scheduler.scheduleOnce(delayMs, () => {
+                abortLease("lease expired");
+                clearLeaseHeartbeat();
+                void releaseLeaseInStore().then(() => {
+                    scheduleDispatchAt(clock.nowMs());
+                }, () => undefined);
+            });
+            leaseExpiryTasks.set(claimed.leaseId, {
+                cancel: () => expiryTask.cancel(),
+            });
+        };
+        const renewLease = async () => {
+            const nowMs = clock.nowMs();
+            const renewedLeaseExpiresAtMs = nowMs + leaseMs;
+            const renewal = await runInTransaction(async () => {
+                return await database
+                    .prepare(`UPDATE work
+             SET
+               lease_expires_at_ms = ?
+             WHERE work_id = ?
+               AND lease_id = ?
+               AND dead = 0`)
+                    .run(renewedLeaseExpiresAtMs, claimed.workId, claimed.leaseId);
+            });
+            if (renewal.changes <= 0) {
+                throw new Error("lease renewal lost ownership");
+            }
+            currentLeaseExpiresAtMs = renewedLeaseExpiresAtMs;
+            scheduleLeaseExpiry();
+        };
+        scheduleLeaseExpiry();
+        const startLeaseHeartbeat = () => {
+            if (leaseHeartbeatTasks.has(claimed.leaseId)) {
+                return;
+            }
+            const heartbeatEveryMs = Math.max(1, Math.floor(leaseMs / 3));
+            const heartbeatTask = scheduler.scheduleRepeating(heartbeatEveryMs, () => {
+                if (leaseAbortController.signal.aborted) {
+                    clearLeaseHeartbeat();
+                    return;
+                }
+                void renewLease().catch(() => {
+                    clearLeaseHeartbeat();
+                    abortLease("lease renewal failed");
+                });
+            });
+            leaseHeartbeatTasks.set(claimed.leaseId, {
+                cancel: () => heartbeatTask.cancel(),
+            });
+        };
+        const stopLeaseHeartbeat = () => {
+            clearLeaseHeartbeat();
+        };
+        const queueSchema = model.queues[claimed.queueName];
+        if (queueSchema === undefined) {
+            throw new Error(`unknown queue schema for ${claimed.queueName}`);
+        }
+        const decodedPayload = Value.Decode(queueSchema, parseJson(claimed.payloadJson, "work.payload_json"));
+        const work = {
+            workId: claimed.workId,
+            queueName: claimed.queueName,
+            payload: decodedPayload,
+            attempt: claimed.attempt,
+            sourceEventId: claimed.sourceEventId,
+        };
+        const lease = {
+            workId: claimed.workId,
+            queueName: claimed.queueName,
+            sourceEventId: claimed.sourceEventId,
+            attempt: claimed.attempt,
+            leaseId: claimed.leaseId,
+            leaseAcquiredAtMs: claimed.leaseAcquiredAtMs,
+            leaseExpiresAtMs: claimed.leaseExpiresAtMs,
+            signal: leaseAbortController.signal,
+            hold: () => {
+                if (leaseAbortController.signal.aborted) {
+                    throw new Error("cannot hold aborted lease");
+                }
+                activeLeaseHolds += 1;
+                if (activeLeaseHolds === 1) {
+                    startLeaseHeartbeat();
+                }
+                let disposed = false;
+                return {
+                    signal: leaseAbortController.signal,
+                    [Symbol.asyncDispose]: async () => {
+                        if (disposed) {
+                            return;
+                        }
+                        disposed = true;
+                        activeLeaseHolds = Math.max(0, activeLeaseHolds - 1);
+                        if (activeLeaseHolds === 0) {
+                            stopLeaseHeartbeat();
+                        }
+                    },
+                };
+            },
+        };
+        const stagedEvents = [];
+        const actions = {
+            emit: (eventName, event, options) => {
+                stagedEvents.push({
+                    eventName: String(eventName),
+                    payload: event,
+                    nowMs: clock.nowMs(),
+                    dedupeKey: options?.dedupeKey,
+                    causationEventId: claimed.sourceEventId,
+                });
+            },
+            query: async (queryName, params) => {
+                const schema = model.queries[queryName];
+                const implementation = implementations.queries[queryName];
+                if (schema === undefined || implementation === undefined) {
+                    throw new Error(`unknown query: ${String(queryName)}`);
+                }
+                const decodedParams = Value.Decode(schema.params, params);
+                const encodedParams = Value.Encode(schema.params, decodedParams);
+                const canonicalParams = Value.Decode(schema.params, encodedParams);
+                const rawResult = await implementation(canonicalParams);
+                const decodedResult = Value.Decode(schema.result, rawResult);
+                return decodedResult;
+            },
+        };
+        let outcome;
+        try {
+            outcome = await handler({
+                work,
+                lease,
+                actions,
+            });
+        }
+        catch (error) {
+            outcome = {
+                outcome: "retry",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        await runInTransaction(async () => {
+            const active = await database
+                .prepare(`SELECT work_id
+           FROM work
+           WHERE work_id = ?
+             AND lease_id = ?
+             AND dead = 0`)
+                .get(claimed.workId, claimed.leaseId);
+            if (active === undefined) {
+                return;
+            }
+            for (const stagedEvent of stagedEvents) {
+                await appendEventInTransaction(stagedEvent);
+            }
+            switch (outcome.outcome) {
+                case "ack":
+                    await database
+                        .prepare(`DELETE FROM work
+               WHERE work_id = ?
+                 AND lease_id = ?
+                 AND dead = 0`)
+                        .run(claimed.workId, claimed.leaseId);
+                    break;
+                case "retry":
+                    await database
+                        .prepare(`UPDATE work
+               SET
+                 available_at_ms = ?,
+                 lease_id = NULL,
+                 lease_acquired_at_ms = NULL,
+                 lease_expires_at_ms = NULL,
+                 last_error = ?
+               WHERE work_id = ?
+                 AND lease_id = ?
+                 AND dead = 0`)
+                        .run(outcome.retryAtMs ?? clock.nowMs() + defaultRetryDelayMs, outcome.error, claimed.workId, claimed.leaseId);
+                    break;
+                case "dead_letter":
+                    await database
+                        .prepare(`UPDATE work
+               SET
+                 dead = 1,
+                 lease_id = NULL,
+                 lease_acquired_at_ms = NULL,
+                 lease_expires_at_ms = NULL,
+                 last_error = ?
+               WHERE work_id = ?
+                 AND lease_id = ?
+                 AND dead = 0`)
+                        .run(outcome.error, claimed.workId, claimed.leaseId);
+                    break;
+            }
+        });
+        stopLeaseHeartbeat();
+        leaseExpiryTasks.get(claimed.leaseId)?.cancel();
+        leaseExpiryTasks.delete(claimed.leaseId);
+        leaseAbortControllers.delete(claimed.leaseId);
+        scheduleDispatchAt(clock.nowMs());
+    }
+    async function close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        scheduledDispatch?.cancel();
+        scheduledDispatch = null;
+        for (const expiryTask of leaseExpiryTasks.values()) {
+            expiryTask.cancel();
+        }
+        leaseExpiryTasks.clear();
+        for (const heartbeatTask of leaseHeartbeatTasks.values()) {
+            heartbeatTask.cancel();
+        }
+        leaseHeartbeatTasks.clear();
+        for (const controller of leaseAbortControllers.values()) {
+            controller.abort(new Error("ledger closed"));
+        }
+        leaseAbortControllers.clear();
+        await Promise.allSettled(inFlight);
+        await runInTransaction(async () => {
+            await database
+                .prepare(`UPDATE work
+           SET
+             lease_id = NULL,
+             lease_acquired_at_ms = NULL,
+             lease_expires_at_ms = NULL,
+             available_at_ms = ?
+           WHERE dead = 0
+             AND lease_id IS NOT NULL`)
+                .run(clock.nowMs());
+        });
+    }
+    const ledger = {
+        emit: async (eventName, event, options) => {
+            await startup;
+            const result = await runInTransaction(async () => await appendEventInTransaction({
+                eventName: String(eventName),
+                payload: event,
+                nowMs: clock.nowMs(),
+                dedupeKey: options?.dedupeKey,
+                causationEventId: null,
+            }));
+            if (result.created) {
+                scheduleDispatchAt(clock.nowMs());
+            }
+        },
+        query: async (queryName, params) => {
+            await startup;
+            const schema = model.queries[queryName];
+            const implementation = implementations.queries[queryName];
+            if (schema === undefined || implementation === undefined) {
+                throw new Error(`unknown query: ${String(queryName)}`);
+            }
+            const decodedParams = Value.Decode(schema.params, params);
+            const encodedParams = Value.Encode(schema.params, decodedParams);
+            const canonicalParams = Value.Decode(schema.params, encodedParams);
+            const rawResult = await implementation(canonicalParams);
+            const decodedResult = Value.Decode(schema.result, rawResult);
+            return decodedResult;
+        },
+        close,
+        [Symbol.asyncDispose]: close,
+    };
+    return ledger;
+}
+//# sourceMappingURL=database-ledger-engine.js.map