@swirls/looms 0.4.0 → 0.5.0

package/dist/client/client.js

@@ -1,5 +1,5 @@
-import { Data, Effect, Option, Schema, Stream } from 'effect';
-import { createRunId, DefinitionCatalogSchema, EventEnvelopeSchema, ReplayStepSchema, RunStateSchema, RunSummariesSchema, stringifyJson, } from '@swirls/looms/core';
+import { Data, Effect, Option, Predicate, Schema, Stream } from 'effect';
+import { createRunId, DefinitionCatalogSchema, EventEnvelopeSchema, readSubscriptionData, ReplayStepSchema, RunStateSchema, RunSummariesSchema, SecretContextSchema, stringifyJson, traceHeaders, } from '@swirls/looms/core';
 import { consumeSseStreamEffect, eventsFromSseData, sseFrames } from './sse.js';
 class LoomsClientError extends Data.TaggedError('LoomsClientError') {
     constructor(message, cause) {
@@ -14,6 +14,46 @@ const StartResultSchema = Schema.Struct({
     state: RunStateSchema,
 });
 const RunResultSchema = Schema.Struct({ runId: Schema.String, state: RunStateSchema });
+function attemptPath(runId, attempt) {
+    return `/runs/${encodeURIComponent(runId)}/effects/${encodeURIComponent(attempt.effectId)}/${attempt.attempt}`;
+}
+function workerCallbackBody(input) {
+    switch (input.kind) {
+        case 'complete':
+            return { events: input.events };
+        case 'fail': {
+            const body = { error: input.error };
+            if (input.nonRetryable !== undefined) {
+                body.nonRetryable = input.nonRetryable;
+            }
+            if (input.retryAfterMs !== undefined) {
+                body.retryAfterMs = input.retryAfterMs;
+            }
+            return body;
+        }
+        case 'heartbeat':
+            return input.details === undefined ? {} : { details: input.details };
+        case 'started':
+        case 'cancelled':
+            return {};
+        default: {
+            const exhaustive = input;
+            return exhaustive;
+        }
+    }
+}
+const WorkerCallbackResultSchema = Schema.Struct({
+    status: Schema.Union([
+        Schema.Literal('accepted'),
+        Schema.Literal('stale'),
+        Schema.Literal('cancelled'),
+    ]),
+    cancelRequested: Schema.Boolean,
+});
+const WorkerSecretsResultSchema = Schema.Union([
+    Schema.Struct({ status: Schema.Literal('accepted'), secrets: SecretContextSchema }),
+    Schema.Struct({ status: Schema.Union([Schema.Literal('stale'), Schema.Literal('cancelled')]) }),
+]);
 /** `appended` counts the events the run gained while the wake ran. */
 const WakeResultSchema = Schema.Struct({
     runId: Schema.String,
@@ -54,19 +94,33 @@ export function createLoomsClient(options = {}) {
             return yield* Schema.decodeUnknownEffect(schema)(body).pipe(Effect.mapError((cause) => new LoomsClientError('Invalid response body', cause)));
         }));
     }
-    const subscribeEvents = (runId, onEvent, reconnectDelayMs = 1_000) => {
+    const subscribeEvents = (runId, onEvent, third = 1_000) => {
+        const settings = subscriptionSettings(third, options.grant);
         let fromSeq = 1;
         const controller = new AbortController();
         const run = Effect.gen(function* () {
             while (!controller.signal.aborted) {
                 yield* Effect.gen(function* () {
+                    if (useWebSocket(settings)) {
+                        return yield* consumeWebSocket({
+                            baseUrl,
+                            runId,
+                            settings,
+                            signal: controller.signal,
+                            currentSeq: () => fromSeq,
+                            setSeq: (next) => {
+                                fromSeq = next;
+                            },
+                            onEvent,
+                        });
+                    }
                     const cursor = Math.max(0, fromSeq - 1);
                     const headers = new Headers({ accept: 'text/event-stream' });
                     if (cursor > 0) {
                         headers.set('last-event-id', String(cursor));
                     }
                     const res = yield* Effect.tryPromise({
-                        try: (signal) => fetchImpl(`${baseUrl}/runs/${encodeURIComponent(runId)}/events?fromSeq=${fromSeq}`, {
+                        try: (signal) => fetchImpl(`${baseUrl}${eventsQuery(runId, fromSeq, settings)}`, {
                             headers,
                             signal,
                         }),
@@ -75,10 +129,20 @@ export function createLoomsClient(options = {}) {
                     const body = res.body;
                     if (res.ok && body) {
                         return yield* consumeSseStreamEffect(body, (frame) => {
-                            for (const event of eventsFromSseData(frame.data, runId)) {
-                                onEvent(event);
-                                fromSeq = Math.max(fromSeq, event.seq + 1);
-                            }
+                            let resync = false;
+                            deliverSubscriptionData({
+                                data: frame.data,
+                                runId,
+                                currentSeq: () => fromSeq,
+                                setSeq: (next) => {
+                                    fromSeq = next;
+                                },
+                                onEvent,
+                                onResync: () => {
+                                    resync = true;
+                                },
+                            });
+                            return resync ? false : undefined;
                         });
                     }
                     return yield* new LoomsClientError(res.ok ? 'event stream missing body' : `HTTP ${res.status}`);
@@ -86,7 +150,7 @@ export function createLoomsClient(options = {}) {
                 if (controller.signal.aborted) {
                     break;
                 }
-                yield* Effect.sleep(reconnectDelayMs);
+                yield* Effect.sleep(settings.reconnectDelayMs);
             }
         });
         void Effect.runPromise(run, { signal: controller.signal }).catch(() => undefined);
@@ -94,31 +158,43 @@ export function createLoomsClient(options = {}) {
             controller.abort();
         };
     };
-    const startRun = (args) => request('/runs', StartResultSchema, { method: 'POST', body: stringifyJson(args) });
+    const startRun = (args) => {
+        const { trace, ...body } = args;
+        return request('/runs', StartResultSchema, {
+            method: 'POST',
+            headers: traceHeaders(trace),
+            body: stringifyJson(body),
+        });
+    };
+    const workerHeaders = options.workerCallbackToken
+        ? { authorization: `Bearer ${options.workerCallbackToken}` }
+        : undefined;
     const workerCallback = (runId, input) => {
-        const body = input.kind === 'complete'
-            ? { events: input.events }
-            : input.kind === 'fail'
-                ? { error: input.error }
-                : {};
-        return request(`/runs/${encodeURIComponent(runId)}/effects/${encodeURIComponent(input.effectId)}/${input.attempt}/${input.kind}`, RunResultSchema, {
+        const body = workerCallbackBody(input);
+        return request(`${attemptPath(runId, input)}/${input.kind}`, WorkerCallbackResultSchema, {
             method: 'POST',
-            headers: options.workerCallbackToken
-                ? { authorization: `Bearer ${options.workerCallbackToken}` }
-                : undefined,
+            headers: workerHeaders,
             body: stringifyJson(body),
         });
     };
+    /** Read the run's secret context. Only the attempt that is currently running gets it. */
+    const workerSecrets = (runId, attempt) => request(`${attemptPath(runId, attempt)}/secrets`, WorkerSecretsResultSchema, {
+        method: 'POST',
+        headers: workerHeaders,
+        body: '{}',
+    });
     const streamRun = (args) => {
-        const runId = args.runId ?? createRunId();
+        const { trace, ...body } = args;
+        const runId = body.runId ?? createRunId();
         const stream = Stream.unwrap(Effect.tryPromise({
             try: (signal) => fetchImpl(`${baseUrl}/runs`, {
                 method: 'POST',
                 headers: {
+                    ...traceHeaders(trace),
                     'content-type': 'application/json',
                     accept: 'text/event-stream',
                 },
-                body: stringifyJson({ ...args, runId }),
+                body: stringifyJson({ ...body, runId }),
                 signal,
             }),
             catch: (cause) => new LoomsClientError('Failed to start event stream', cause),
@@ -175,6 +251,7 @@ export function createLoomsClient(options = {}) {
             body: stringifyJson(forkOptions?.runId === undefined ? {} : { runId: forkOptions.runId }),
         }),
         workerCallback,
+        workerSecrets,
         listRunSummaries: () => request('/runs/summaries', RunSummariesSchema),
         listDefinitions: () => request('/definitions', DefinitionCatalogSchema),
         replayTo: (runId, seq) => request(`/runs/${encodeURIComponent(runId)}/replay?seq=${seq}`, ReplayResultSchema),
@@ -193,3 +270,119 @@ export function createLoomsClient(options = {}) {
         }),
     };
 }
+function subscriptionSettings(third, grant) {
+    if (Predicate.isNumber(third)) {
+        return { transport: 'sse', reconnectDelayMs: third, grant };
+    }
+    return {
+        transport: third.transport ?? 'sse',
+        reconnectDelayMs: third.reconnectDelayMs ?? 1_000,
+        threadId: third.threadId,
+        includeEphemeral: third.includeEphemeral,
+        webSocket: third.webSocket,
+        grant,
+    };
+}
+function useWebSocket(settings) {
+    if (settings.transport !== 'websocket' && settings.transport !== 'auto') {
+        return false;
+    }
+    return settings.webSocket !== undefined || globalWebSocket() !== undefined;
+}
+function eventsQuery(runId, fromSeq, settings) {
+    const params = new URLSearchParams({ fromSeq: String(fromSeq) });
+    if (settings.threadId) {
+        params.set('threadId', settings.threadId);
+    }
+    if (settings.includeEphemeral === false) {
+        params.set('includeEphemeral', 'false');
+    }
+    if (settings.grant) {
+        params.set('grant', settings.grant);
+    }
+    return `/runs/${encodeURIComponent(runId)}/events?${params.toString()}`;
+}
+function webSocketUrl(baseUrl, path) {
+    const url = new URL(path, baseUrl);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    return url.toString();
+}
+function globalWebSocket() {
+    if (!('WebSocket' in globalThis) || !Predicate.isFunction(globalThis.WebSocket)) {
+        return undefined;
+    }
+    return globalThis.WebSocket;
+}
+function consumeWebSocket(subscription) {
+    const Socket = subscription.settings.webSocket ?? globalWebSocket();
+    if (!Socket) {
+        return Effect.void;
+    }
+    const url = webSocketUrl(subscription.baseUrl, eventsQuery(subscription.runId, subscription.currentSeq(), subscription.settings));
+    return Effect.callback((resume) => {
+        const socket = new Socket(url);
+        const finish = () => {
+            resume(Effect.void);
+        };
+        if (subscription.signal.aborted) {
+            socket.close();
+            finish();
+            return Effect.void;
+        }
+        const onAbort = () => {
+            socket.close();
+            finish();
+        };
+        subscription.signal.addEventListener('abort', onAbort);
+        socket.addEventListener('message', (event) => {
+            if (!Predicate.isString(event.data)) {
+                return;
+            }
+            deliverSubscriptionData({
+                data: event.data,
+                runId: subscription.runId,
+                currentSeq: subscription.currentSeq,
+                setSeq: subscription.setSeq,
+                onEvent: subscription.onEvent,
+                onResync: () => {
+                    socket.close();
+                },
+            });
+        });
+        socket.addEventListener('close', finish);
+        socket.addEventListener('error', finish);
+        return Effect.sync(() => {
+            subscription.signal.removeEventListener('abort', onAbort);
+            socket.close();
+        });
+    });
+}
+function deliverSubscriptionData(delivery) {
+    const read = readSubscriptionData(delivery.data, delivery.runId);
+    switch (read.kind) {
+        case 'events': {
+            const fromSeq = delivery.currentSeq();
+            let next = fromSeq;
+            for (const event of read.events) {
+                if (event.seq < fromSeq) {
+                    continue;
+                }
+                delivery.onEvent(event);
+                next = Math.max(next, event.seq + 1);
+            }
+            delivery.setSeq(next);
+            return;
+        }
+        case 'resync':
+            delivery.setSeq(read.head);
+            delivery.onResync();
+            return;
+        case 'hello':
+        case 'ignore':
+            return;
+        default: {
+            const unexpected = read;
+            return unexpected;
+        }
+    }
+}

package/dist/client/index.d.ts

@@ -1,2 +1,2 @@
-export { createLoomsClient, type LoomsClient, type LoomsClientOptions, type StartResult, type StreamHandle, } from './client';
+export { createLoomsClient, type LoomsClient, type LoomsClientOptions, type StartResult, type StreamHandle, type SubscribeEventsOptions, type SubscriptionSocket, type SubscriptionSocketConstructor, } from './client';
 export { consumeSseStream, consumeSseStreamEffect, delay, eventsFromSseData, parseSseFrame, type SseFrame, } from './sse';

package/dist/client/sse.d.ts

@@ -15,7 +15,7 @@ export declare class SseStreamError extends SseStreamError_base<{
 }> {
     constructor(cause: unknown);
 }
-export declare function consumeSseStreamEffect(body: ReadableStream<Uint8Array>, onFrame: (frame: SseFrame) => void): Effect.Effect<void, SseStreamError>;
+export declare function consumeSseStreamEffect(body: ReadableStream<Uint8Array>, onFrame: (frame: SseFrame) => void | boolean): Effect.Effect<void, SseStreamError>;
 export declare function sseFrames(body: ReadableStream<Uint8Array>): Stream.Stream<SseFrame, SseStreamError>;
 export declare function consumeSseStream(body: ReadableStream<Uint8Array>, onFrame: (frame: SseFrame) => void, signal?: AbortSignal): Promise<void>;
 export declare function eventsFromSseData(data: string, runId: string): EventEnvelope[];

package/dist/client/sse.js

@@ -52,8 +52,8 @@ export function consumeSseStreamEffect(body, onFrame) {
             buffer = chunks.pop() ?? '';
             for (const chunk of chunks) {
                 const frame = parseSseFrame(chunk);
-                if (frame) {
-                    onFrame(frame);
+                if (frame && onFrame(frame) === false) {
+                    return;
                 }
             }
         }

package/dist/cloudflare/durable-object.d.ts

@@ -1,10 +1,14 @@
 import { DurableObject } from 'cloudflare:workers';
-import type { AnyRuntimeModule, EventStoreTrimCoverage } from '@swirls/looms/core';
+import { type AnyRuntimeModule, type DefinitionResolver, type EventInput, type BlobStore, type EventStoreTrimCoverage, type LaunchRunArgs, type RunLauncher, type RunState, type RunStatusSnapshot } from '@swirls/looms/core';
 import type { Projector } from '@swirls/looms/projectors';
-import type { Authorize } from '@swirls/looms/runtime';
+import { type Authorize, type StartResult, type StartRunArgs } from '@swirls/looms/runtime';
 export interface LoomsDurableObjectConfig {
     readonly modules: readonly AnyRuntimeModule[];
+    /** Loads definitions that were not registered on a module. See `CreateRuntimeOptions`. */
+    readonly definitionResolver?: DefinitionResolver;
     readonly projectors?: readonly Projector[];
+    /** Content-addressed store for event and snapshot JSON over the inline byte limits. */
+    readonly blobs?: BlobStore;
     readonly snapshotEvery?: number;
     readonly maxWakeIterations?: number;
     readonly maxPendingRunOperations?: number;
@@ -14,6 +18,11 @@ export interface LoomsDurableObjectConfig {
     };
     /** Authorizes the actor's HTTP API; see `createFetchHandler`. */
     readonly authorize?: Authorize;
+    /**
+     * Starts runs from effect handlers. A schedule object passes `durableObjectLauncher` so fires
+     * land in the target's object. Without it, a fire fails instead of writing into this object.
+     */
+    readonly launcher?: RunLauncher;
 }
 /**
  * Base Durable Object class for hosting a Looms actor cell.
@@ -23,10 +32,65 @@ export interface LoomsDurableObjectConfig {
 export declare abstract class LoomsDurableObject<Env = unknown> extends DurableObject<Env> {
     private cellPromise?;
     private store?;
+    private authorize;
     abstract configure(env: Env): LoomsDurableObjectConfig | Promise<LoomsDurableObjectConfig>;
     private getCell;
     private createCell;
     fetch(req: Request): Promise<Response>;
+    /** Client messages are ignored. Signals and other writes stay on HTTP. */
+    webSocketMessage(): void;
+    webSocketClose(): void;
+    webSocketError(): void;
+    private acceptRunSocket;
+    /** Commit this object's run and set its alarm. Returns before the run wakes. */
+    launch(args: LaunchRunArgs): Promise<void>;
+    status(): Promise<RunStatusSnapshot | null>;
+    startRun(args: StartRunArgs): Promise<StartResult>;
+    signal(events: ReadonlyArray<EventInput>, options?: {
+        idempotencyKey?: string;
+        coalesce?: boolean;
+    }): Promise<RunState>;
+    accept(events: ReadonlyArray<EventInput>, options?: {
+        idempotencyKey?: string;
+        coalesce?: boolean;
+    }): Promise<RunState>;
+    cancel(): Promise<void>;
+    getRun(): Promise<RunState>;
     /** A rejected alarm is retried by the platform with backoff, so failures just propagate. */
     alarm(): Promise<void>;
 }
+export interface DurableObjectRunStub {
+    fetch(request: Request): Promise<Response>;
+    launch(args: LaunchRunArgs): Promise<void>;
+    status(): Promise<RunStatusSnapshot | null>;
+    startRun(args: StartRunArgs): Promise<StartResult>;
+    signal(events: ReadonlyArray<EventInput>, options?: {
+        idempotencyKey?: string;
+        coalesce?: boolean;
+    }): Promise<RunState>;
+    accept(events: ReadonlyArray<EventInput>, options?: {
+        idempotencyKey?: string;
+        coalesce?: boolean;
+    }): Promise<RunState>;
+    cancel(): Promise<void>;
+    getRun(): Promise<RunState>;
+}
+/**
+ * Launches and reads runs in other Durable Objects. One object per `runId`.
+ * The argument is the binding, not the stub, so a class can pass its own namespace
+ * without the type checker expanding that class through this function.
+ */
+export declare function durableObjectLauncher(namespace: {
+    getByName(name: string): object;
+}): RunLauncher;
+export interface DurableObjectScheduleHost {
+    startRun(args: StartRunArgs): Promise<StartResult>;
+    signal(runId: string, events: ReadonlyArray<EventInput>, options?: {
+        idempotencyKey?: string;
+    }): Promise<RunState>;
+    getRun(runId: string): Promise<RunState>;
+}
+/** `ScheduleHost` for a Worker that reconciles schedules onto Durable Objects. */
+export declare function durableObjectScheduleHost(namespace: {
+    getByName(name: string): object;
+}): DurableObjectScheduleHost;

package/dist/cloudflare/durable-object.js

@@ -1,8 +1,11 @@
 import { DurableObject } from 'cloudflare:workers';
 import { Effect } from 'effect';
 import { createActorCell } from '@swirls/looms/actor';
+import { createRemoteRunLauncher, } from '@swirls/looms/core';
+import { defaultAuthorize, } from '@swirls/looms/runtime';
 import { durableObjectAlarms } from './alarm-scheduler.js';
 import { durableObjectEventStore } from './event-store.js';
+import { attachSocketFanout, isRunSocketUpgrade, openRunSocket } from './websocket.js';
 /**
  * Base Durable Object class for hosting a Looms actor cell.
  * Subclasses implement `configure(env)` to supply configured modules.
@@ -11,6 +14,7 @@ import { durableObjectEventStore } from './event-store.js';
 export class LoomsDurableObject extends DurableObject {
     cellPromise;
     store;
+    authorize = defaultAuthorize;
     getCell() {
         if (this.cellPromise) {
             return this.cellPromise;
@@ -36,18 +40,22 @@ export class LoomsDurableObject extends DurableObject {
             const store = durableObjectEventStore(this.ctx, {
                 projectors: config.projectors,
                 scheduleProjectorRetry: alarms.scheduleAtEarliest,
+                blobs: config.blobs,
             });
             this.store = store;
+            this.authorize = config.authorize ?? defaultAuthorize;
             const cell = createActorCell({
                 runId,
-                store,
+                store: attachSocketFanout(this.ctx, store, runId),
                 scheduler: alarms.scheduler,
                 modules: config.modules,
+                definitionResolver: config.definitionResolver,
                 snapshotEvery: config.snapshotEvery,
                 maxWakeIterations: config.maxWakeIterations,
                 maxPendingRunOperations: config.maxPendingRunOperations,
                 trimAfterSnapshot: config.trimAfterSnapshot,
                 authorize: config.authorize,
+                launcher: config.launcher,
             });
             const delivery = store.projectorDelivery;
             const recoverProjectors = delivery
@@ -57,8 +65,58 @@ export class LoomsDurableObject extends DurableObject {
         });
     }
     fetch(req) {
+        if (isRunSocketUpgrade(req)) {
+            return this.getCell().then((cell) => this.acceptRunSocket(req, cell.runtime));
+        }
         return this.getCell().then((cell) => cell.fetch(req));
     }
+    /** Client messages are ignored. Signals and other writes stay on HTTP. */
+    webSocketMessage() {
+        // A hibernated socket stays quiet. The platform delivers this only if a client writes.
+    }
+    webSocketClose() {
+        // The platform drops the socket. Nothing is retained for it.
+    }
+    webSocketError() {
+        // The platform drops the socket. Nothing is retained for it.
+    }
+    acceptRunSocket(req, runtime) {
+        const store = this.store;
+        const runId = this.ctx.id.name;
+        if (!store || !runId) {
+            return Promise.resolve(Response.json({ error: 'Run is not ready' }, { status: 500 }));
+        }
+        return Effect.runPromise(openRunSocket({
+            ctx: this.ctx,
+            runtime,
+            store,
+            request: req,
+            runId,
+            authorize: this.authorize,
+        }));
+    }
+    /** Commit this object's run and set its alarm. Returns before the run wakes. */
+    launch(args) {
+        return this.getCell().then((cell) => cell.launch(args));
+    }
+    status() {
+        return this.getCell().then((cell) => cell.status());
+    }
+    startRun(args) {
+        return this.getCell().then((cell) => cell.startRun(args));
+    }
+    signal(events, options) {
+        return this.getCell().then((cell) => cell.signal(events, options));
+    }
+    accept(events, options) {
+        return this.getCell().then((cell) => cell.accept(events, options));
+    }
+    cancel() {
+        return this.getCell().then((cell) => cell.cancel());
+    }
+    getRun() {
+        return this.getCell().then((cell) => cell.getRun());
+    }
     /** A rejected alarm is retried by the platform with backoff, so failures just propagate. */
     alarm() {
         return this.getCell()
@@ -72,3 +130,40 @@ export class LoomsDurableObject extends DurableObject {
             .then(() => undefined);
     }
 }
+/**
+ * Launches and reads runs in other Durable Objects. One object per `runId`.
+ * The argument is the binding, not the stub, so a class can pass its own namespace
+ * without the type checker expanding that class through this function.
+ */
+export function durableObjectLauncher(namespace) {
+    const runs = loomsNamespace(namespace);
+    return createRemoteRunLauncher({
+        launch: (runId, args) => runs.getByName(runId).launch(args),
+        status: (runId) => runs.getByName(runId).status(),
+        accept: (runId, events, options) => runs
+            .getByName(runId)
+            .accept(events, options)
+            .then(() => undefined),
+        cancel: (runId) => runs.getByName(runId).cancel(),
+    });
+}
+/** `ScheduleHost` for a Worker that reconciles schedules onto Durable Objects. */
+export function durableObjectScheduleHost(namespace) {
+    const runs = loomsNamespace(namespace);
+    return {
+        startRun: (args) => {
+            const runId = args.runId;
+            if (!runId) {
+                return Promise.reject(new Error('ScheduleHost.startRun requires runId'));
+            }
+            return runs.getByName(runId).startRun(args);
+        },
+        signal: (runId, events, options) => runs.getByName(runId).signal(events, options),
+        getRun: (runId) => runs.getByName(runId).getRun(),
+    };
+}
+function loomsNamespace(namespace) {
+    // SAFETY: callers pass a Looms Durable Object namespace, whose stub implements these methods.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    return namespace;
+}

package/dist/cloudflare/event-store.d.ts

@@ -1,15 +1,19 @@
-import type { Effect } from 'effect';
-import type { EventStore } from '@swirls/looms/core';
+import { Effect } from 'effect';
+import { type BlobStore, type EventStore } from '@swirls/looms/core';
 import { type Projector, type ProjectorDelivery } from '@swirls/looms/projectors';
 export interface DurableObjectStoreOptions {
     readonly projectors?: readonly Projector[];
     readonly scheduleProjectorRetry?: (at: number) => Effect.Effect<void>;
+    /** Offloads oversized event and snapshot JSON. See `withBlobOffload`. */
+    readonly blobs?: BlobStore;
 }
 export interface DurableObjectEventStore extends EventStore {
     readonly projectorDelivery?: ProjectorDelivery;
 }
 /**
  * Creates an EventStore backed by a Durable Object's embedded SQLite database (`ctx.storage.sql`).
- * Optionally attaches asynchronous projectors (such as S2).
+ * Optionally attaches projectors. Their delivery is scheduled with `waitUntil`, so an append
+ * returns when the log commits. A crashed delivery is retried from the durable cursor on the next
+ * alarm or request.
  */
 export declare function durableObjectEventStore(ctx: DurableObjectState, options?: DurableObjectStoreOptions): DurableObjectEventStore;

package/dist/cloudflare/event-store.js

@@ -1,18 +1,31 @@
+import { Effect } from 'effect';
+import { snapshotStoreOf, withBlobOffload } from '@swirls/looms/core';
 import { sqliteEventStore, sqlStorageExec } from '@swirls/looms/core/sqlite-store';
 import { createProjectorDelivery, sqliteProjectorCursorStore, withProjectors, } from '@swirls/looms/projectors';
 /**
  * Creates an EventStore backed by a Durable Object's embedded SQLite database (`ctx.storage.sql`).
- * Optionally attaches asynchronous projectors (such as S2).
+ * Optionally attaches projectors. Their delivery is scheduled with `waitUntil`, so an append
+ * returns when the log commits. A crashed delivery is retried from the durable cursor on the next
+ * alarm or request.
  */
 export function durableObjectEventStore(ctx, options = {}) {
     const exec = sqlStorageExec(ctx.storage.sql, {
         // DO SQLite rejects BEGIN/COMMIT/ROLLBACK; use the storage transaction API.
         transaction: (fn) => ctx.storage.transactionSync(fn),
     });
-    const store = sqliteEventStore({ exec });
+    const sqlite = sqliteEventStore({ exec });
+    const snapshots = snapshotStoreOf(sqlite);
+    const store = options.blobs
+        ? withBlobOffload(sqlite, options.blobs, snapshots ? { snapshots } : undefined)
+        : sqlite;
     if (options.projectors && options.projectors.length > 0) {
         const delivery = createProjectorDelivery(store, options.projectors, sqliteProjectorCursorStore(exec), { scheduleRetry: options.scheduleProjectorRetry });
-        const wrapped = withProjectors(store, options.projectors, { delivery });
+        const wrapped = withProjectors(store, options.projectors, {
+            delivery,
+            scheduleDelivery: (_runId, work) => {
+                ctx.waitUntil(Effect.runPromise(work));
+            },
+        });
         return Object.assign(wrapped, { projectorDelivery: delivery });
     }
     return store;

package/dist/cloudflare/index.d.ts

@@ -1,4 +1,10 @@
 export { durableObjectAlarms, type AlarmStorage, type DurableObjectAlarms } from './alarm-scheduler';
 export { durableObjectEventStore, type DurableObjectEventStore, type DurableObjectStoreOptions, } from './event-store';
-export { LoomsDurableObject, type LoomsDurableObjectConfig } from './durable-object';
+export { durableObjectLauncher, durableObjectScheduleHost, LoomsDurableObject, type DurableObjectRunStub, type LoomsDurableObjectConfig, } from './durable-object';
+export { r2BlobStore, type R2BucketLike, type R2ListResult, type R2ObjectBodyLike, type R2StoredObject, } from './r2-blob-store';
 export { routeToDurableObject, type DurableObjectNamespaceLike, type DurableObjectStubLike, } from './router';
+export { createMemoryQueue, type MemoryQueue, type MemoryQueueOptions } from './memory-queue';
+export { processQueueMessage, queueConsumer, QueueTaskError, type QueueBatchLike, type QueueConsumerOptions, type QueueTask, type QueueTaskContext, type QueueTaskHandler, type WorkerCallbackClient, } from './queue-consumer';
+export { readQueueEffectMessage, type QueueEffectMessage, type QueueMessageLike, } from './queue-message';
+export { cloudflareQueuePullSource, createQueuePullConsumer, QueuePullError, type CloudflareQueuePullSourceOptions, type PulledQueueMessage, type QueueLeaseRetry, type QueuePullConsumer, type QueuePullConsumerOptions, type QueuePullResult, type QueuePullSource, } from './queue-pull';
+export { cloudflareQueueWorker, DEFAULT_MAX_QUEUE_MESSAGE_BYTES, QueueDispatchError, type CloudflareQueueWorkerOptions, type QueueProducer, type QueueRoute, } from './queue-worker';

package/dist/cloudflare/index.js

@@ -1,4 +1,10 @@
 export { durableObjectAlarms } from './alarm-scheduler.js';
 export { durableObjectEventStore, } from './event-store.js';
-export { LoomsDurableObject } from './durable-object.js';
+export { durableObjectLauncher, durableObjectScheduleHost, LoomsDurableObject, } from './durable-object.js';
+export { r2BlobStore, } from './r2-blob-store.js';
 export { routeToDurableObject, } from './router.js';
+export { createMemoryQueue } from './memory-queue.js';
+export { processQueueMessage, queueConsumer, QueueTaskError, } from './queue-consumer.js';
+export { readQueueEffectMessage, } from './queue-message.js';
+export { cloudflareQueuePullSource, createQueuePullConsumer, QueuePullError, } from './queue-pull.js';
+export { cloudflareQueueWorker, DEFAULT_MAX_QUEUE_MESSAGE_BYTES, QueueDispatchError, } from './queue-worker.js';