@swirls/looms 0.0.2 → 0.2.0

package/dist/projectors/delivery.js

@@ -0,0 +1,182 @@
+import { Data, Effect, Semaphore } from 'effect';
+import { runProjectorEffect } from './projector.js';
+export class ProjectorCursorError extends Data.TaggedError('ProjectorCursorError') {
+}
+export class UnknownProjectorError extends Data.TaggedError('UnknownProjectorError') {
+}
+function projectorIdentity(projector) {
+    return `${projector.name}@${projector.version}`;
+}
+class ProjectorDeliveryError extends Data.TaggedError('ProjectorDeliveryError') {
+}
+function normalizeError(cause) {
+    return new ProjectorDeliveryError({
+        message: cause instanceof Error ? cause.message : String(cause),
+    });
+}
+export function createProjectorDelivery(source, projectors, cursors, options = {}) {
+    const batchSize = options.batchSize ?? 100;
+    const initialRetryMs = options.initialRetryMs ?? 1_000;
+    const maxRetryMs = options.maxRetryMs ?? 60_000;
+    const maxAttempts = options.maxAttempts ?? 8;
+    const now = options.now ?? Date.now;
+    const initialized = new Map();
+    const exclusive = new Map();
+    const observe = (event) => {
+        try {
+            Promise.resolve(options.observer?.observe(event)).catch(() => undefined);
+        }
+        catch {
+            // Delivery correctness must not depend on telemetry.
+        }
+    };
+    const initialize = (projector) => {
+        const key = projectorIdentity(projector);
+        let pending = initialized.get(key);
+        if (!pending) {
+            pending = Promise.resolve(projector.init?.()).catch((cause) => {
+                initialized.delete(key);
+                throw cause;
+            });
+            initialized.set(key, pending);
+        }
+        return pending;
+    };
+    const scheduleRetry = (at) => options.scheduleRetry?.(at) ?? Effect.void;
+    const recordFailure = (runId, projector, status, failedSeq, error) => Effect.gen(function* () {
+        const attempts = status.attempts + 1;
+        const deadLettered = attempts >= maxAttempts;
+        const nextRetryAt = deadLettered
+            ? null
+            : now() + Math.min(maxRetryMs, initialRetryMs * 2 ** Math.max(0, attempts - 1));
+        yield* cursors.fail(runId, projector, {
+            attempts,
+            failedSeq,
+            nextRetryAt,
+            error: error.message,
+            now: now(),
+        });
+        const sourceTail = yield* source.tail(runId).pipe(Effect.orElseSucceed(() => status.cursor));
+        observe({
+            type: deadLettered ? 'projector.dead-letter' : 'projector.retry',
+            runId,
+            projector: projectorIdentity(projector),
+            at: now(),
+            cursor: status.cursor,
+            lag: Math.max(0, sourceTail - status.cursor),
+            attempts,
+            error: error.message,
+        });
+        if (nextRetryAt !== null) {
+            yield* scheduleRetry(nextRetryAt);
+        }
+    });
+    const deliverProjector = (runId, projector, force) => Effect.gen(function* () {
+        let status = yield* cursors.get(runId, projector);
+        const currentTime = now();
+        if (status.state === 'dead-letter' ||
+            (!force && status.nextRetryAt !== null && status.nextRetryAt > currentTime)) {
+            return;
+        }
+        const initialization = yield* Effect.tryPromise({
+            try: () => initialize(projector),
+            catch: normalizeError,
+        }).pipe(Effect.exit);
+        if (initialization._tag === 'Failure') {
+            yield* recordFailure(runId, projector, status, status.cursor + 1, normalizeError(initialization.cause));
+            return;
+        }
+        while (true) {
+            const events = yield* source.read(runId, {
+                fromSeq: status.cursor + 1,
+                limit: batchSize,
+            });
+            const first = events[0];
+            const last = events.at(-1);
+            if (first === undefined || last === undefined) {
+                return;
+            }
+            const projected = yield* runProjectorEffect(projectorIdentity(projector), () => projector.project(events)).pipe(Effect.exit);
+            if (projected._tag === 'Failure') {
+                yield* recordFailure(runId, projector, status, first.seq, normalizeError(projected.cause));
+                return;
+            }
+            const advancedAt = now();
+            yield* cursors.advance(runId, projector, last.seq, advancedAt);
+            status = {
+                ...status,
+                cursor: last.seq,
+                state: 'idle',
+                attempts: 0,
+                failedSeq: null,
+                nextRetryAt: null,
+                lastError: null,
+            };
+            const sourceTail = yield* source.tail(runId).pipe(Effect.orElseSucceed(() => last.seq));
+            observe({
+                type: 'projector.lag',
+                runId,
+                projector: projectorIdentity(projector),
+                at: advancedAt,
+                cursor: last.seq,
+                lag: Math.max(0, sourceTail - last.seq),
+                attempts: 0,
+            });
+        }
+    });
+    /** One delivery at a time per run and projector; independent projectors still run in parallel. */
+    const deliverExclusive = (runId, projector, force) => {
+        const key = `${runId}:${projectorIdentity(projector)}`;
+        let semaphore = exclusive.get(key);
+        if (!semaphore) {
+            semaphore = Semaphore.makeUnsafe(1);
+            exclusive.set(key, semaphore);
+        }
+        return Semaphore.withPermits(semaphore, 1, deliverProjector(runId, projector, force));
+    };
+    const findProjector = (name, version) => projectors.find((candidate) => candidate.name === name && (version === undefined || candidate.version === version));
+    return {
+        deliver: (runId, runOptions) => Effect.forEach(projectors, (projector) => deliverExclusive(runId, projector, runOptions?.force ?? false), { concurrency: 'unbounded', discard: true }),
+        status: (runId) => cursors.list(runId),
+        requeue: (runId, projectorName, version) => {
+            const projector = findProjector(projectorName, version);
+            if (!projector) {
+                return Effect.fail(new UnknownProjectorError({
+                    message: `Unknown projector ${projectorName}${version === undefined ? '' : `@${version}`}`,
+                }));
+            }
+            return cursors
+                .requeue(runId, projector, now())
+                .pipe(Effect.andThen(deliverExclusive(runId, projector, true)));
+        },
+        nextRetryAt: (runId) => cursors.list(runId).pipe(Effect.map((statuses) => {
+            const deadlines = statuses
+                .map((status) => status.nextRetryAt)
+                .filter((deadline) => deadline !== null);
+            return deadlines.length === 0 ? null : Math.min(...deadlines);
+        })),
+        inspect: (runId) => cursors.list(runId).pipe(Effect.flatMap((statuses) => Effect.forEach(statuses, (status) => source.tail(status.runId).pipe(Effect.map((sourceTail) => ({
+            ...status,
+            sourceTail,
+            lag: Math.max(0, sourceTail - status.cursor),
+        }))), { concurrency: 'unbounded' }))),
+        recover: (runId) => Effect.gen(function* () {
+            const statuses = yield* cursors.list(runId);
+            let recovered = 0;
+            for (const status of statuses) {
+                if (status.state === 'dead-letter' || status.nextRetryAt === null) {
+                    continue;
+                }
+                yield* scheduleRetry(status.nextRetryAt);
+                if (status.nextRetryAt <= now()) {
+                    const projector = findProjector(status.projector, status.version);
+                    if (projector) {
+                        yield* deliverExclusive(status.runId, projector, true);
+                    }
+                }
+                recovered += 1;
+            }
+            return recovered;
+        }),
+    };
+}

package/dist/projectors/index-model.d.ts

@@ -53,4 +53,4 @@ export interface IndexProjector extends Projector {
     listReviews: (actorId?: string) => Promise<ReviewIndexRow[]>;
 }
 export declare function indexOpsFor(event: EventEnvelope): IndexOp[];
-export declare function createIndexProjector(name: string, backend: IndexBackend): IndexProjector;
+export declare function createIndexProjector(name: string, backend: IndexBackend, version?: string): IndexProjector;

package/dist/projectors/index-model.js

@@ -99,17 +99,15 @@ export function indexOpsFor(event) {
             return [];
     }
 }
-export function createIndexProjector(name, backend) {
+export function createIndexProjector(name, backend, version = '1') {
     return {
         name,
+        version,
         init: backend.init,
         dispose: backend.dispose,
-        project: async (events) => {
+        project: (events) => {
             const ops = events.flatMap(indexOpsFor);
-            if (ops.length === 0) {
-                return;
-            }
-            await backend.applyOps(ops);
+            return ops.length === 0 ? Promise.resolve() : backend.applyOps(ops);
         },
         getActor: (actorId) => backend.getActor(actorId),
         listReviews: (actorId) => backend.listReviews(actorId),

package/dist/projectors/index.d.ts

@@ -1,4 +1,6 @@
 export type { Projector, ProjectorErrorHandler } from './projector';
+export { createProjectorDelivery, ProjectorCursorError, UnknownProjectorError, type ProjectorCursorStore, type ProjectorDeliveryFailure, type ProjectorDelivery, type ProjectorDeliveryOptions, type ProjectorDeliveryState, type ProjectorDeliveryStatus, type ProjectorObservation, type ProjectorObserver, type ProjectorOperationalStatus, } from './delivery';
+export { sqliteProjectorCursorStore, SQLITE_PROJECTOR_DELIVERY_SCHEMA } from './sqlite-delivery';
 export { withProjectors, projectEvents, ProjectorsStoreLive, type WithProjectorsOptions, } from './with-projectors';
 export { indexOpsFor, createIndexProjector, type IndexOp, type IndexBackend, type IndexProjector, type ActorIndexRow, type ReviewIndexRow, } from './index-model';
 export { memory, noop } from './memory';

package/dist/projectors/index.js

@@ -1,3 +1,5 @@
+export { createProjectorDelivery, ProjectorCursorError, UnknownProjectorError, } from './delivery.js';
+export { sqliteProjectorCursorStore, SQLITE_PROJECTOR_DELIVERY_SCHEMA } from './sqlite-delivery.js';
 export { withProjectors, projectEvents, ProjectorsStoreLive, } from './with-projectors.js';
 export { indexOpsFor, createIndexProjector, } from './index-model.js';
 export { memory, noop } from './memory.js';

package/dist/projectors/memory.d.ts

@@ -1,5 +1,5 @@
 import { type IndexProjector } from './index-model';
-import type { Projector } from './projector';
+import { type Projector } from './projector';
 export declare function memory(): IndexProjector;
 /** No-op projector — safe default when indexing is disabled. */
 export declare function noop(): Projector;

package/dist/projectors/memory.js

@@ -1,4 +1,5 @@
 import { createIndexProjector, } from './index-model.js';
+import { runProjectorSync } from './projector.js';
 function applyOp(actors, reviews, op) {
     switch (op.type) {
         case 'upsertActor':
@@ -51,20 +52,20 @@ export function memory() {
     const actors = new Map();
     const reviews = new Map();
     const backend = {
-        applyOps: async (ops) => {
+        applyOps: (ops) => runProjectorSync('memory', () => {
             for (const op of ops) {
                 applyOp(actors, reviews, op);
             }
-        },
-        getActor: async (actorId) => actors.get(actorId) ?? null,
-        listReviews: async (actorId) => {
+        }),
+        getActor: (actorId) => runProjectorSync('memory', () => actors.get(actorId) ?? null),
+        listReviews: (actorId) => runProjectorSync('memory', () => {
             const rows = [...reviews.values()];
             return actorId ? rows.filter((row) => row.actorId === actorId) : rows;
-        },
-        dispose: async () => {
+        }),
+        dispose: () => runProjectorSync('memory', () => {
             actors.clear();
             reviews.clear();
-        },
+        }),
     };
     return createIndexProjector('memory', backend);
 }
@@ -72,6 +73,7 @@ export function memory() {
 export function noop() {
     return {
         name: 'noop',
-        project: async () => { },
+        version: '1',
+        project: () => Promise.resolve(),
     };
 }

package/dist/projectors/postgres.js

@@ -1,16 +1,19 @@
+import { DateTime, Effect } from 'effect';
 import createPostgresClient, {} from 'postgres';
 import { createIndexProjector, } from './index-model.js';
+import { runProjectorPromise } from './projector.js';
 import { POSTGRES_SCHEMA_SQL } from './schema.js';
 export { POSTGRES_SCHEMA_SQL } from './schema.js';
 function ownsClient(options) {
     return 'url' in options;
 }
-async function applyOp(sql, op) {
+function applyOp(sql, op) {
+    const date = DateTime.toDateUtc(DateTime.makeUnsafe(op.updatedAt));
     switch (op.type) {
         case 'upsertActor':
-            await sql `
+            return sql `
         INSERT INTO looms_actors (actor_id, kind, status, definition_name, parent_actor_id, updated_at)
-        VALUES (${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId}, ${new Date(op.updatedAt)})
+        VALUES (${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId}, ${date})
         ON CONFLICT (actor_id) DO UPDATE SET
           kind = EXCLUDED.kind,
           status = EXCLUDED.status,
@@ -18,31 +21,27 @@ async function applyOp(sql, op) {
           parent_actor_id = EXCLUDED.parent_actor_id,
           updated_at = EXCLUDED.updated_at
       `;
-            return;
         case 'setActorStatus':
-            await sql `
+            return sql `
         INSERT INTO looms_actors (actor_id, status, updated_at)
-        VALUES (${op.actorId}, ${op.status}, ${new Date(op.updatedAt)})
+        VALUES (${op.actorId}, ${op.status}, ${date})
         ON CONFLICT (actor_id) DO UPDATE SET
           status = EXCLUDED.status,
           updated_at = EXCLUDED.updated_at
       `;
-            return;
         case 'upsertReview':
-            await sql `
+            return sql `
         INSERT INTO looms_reviews (review_id, actor_id, status, title, updated_at)
-        VALUES (${op.reviewId}, ${op.actorId}, ${op.status}, ${op.title}, ${new Date(op.updatedAt)})
+        VALUES (${op.reviewId}, ${op.actorId}, ${op.status}, ${op.title}, ${date})
         ON CONFLICT (review_id) DO UPDATE SET
           status = EXCLUDED.status,
           updated_at = EXCLUDED.updated_at
       `;
-            return;
         case 'setReviewStatus':
-            await sql `
-        UPDATE looms_reviews SET status = ${op.status}, updated_at = ${new Date(op.updatedAt)}
+            return sql `
+        UPDATE looms_reviews SET status = ${op.status}, updated_at = ${date}
         WHERE review_id = ${op.reviewId}
       `;
-            return;
         default: {
             const exhaustiveCheck = op;
             return exhaustiveCheck;
@@ -53,56 +52,43 @@ export function postgres(options) {
     const createdClient = ownsClient(options);
     const sql = createdClient ? createPostgresClient(options.url) : options.sql;
     const backend = {
-        init: async () => {
-            await sql.unsafe(POSTGRES_SCHEMA_SQL);
-        },
-        applyOps: async (ops) => {
-            await sql.begin(async (tx) => {
-                for (const op of ops) {
-                    await applyOp(tx, op);
-                }
-            });
-        },
-        getActor: async (actorId) => {
-            const rows = await sql `
-        SELECT actor_id, kind, status, definition_name, parent_actor_id, updated_at
-        FROM looms_actors WHERE actor_id = ${actorId}
-      `;
+        init: () => runProjectorPromise('postgres', () => sql.unsafe(POSTGRES_SCHEMA_SQL)).then(() => undefined),
+        applyOps: (ops) => runProjectorPromise('postgres', () => sql.begin((tx) => Effect.runPromise(Effect.forEach(ops, (op) => Effect.promise(() => Promise.resolve(applyOp(tx, op))), {
+            discard: true,
+        })))).then(() => undefined),
+        getActor: (actorId) => runProjectorPromise('postgres', () => sql `
+          SELECT actor_id, kind, status, definition_name, parent_actor_id, updated_at
+          FROM looms_actors WHERE actor_id = ${actorId}
+        `).then((rows) => {
             const row = rows[0];
-            if (!row) {
-                return null;
-            }
-            return {
-                actorId: row.actor_id,
-                kind: row.kind,
-                status: row.status,
-                definitionName: row.definition_name,
-                parentActorId: row.parent_actor_id,
-                updatedAt: row.updated_at.getTime(),
-            };
-        },
-        listReviews: async (actorId) => {
-            const rows = actorId
-                ? await sql `
+            return row
+                ? {
+                    actorId: row.actor_id,
+                    kind: row.kind,
+                    status: row.status,
+                    definitionName: row.definition_name,
+                    parentActorId: row.parent_actor_id,
+                    updatedAt: row.updated_at.getTime(),
+                }
+                : null;
+        }),
+        listReviews: (actorId) => runProjectorPromise('postgres', () => actorId
+            ? sql `
             SELECT review_id, actor_id, status, title, updated_at
             FROM looms_reviews WHERE actor_id = ${actorId}
           `
-                : await sql `
+            : sql `
             SELECT review_id, actor_id, status, title, updated_at FROM looms_reviews
-          `;
-            return rows.map((row) => ({
-                reviewId: row.review_id,
-                actorId: row.actor_id,
-                status: row.status,
-                title: row.title,
-                updatedAt: row.updated_at.getTime(),
-            }));
-        },
-        dispose: async () => {
-            if (createdClient) {
-                await sql.end({ timeout: 5 });
-            }
-        },
+          `).then((rows) => rows.map((row) => ({
+            reviewId: row.review_id,
+            actorId: row.actor_id,
+            status: row.status,
+            title: row.title,
+            updatedAt: row.updated_at.getTime(),
+        }))),
+        dispose: () => createdClient
+            ? runProjectorPromise('postgres', () => sql.end({ timeout: 5 })).then(() => undefined)
+            : Promise.resolve(),
     };
     return createIndexProjector('postgres', backend);
 }

package/dist/projectors/projector.d.ts

@@ -1,7 +1,23 @@
+import { Effect } from 'effect';
 import type { EventEnvelope } from '@swirls/looms/core';
+declare const ProjectorError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProjectorError";
+} & Readonly<A>;
+export declare class ProjectorError extends ProjectorError_base<{
+    readonly projector: string;
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+    constructor(projector: string, cause: unknown);
+}
+export declare function runProjectorEffect<A>(projector: string, operation: () => PromiseLike<A>): Effect.Effect<A, ProjectorError>;
+export declare function runProjectorSync<A>(projector: string, operation: () => A): Promise<A>;
+export declare function runProjectorPromise<A>(projector: string, operation: () => PromiseLike<A>): Promise<A>;
 export interface Projector {
     /** Used in error reporting / diagnostics. */
     readonly name: string;
+    /** Changes when projection semantics or its target schema changes. */
+    readonly version: string;
     /** Optional one-time setup (open connection, create tables). Runtime calls this before the first `project`. */
     readonly init?: () => Promise<void>;
     /** Apply a batch of events in log order. Must be idempotent (a batch may be redelivered). */
@@ -9,3 +25,4 @@ export interface Projector {
     readonly dispose?: () => Promise<void>;
 }
 export type ProjectorErrorHandler = (error: Error, projector: Projector, events: ReadonlyArray<EventEnvelope>) => void;
+export {};

package/dist/projectors/projector.js

@@ -1 +1,26 @@
-export {};
+import { Data, Effect } from 'effect';
+export class ProjectorError extends Data.TaggedError('ProjectorError') {
+    constructor(projector, cause) {
+        super({
+            projector,
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'ProjectorError';
+    }
+}
+export function runProjectorEffect(projector, operation) {
+    return Effect.tryPromise({
+        try: () => Promise.resolve(operation()),
+        catch: (cause) => new ProjectorError(projector, cause),
+    });
+}
+export function runProjectorSync(projector, operation) {
+    return Effect.runPromise(Effect.try({
+        try: operation,
+        catch: (cause) => new ProjectorError(projector, cause),
+    }));
+}
+export function runProjectorPromise(projector, operation) {
+    return Effect.runPromise(runProjectorEffect(projector, operation));
+}

package/dist/projectors/sqlite-delivery.d.ts

@@ -0,0 +1,4 @@
+import type { SqliteExec } from '@swirls/looms/core/sqlite-store';
+import { type ProjectorCursorStore } from './delivery';
+export declare const SQLITE_PROJECTOR_DELIVERY_SCHEMA: string;
+export declare function sqliteProjectorCursorStore(exec: SqliteExec): ProjectorCursorStore;

package/dist/projectors/sqlite-delivery.js

@@ -0,0 +1,147 @@
+import { Effect, Schema } from 'effect';
+import { ProjectorCursorError, } from './delivery.js';
+export const SQLITE_PROJECTOR_DELIVERY_SCHEMA = `
+CREATE TABLE IF NOT EXISTS looms_projector_delivery (
+  run_id TEXT NOT NULL,
+  projector_name TEXT NOT NULL,
+  projector_version TEXT NOT NULL,
+  cursor INTEGER NOT NULL DEFAULT 0,
+  state TEXT NOT NULL DEFAULT 'idle',
+  attempts INTEGER NOT NULL DEFAULT 0,
+  failed_seq INTEGER,
+  next_retry_at INTEGER,
+  last_error TEXT,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (run_id, projector_name, projector_version)
+);
+CREATE INDEX IF NOT EXISTS looms_projector_delivery_retry_idx
+  ON looms_projector_delivery (next_retry_at)
+`.trim();
+const DeliveryRowSchema = Schema.Struct({
+    run_id: Schema.String,
+    projector_name: Schema.String,
+    projector_version: Schema.String,
+    cursor: Schema.Finite,
+    state: Schema.String,
+    attempts: Schema.Finite,
+    failed_seq: Schema.NullOr(Schema.Finite),
+    next_retry_at: Schema.NullOr(Schema.Finite),
+    last_error: Schema.NullOr(Schema.String),
+    updated_at: Schema.Finite,
+});
+const decodeDeliveryRow = Schema.decodeUnknownSync(DeliveryRowSchema);
+function parseState(value) {
+    switch (value) {
+        case 'idle':
+        case 'retrying':
+        case 'dead-letter':
+            return value;
+        default:
+            throw new Error(`Invalid projector delivery state: ${value}`);
+    }
+}
+function deliveryStatus(row) {
+    return {
+        runId: row.run_id,
+        projector: row.projector_name,
+        version: row.projector_version,
+        cursor: row.cursor,
+        state: parseState(row.state),
+        attempts: row.attempts,
+        failedSeq: row.failed_seq,
+        nextRetryAt: row.next_retry_at,
+        lastError: row.last_error,
+        updatedAt: row.updated_at,
+    };
+}
+function initialize(exec) {
+    for (const statement of SQLITE_PROJECTOR_DELIVERY_SCHEMA.split(';')) {
+        const sql = statement.trim();
+        if (sql.length > 0) {
+            exec.run(sql);
+        }
+    }
+}
+function query(run) {
+    return Effect.try({
+        try: run,
+        catch: (cause) => new ProjectorCursorError({
+            message: cause instanceof Error ? cause.message : 'Projector cursor query failed',
+        }),
+    });
+}
+export function sqliteProjectorCursorStore(exec) {
+    initialize(exec);
+    const get = (runId, projector) => {
+        const [row] = exec.rows(`SELECT run_id, projector_name, projector_version, cursor, state, attempts,
+              failed_seq, next_retry_at, last_error, updated_at
+       FROM looms_projector_delivery
+       WHERE run_id = ? AND projector_name = ? AND projector_version = ?`, [runId, projector.name, projector.version]);
+        return row === undefined
+            ? {
+                runId,
+                projector: projector.name,
+                version: projector.version,
+                cursor: 0,
+                state: 'idle',
+                attempts: 0,
+                failedSeq: null,
+                nextRetryAt: null,
+                lastError: null,
+                updatedAt: 0,
+            }
+            : deliveryStatus(decodeDeliveryRow(row));
+    };
+    return {
+        get: (runId, projector) => query(() => get(runId, projector)),
+        advance: (runId, projector, cursor, now) => query(() => {
+            exec.run(`INSERT INTO looms_projector_delivery
+           (run_id, projector_name, projector_version, cursor, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT (run_id, projector_name, projector_version) DO UPDATE
+         SET cursor = MAX(cursor, excluded.cursor), state = 'idle', attempts = 0,
+             failed_seq = NULL, next_retry_at = NULL, last_error = NULL,
+             updated_at = excluded.updated_at`, [runId, projector.name, projector.version, cursor, now]);
+        }),
+        fail: (runId, projector, failure) => query(() => {
+            exec.run(`INSERT INTO looms_projector_delivery
+           (run_id, projector_name, projector_version, state, attempts, failed_seq,
+            next_retry_at, last_error, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (run_id, projector_name, projector_version) DO UPDATE
+         SET state = excluded.state, attempts = excluded.attempts,
+             failed_seq = excluded.failed_seq, next_retry_at = excluded.next_retry_at,
+             last_error = excluded.last_error, updated_at = excluded.updated_at
+         WHERE cursor < excluded.failed_seq`, [
+                runId,
+                projector.name,
+                projector.version,
+                failure.nextRetryAt === null ? 'dead-letter' : 'retrying',
+                failure.attempts,
+                failure.failedSeq,
+                failure.nextRetryAt,
+                failure.error,
+                failure.now,
+            ]);
+        }),
+        requeue: (runId, projector, now) => query(() => {
+            exec.run(`INSERT INTO looms_projector_delivery
+           (run_id, projector_name, projector_version, state, next_retry_at, updated_at)
+         VALUES (?, ?, ?, 'retrying', ?, ?)
+         ON CONFLICT (run_id, projector_name, projector_version) DO UPDATE
+         SET state = 'retrying', attempts = 0, next_retry_at = excluded.next_retry_at,
+             last_error = NULL, updated_at = excluded.updated_at`, [runId, projector.name, projector.version, now, now]);
+        }),
+        list: (runId) => {
+            const params = runId === undefined ? [] : [runId];
+            const where = runId === undefined ? '' : 'WHERE run_id = ?';
+            return query(() => exec
+                .rows(`SELECT run_id, projector_name, projector_version, cursor, state, attempts,
+                  failed_seq, next_retry_at, last_error, updated_at
+           FROM looms_projector_delivery ${where}
+           ORDER BY run_id, projector_name, projector_version`, params)
+                .map((row) => decodeDeliveryRow(row))
+                .map(deliveryStatus));
+        },
+    };
+}