@swirls/looms 0.0.2 → 0.2.0

package/dist/client/client.js

@@ -1,151 +1,147 @@
-import { Predicate } from 'effect';
-import { createRunId, } from '@swirls/looms/core';
-import { consumeSseStream, delay, eventsFromSseData } from './sse.js';
+import { Data, Effect, Option, Schema, Stream } from 'effect';
+import { createRunId, DefinitionCatalogSchema, EventEnvelopeSchema, ReplayStepSchema, RunStateSchema, RunSummariesSchema, stringifyJson, } from '@swirls/looms/core';
+import { consumeSseStreamEffect, eventsFromSseData, sseFrames } from './sse.js';
+class LoomsClientError extends Data.TaggedError('LoomsClientError') {
+    constructor(message, cause) {
+        super({ cause, message });
+        this.name = 'LoomsClientError';
+    }
+}
+const decodeStreamError = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ error: Schema.String })));
+const StartResultSchema = Schema.Struct({
+    runId: Schema.String,
+    threadId: Schema.String,
+    state: RunStateSchema,
+});
+const RunResultSchema = Schema.Struct({ runId: Schema.String, state: RunStateSchema });
+const EventsResultSchema = Schema.Struct({
+    runId: Schema.String,
+    events: Schema.Array(EventEnvelopeSchema),
+});
+const ReplayResultSchema = Schema.Struct({
+    runId: Schema.String,
+    step: Schema.NullOr(ReplayStepSchema),
+});
+const ProjectionResultSchema = Schema.Struct({
+    runId: Schema.String,
+    name: Schema.String,
+    value: Schema.Unknown,
+});
 export function createLoomsClient(options = {}) {
     const baseUrl = (options.baseUrl ?? '').replace(/\/$/, '');
     const fetchImpl = options.fetch ?? fetch;
-    async function request(path, init) {
+    function request(path, schema, init) {
         const headers = new Headers(init?.headers);
         if (!headers.has('content-type')) {
             headers.set('content-type', 'application/json');
         }
-        const res = await fetchImpl(`${baseUrl}${path}`, { ...init, headers });
-        if (!res.ok) {
-            const body = await res.text();
-            throw new Error(body || `HTTP ${res.status}`);
-        }
-        // SAFETY: host JSON responses match the generic requested by each route helper.
-        return (await res.json());
+        return Effect.runPromise(Effect.gen(function* () {
+            const res = yield* Effect.tryPromise({
+                try: (signal) => fetchImpl(`${baseUrl}${path}`, { ...init, headers, signal }),
+                catch: (cause) => new LoomsClientError('Request failed', cause),
+            });
+            if (!res.ok) {
+                const body = yield* Effect.promise(() => res.text());
+                return yield* new LoomsClientError(body || `HTTP ${res.status}`);
+            }
+            const body = yield* Effect.promise(() => res.json());
+            return yield* Schema.decodeUnknownEffect(schema)(body).pipe(Effect.mapError((cause) => new LoomsClientError('Invalid response body', cause)));
+        }));
     }
     const subscribeEvents = (runId, onEvent, reconnectDelayMs = 1_000) => {
         let fromSeq = 1;
         const controller = new AbortController();
-        const run = async () => {
+        const run = Effect.gen(function* () {
             while (!controller.signal.aborted) {
-                try {
+                yield* Effect.gen(function* () {
                     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 = await fetchImpl(`${baseUrl}/api/events?runId=${encodeURIComponent(runId)}&live=true&cursor=${cursor}`, { headers, signal: controller.signal });
-                    if (!res.ok || !res.body) {
-                        throw new Error(res.ok ? 'event stream missing body' : `HTTP ${res.status}`);
-                    }
-                    await consumeSseStream(res.body, (frame) => {
-                        for (const event of eventsFromSseData(frame.data, runId)) {
-                            onEvent(event);
-                            fromSeq = Math.max(fromSeq, event.seq + 1);
-                        }
-                    }, controller.signal);
-                }
-                catch {
-                    if (controller.signal.aborted) {
-                        return;
+                    const res = yield* Effect.tryPromise({
+                        try: (signal) => fetchImpl(`${baseUrl}/runs/${encodeURIComponent(runId)}/events?fromSeq=${fromSeq}`, {
+                            headers,
+                            signal,
+                        }),
+                        catch: (cause) => new LoomsClientError('Event subscription failed', cause),
+                    });
+                    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);
+                            }
+                        });
                     }
-                }
+                    return yield* new LoomsClientError(res.ok ? 'event stream missing body' : `HTTP ${res.status}`);
+                }).pipe(Effect.ignore);
                 if (controller.signal.aborted) {
-                    return;
+                    break;
                 }
-                await delay(reconnectDelayMs, controller.signal);
+                yield* Effect.sleep(reconnectDelayMs);
             }
-        };
-        void run();
+        });
+        void Effect.runPromise(run, { signal: controller.signal }).catch(() => undefined);
         return () => {
             controller.abort();
         };
     };
-    const startRun = (args) => request('/runs', { method: 'POST', body: JSON.stringify(args) });
+    const startRun = (args) => request('/runs', StartResultSchema, { method: 'POST', body: stringifyJson(args) });
+    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, {
+            method: 'POST',
+            headers: options.workerCallbackToken
+                ? { authorization: `Bearer ${options.workerCallbackToken}` }
+                : undefined,
+            body: stringifyJson(body),
+        });
+    };
     const streamRun = (args) => {
         const runId = args.runId ?? createRunId();
-        return {
-            runId,
-            async *[Symbol.asyncIterator]() {
-                const controller = new AbortController();
-                const res = await fetchImpl(`${baseUrl}/runs`, {
-                    method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        accept: 'text/event-stream',
-                    },
-                    body: JSON.stringify({ ...args, runId }),
-                    signal: controller.signal,
-                });
-                if (!res.ok || !res.body) {
-                    throw new Error(res.ok ? 'SSE stream missing body' : `HTTP ${res.status}`);
-                }
-                const pending = [];
-                let notify;
-                let finished = false;
-                let streamError;
-                const consume = consumeSseStream(res.body, (frame) => {
-                    if (frame.event === 'error') {
-                        try {
-                            const parsed = JSON.parse(frame.data);
-                            const message = Predicate.isReadonlyObject(parsed) && Predicate.isString(parsed.error)
-                                ? parsed.error
-                                : frame.data;
-                            streamError = new Error(message);
-                        }
-                        catch {
-                            streamError = new Error(frame.data);
-                        }
-                        return;
-                    }
-                    if (frame.event === 'done') {
-                        finished = true;
-                        notify?.();
-                        return;
-                    }
-                    for (const event of eventsFromSseData(frame.data, runId)) {
-                        pending.push(event);
-                    }
-                    notify?.();
-                }, controller.signal)
-                    .catch((cause) => {
-                    streamError = cause instanceof Error ? cause : new Error(String(cause));
-                })
-                    .finally(() => {
-                    finished = true;
-                    notify?.();
-                });
-                try {
-                    while (true) {
-                        if (pending.length === 0) {
-                            if (finished) {
-                                break;
-                            }
-                            await new Promise((resolve) => {
-                                notify = resolve;
-                            });
-                            continue;
-                        }
-                        const event = pending.shift();
-                        if (event) {
-                            yield event;
-                        }
-                    }
-                    await consume;
-                    if (streamError) {
-                        throw streamError;
-                    }
-                }
-                finally {
-                    controller.abort();
-                }
-            },
-        };
+        const stream = Stream.unwrap(Effect.tryPromise({
+            try: (signal) => fetchImpl(`${baseUrl}/runs`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'text/event-stream',
+                },
+                body: stringifyJson({ ...args, runId }),
+                signal,
+            }),
+            catch: (cause) => new LoomsClientError('Failed to start event stream', cause),
+        }).pipe(Effect.flatMap((res) => res.ok && res.body
+            ? Effect.succeed(sseFrames(res.body))
+            : new LoomsClientError(res.ok ? 'SSE stream missing body' : `HTTP ${res.status}`)))).pipe(Stream.takeWhile((frame) => frame.event !== 'done'), Stream.mapEffect((frame) => {
+            if (frame.event !== 'error') {
+                return Effect.succeed(eventsFromSseData(frame.data, runId));
+            }
+            const decoded = decodeStreamError(frame.data);
+            return new LoomsClientError(Option.isSome(decoded) ? decoded.value.error : frame.data);
+        }), Stream.flatMap(Stream.fromIterable));
+        return Object.assign(Stream.toAsyncIterable(stream), { runId });
     };
     return {
         /** Start a run by `{ kind, definitionName }` when you only have names. */
         startRun,
         /** Start a run from a definition object (agent, workflow, or your own kind). */
-        start: (definition, input) => request('/runs', {
+        start: (definition, input) => request('/runs', StartResultSchema, {
             method: 'POST',
-            body: JSON.stringify({ kind: definition.kind, definitionName: definition.name, input }),
+            body: stringifyJson({
+                kind: definition.kind,
+                definitionName: definition.name,
+                definitionVersion: definition.version,
+                input,
+            }),
         }),
-        getRun: (runId) => request(`/runs/${runId}`),
-        getState: (runId) => request(`/runs/${runId}`),
+        getRun: (runId) => request(`/runs/${encodeURIComponent(runId)}`, RunResultSchema),
+        getState: (runId) => request(`/runs/${encodeURIComponent(runId)}`, RunResultSchema),
         getEvents: (runId, opts) => {
             const params = new URLSearchParams();
             if (opts?.fromSeq !== undefined) {
@@ -155,15 +151,18 @@ export function createLoomsClient(options = {}) {
                 params.set('limit', String(opts.limit));
             }
             const q = params.toString();
-            return request(`/runs/${runId}/events${q ? `?${q}` : ''}`);
+            return request(`/runs/${encodeURIComponent(runId)}/events${q ? `?${q}` : ''}`, EventsResultSchema);
         },
-        signal: (runId, events) => request(`/runs/${runId}/events`, {
+        signal: (runId, events) => request(`/runs/${encodeURIComponent(runId)}/events`, RunResultSchema, {
             method: 'POST',
-            body: JSON.stringify({ events }),
+            body: stringifyJson({ events }),
         }),
-        wake: (runId) => request(`/runs/${runId}/wake`, { method: 'POST' }),
-        replayTo: (runId, seq) => request(`/runs/${runId}/replay?seq=${seq}`),
-        project: (runId, name) => request(`/runs/${runId}/projections/${name}`),
+        wake: (runId) => request(`/runs/${encodeURIComponent(runId)}/wake`, RunResultSchema, { method: 'POST' }),
+        workerCallback,
+        listRunSummaries: () => request('/runs/summaries', RunSummariesSchema),
+        listDefinitions: () => request('/definitions', DefinitionCatalogSchema),
+        replayTo: (runId, seq) => request(`/runs/${encodeURIComponent(runId)}/replay?seq=${seq}`, ReplayResultSchema),
+        project: (runId, name) => request(`/runs/${encodeURIComponent(runId)}/projections/${encodeURIComponent(name)}`, ProjectionResultSchema),
         subscribeEvents,
         /**
          * Subscribe to the run log, then start execution so deltas arrive live.
@@ -173,6 +172,7 @@ export function createLoomsClient(options = {}) {
         stream: (definition, input) => streamRun({
             kind: definition.kind,
             definitionName: definition.name,
+            definitionVersion: definition.version,
             input,
         }),
     };

package/dist/client/index.d.ts

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

package/dist/client/index.js

@@ -1,2 +1,2 @@
 export { createLoomsClient, } from './client.js';
-export { consumeSseStream, delay, eventsFromSseData, parseSseFrame } from './sse.js';
+export { consumeSseStream, consumeSseStreamEffect, delay, eventsFromSseData, parseSseFrame, } from './sse.js';

package/dist/client/sse.d.ts

@@ -1,3 +1,4 @@
+import { Effect, Stream } from 'effect';
 import { type EventEnvelope } from '@swirls/looms/core';
 export interface SseFrame {
     id?: string;
@@ -5,6 +6,18 @@ export interface SseFrame {
     data: string;
 }
 export declare function parseSseFrame(raw: string): SseFrame | undefined;
+declare const SseStreamError_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: "SseStreamError";
+} & Readonly<A>;
+export declare class SseStreamError extends SseStreamError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+    constructor(cause: unknown);
+}
+export declare function consumeSseStreamEffect(body: ReadableStream<Uint8Array>, onFrame: (frame: SseFrame) => void): 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[];
 export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+export {};

package/dist/client/sse.js

@@ -1,5 +1,6 @@
-import { Predicate } from 'effect';
+import { Data, Effect, Option, Predicate, Queue, Schema, Stream } from 'effect';
 import { decodeLoomsEvent } from '@swirls/looms/core';
+const decodeSseData = Schema.decodeOption(Schema.fromJsonString(Schema.Unknown));
 export function parseSseFrame(raw) {
     let id;
     let event;
@@ -25,20 +26,24 @@ export function parseSseFrame(raw) {
     }
     return { id, event, data: dataLines.join('\n') };
 }
-export async function consumeSseStream(body, onFrame, signal) {
-    const reader = body.getReader();
+export class SseStreamError extends Data.TaggedError('SseStreamError') {
+    constructor(cause) {
+        super({
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'SseStreamError';
+    }
+}
+export function consumeSseStreamEffect(body, onFrame) {
     const decoder = new TextDecoder();
-    let buffer = '';
-    const abort = () => {
-        void reader.cancel();
-    };
-    signal?.addEventListener('abort', abort);
-    try {
+    return Effect.acquireUseRelease(Effect.sync(() => body.getReader()), (reader) => Effect.gen(function* () {
+        let buffer = '';
         while (true) {
-            if (signal?.aborted) {
-                break;
-            }
-            const { done, value } = await reader.read();
+            const { done, value } = yield* Effect.tryPromise({
+                try: () => reader.read(),
+                catch: (cause) => new SseStreamError(cause),
+            });
             if (done) {
                 break;
             }
@@ -52,35 +57,31 @@ export async function consumeSseStream(body, onFrame, signal) {
                 }
             }
         }
-    }
-    finally {
-        signal?.removeEventListener('abort', abort);
-        try {
-            reader.releaseLock();
-        }
-        catch {
-            // reader already cancelled
-        }
-    }
+    }), (reader) => Effect.promise(() => reader.cancel()).pipe(Effect.ignore, Effect.ensuring(Effect.sync(() => reader.releaseLock()).pipe(Effect.ignore))));
+}
+export function sseFrames(body) {
+    return Stream.callback((queue) => consumeSseStreamEffect(body, (frame) => {
+        Queue.offerUnsafe(queue, frame);
+    }).pipe(Effect.tap(() => Effect.sync(() => {
+        Queue.endUnsafe(queue);
+    }))));
+}
+export function consumeSseStream(body, onFrame, signal) {
+    return Effect.runPromise(consumeSseStreamEffect(body, onFrame), { signal });
 }
 export function eventsFromSseData(data, runId) {
-    let parsed;
-    try {
-        parsed = JSON.parse(data);
-    }
-    catch {
+    const parsed = decodeSseData(data);
+    if (Option.isNone(parsed)) {
         return [];
     }
-    if (!Predicate.isReadonlyObject(parsed)) {
+    if (!Predicate.isReadonlyObject(parsed.value)) {
         return [];
     }
-    const batch = 'batch' in parsed && Array.isArray(parsed.batch) ? parsed.batch : [];
+    const batch = 'batch' in parsed.value && Array.isArray(parsed.value.batch) ? parsed.value.batch : [];
     const events = [];
     for (const item of batch) {
         try {
-            events.push(decodeLoomsEvent(
-            // SAFETY: host SSE batch items are encoded Looms event envelopes.
-            item, runId));
+            events.push(decodeLoomsEvent(item, runId));
         }
         catch {
             // skip a malformed item and keep the rest of the batch
@@ -89,15 +90,8 @@ export function eventsFromSseData(data, runId) {
     return events;
 }
 export function delay(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal?.aborted) {
-            resolve();
-            return;
-        }
-        const timer = setTimeout(resolve, ms);
-        signal?.addEventListener('abort', () => {
-            clearTimeout(timer);
-            resolve();
-        }, { once: true });
-    });
+    if (signal?.aborted) {
+        return Promise.resolve();
+    }
+    return Effect.runPromise(Effect.sleep(ms), { signal }).catch(() => undefined);
 }

package/dist/cloudflare/alarm-scheduler.d.ts

@@ -1,9 +1,19 @@
+import { Effect } from 'effect';
 import type { WakeScheduler } from '@swirls/looms/runtime';
 export interface AlarmStorage {
     setAlarm(scheduledTime: number | Date): Promise<void>;
     deleteAlarm(): Promise<void>;
+    getAlarm?(): Promise<number | null>;
+}
+export interface DurableObjectAlarms {
+    /** Wake scheduler for the runtime; its deadline is remembered across rearms. */
+    readonly scheduler: WakeScheduler;
+    /** Ensures the alarm fires no later than `at` without forgetting the runtime deadline. */
+    readonly scheduleAtEarliest: (at: number) => Effect.Effect<void>;
 }
 /**
- * Adapter that maps actor wake timer scheduling to Cloudflare Durable Object alarms.
+ * The single owner of a Durable Object's one alarm. Every write is serialized and sets the alarm to
+ * the earliest of the runtime deadline, `additionalDeadline` (such as projector retries), and the
+ * requested time, so concurrent writers cannot overwrite each other's deadlines.
  */
-export declare function alarmScheduler(storage: AlarmStorage): WakeScheduler;
+export declare function durableObjectAlarms(storage: AlarmStorage, additionalDeadline?: () => Effect.Effect<number | null>): DurableObjectAlarms;

package/dist/cloudflare/alarm-scheduler.js

@@ -1,13 +1,40 @@
+import { Effect, Semaphore } from 'effect';
+function earliest(...deadlines) {
+    const known = deadlines.filter((deadline) => deadline !== null && deadline !== undefined);
+    return known.length === 0 ? null : Math.min(...known);
+}
 /**
- * Adapter that maps actor wake timer scheduling to Cloudflare Durable Object alarms.
+ * The single owner of a Durable Object's one alarm. Every write is serialized and sets the alarm to
+ * the earliest of the runtime deadline, `additionalDeadline` (such as projector retries), and the
+ * requested time, so concurrent writers cannot overwrite each other's deadlines.
  */
-export function alarmScheduler(storage) {
+export function durableObjectAlarms(storage, additionalDeadline) {
+    // `undefined` until the runtime reports a deadline; until then an existing alarm is preserved.
+    let runtimeDeadline;
+    const writes = Semaphore.makeUnsafe(1);
+    const rearm = (requested) => Semaphore.withPermits(writes, 1, Effect.gen(function* () {
+        const [additional, current] = yield* Effect.all([
+            additionalDeadline?.() ?? Effect.succeed(null),
+            Effect.promise(() => storage.getAlarm?.() ?? Promise.resolve(null)),
+        ], { concurrency: 'unbounded' });
+        const preserved = runtimeDeadline === undefined ? current : null;
+        const desired = earliest(runtimeDeadline, additional, requested, preserved);
+        if (desired === current) {
+            return;
+        }
+        yield* Effect.promise(() => desired === null ? storage.deleteAlarm() : storage.setAlarm(desired));
+    }));
     return {
-        schedule: async (_runId, at) => {
-            await storage.setAlarm(at);
-        },
-        cancel: async (_runId) => {
-            await storage.deleteAlarm();
+        scheduler: {
+            schedule: (_runId, at) => Effect.suspend(() => {
+                runtimeDeadline = at;
+                return rearm(null);
+            }),
+            cancel: () => Effect.suspend(() => {
+                runtimeDeadline = null;
+                return rearm(null);
+            }),
         },
+        scheduleAtEarliest: rearm,
     };
 }

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

@@ -1,14 +1,19 @@
 import { DurableObject } from 'cloudflare:workers';
-import type { AnyRuntimeModule } from '@swirls/looms/core';
+import type { AnyRuntimeModule, EventStoreTrimCoverage } from '@swirls/looms/core';
 import type { Projector } from '@swirls/looms/projectors';
+import type { Authorize } from '@swirls/looms/runtime';
 export interface LoomsDurableObjectConfig {
     readonly modules: readonly AnyRuntimeModule[];
     readonly projectors?: readonly Projector[];
     readonly snapshotEvery?: number;
     readonly maxWakeIterations?: number;
+    readonly maxPendingRunOperations?: number;
     readonly trimAfterSnapshot?: {
-        keepSnapshots: number;
+        readonly keepSnapshots: number;
+        readonly coverage?: (runId: string) => EventStoreTrimCoverage | Promise<EventStoreTrimCoverage>;
     };
+    /** Authorizes the actor's HTTP API; see `createFetchHandler`. */
+    readonly authorize?: Authorize;
 }
 /**
  * Base Durable Object class for hosting a Looms actor cell.
@@ -17,8 +22,11 @@ export interface LoomsDurableObjectConfig {
  */
 export declare abstract class LoomsDurableObject<Env = unknown> extends DurableObject<Env> {
     private cellPromise?;
+    private store?;
     abstract configure(env: Env): LoomsDurableObjectConfig | Promise<LoomsDurableObjectConfig>;
     private getCell;
+    private createCell;
     fetch(req: Request): Promise<Response>;
+    /** A rejected alarm is retried by the platform with backoff, so failures just propagate. */
     alarm(): Promise<void>;
 }

package/dist/cloudflare/durable-object.js

@@ -1,6 +1,7 @@
 import { DurableObject } from 'cloudflare:workers';
+import { Effect } from 'effect';
 import { createActorCell } from '@swirls/looms/actor';
-import { alarmScheduler } from './alarm-scheduler.js';
+import { durableObjectAlarms } from './alarm-scheduler.js';
 import { durableObjectEventStore } from './event-store.js';
 /**
  * Base Durable Object class for hosting a Looms actor cell.
@@ -9,35 +10,65 @@ import { durableObjectEventStore } from './event-store.js';
  */
 export class LoomsDurableObject extends DurableObject {
     cellPromise;
-    async getCell() {
-        if (!this.cellPromise) {
-            this.cellPromise = (async () => {
-                const runId = this.ctx.id.name;
-                if (!runId) {
-                    throw new Error('LoomsDurableObject requires a named Durable Object id (use idFromName / getByName)');
-                }
-                const config = await this.configure(this.env);
-                const store = durableObjectEventStore(this.ctx, { projectors: config.projectors });
-                const scheduler = alarmScheduler(this.ctx.storage);
-                return createActorCell({
-                    runId,
-                    store,
-                    scheduler,
-                    modules: config.modules,
-                    snapshotEvery: config.snapshotEvery,
-                    maxWakeIterations: config.maxWakeIterations,
-                    trimAfterSnapshot: config.trimAfterSnapshot,
-                });
-            })();
+    store;
+    getCell() {
+        if (this.cellPromise) {
+            return this.cellPromise;
         }
-        return this.cellPromise;
+        const created = this.createCell();
+        this.cellPromise = created;
+        // A failed setup must not be cached, or every later request and alarm would fail with it.
+        created.catch(() => {
+            if (this.cellPromise === created) {
+                this.cellPromise = undefined;
+            }
+        });
+        return created;
     }
-    async fetch(req) {
-        const cell = await this.getCell();
-        return cell.fetch(req);
+    createCell() {
+        return Promise.resolve(this.configure(this.env)).then((config) => {
+            const runId = this.ctx.id.name;
+            if (!runId) {
+                throw new Error('LoomsDurableObject requires a named Durable Object id (use idFromName / getByName)');
+            }
+            const alarms = durableObjectAlarms(this.ctx.storage, () => this.store?.projectorDelivery?.nextRetryAt(runId).pipe(Effect.orDie) ??
+                Effect.succeed(null));
+            const store = durableObjectEventStore(this.ctx, {
+                projectors: config.projectors,
+                scheduleProjectorRetry: alarms.scheduleAtEarliest,
+            });
+            this.store = store;
+            const cell = createActorCell({
+                runId,
+                store,
+                scheduler: alarms.scheduler,
+                modules: config.modules,
+                snapshotEvery: config.snapshotEvery,
+                maxWakeIterations: config.maxWakeIterations,
+                maxPendingRunOperations: config.maxPendingRunOperations,
+                trimAfterSnapshot: config.trimAfterSnapshot,
+                authorize: config.authorize,
+            });
+            const delivery = store.projectorDelivery;
+            const recoverProjectors = delivery
+                ? Effect.runPromise(delivery.recover(runId).pipe(Effect.andThen(delivery.deliver(runId))))
+                : Promise.resolve();
+            return recoverProjectors.then(() => cell.recoverWake()).then(() => cell);
+        });
     }
-    async alarm() {
-        const cell = await this.getCell();
-        await cell.wake();
+    fetch(req) {
+        return this.getCell().then((cell) => cell.fetch(req));
+    }
+    /** A rejected alarm is retried by the platform with backoff, so failures just propagate. */
+    alarm() {
+        return this.getCell()
+            .then((cell) => {
+            const delivery = this.store?.projectorDelivery;
+            const delivered = delivery
+                ? Effect.runPromise(delivery.deliver(this.ctx.id.name ?? ''))
+                : Promise.resolve();
+            return delivered.then(() => cell.wake());
+        })
+            .then(() => undefined);
     }
 }