@swirls/looms 0.0.1

package/dist/cli/commands.js

@@ -0,0 +1,133 @@
+import { Config, Console, Effect, FileSystem, Layer, Option, Path, Queue, Stdio, Stream, Terminal, } from 'effect';
+import { Argument, CliError, Command, Flag } from 'effect/unstable/cli';
+import { ChildProcessSpawner } from 'effect/unstable/process';
+import { steer as steerEvent } from '@swirls/looms/agent';
+import { decision } from '@swirls/looms/approval';
+import { createLoomsClient } from '@swirls/looms/client';
+import { createLooms } from '@swirls/looms/runtime';
+const VERSION = '0.0.1';
+const urlFlag = Flag.string('url').pipe(Flag.withDescription('Looms host base URL (env LOOMS_URL)'), Flag.withFallbackConfig(Config.string('LOOMS_URL')), Flag.withDefault('http://127.0.0.1:8787'), Flag.map((url) => url.replace(/\/$/, '')));
+function parseJsonArg(raw) {
+    if (Option.isNone(raw) || raw.value === '') {
+        return null;
+    }
+    try {
+        // SAFETY: CLI JSON args decode to JsonValue; parse failures fall back to the raw string
+        return JSON.parse(raw.value);
+    }
+    catch {
+        return raw.value;
+    }
+}
+function clientFor(url) {
+    return createLoomsClient({ baseUrl: url });
+}
+function tryClient(run) {
+    return Effect.tryPromise({
+        try: run,
+        catch: (error) => new CliError.UserError({
+            cause: error,
+            userMessage: error instanceof Error ? error.message : String(error),
+        }),
+    });
+}
+const serve = Command.make('serve', {
+    port: Flag.integer('port').pipe(Flag.withDescription('Port to listen on (env PORT)'), Flag.withFallbackConfig(Config.int('PORT')), Flag.withDefault(8787)),
+}, Effect.fn('serve')(function* ({ port }) {
+    const looms = createLooms();
+    const server = looms.serve({ port });
+    yield* Console.log(`Looms runtime listening on http://127.0.0.1:${server?.port ?? port}`);
+    return yield* Effect.never;
+})).pipe(Command.withDescription('Start the Looms runtime host'), Command.withShortDescription('Start the runtime'));
+const loomsBase = Command.make('looms').pipe(Command.withDescription('Looms thread runtime'), Command.withSharedFlags({ url: urlFlag }));
+const start = Command.make('start', {
+    kind: Argument.string('kind').pipe(Argument.withDescription('Thread kind (e.g. agent, workflow)')),
+    name: Argument.string('name').pipe(Argument.withDescription('Definition name')),
+    json: Argument.string('json').pipe(Argument.withDescription('Optional JSON input'), Argument.optional),
+}, Effect.fn('start')(function* ({ kind, name, json }) {
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).startRun({ kind, definitionName: name, input: parseJsonArg(json) }));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('Start a run from a registered definition: looms start agent echo \'{"text":"hi"}\''), Command.withShortDescription('Start a run'));
+const events = Command.make('events', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+}, Effect.fn('events')(function* ({ runId }) {
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).getEvents(runId));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('List events for a run'), Command.withShortDescription('List run events'));
+const state = Command.make('state', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+}, Effect.fn('state')(function* ({ runId }) {
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).getRun(runId));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('Show run state'), Command.withShortDescription('Show run state'));
+const approve = Command.make('approve', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+    approvalId: Argument.string('approvalId').pipe(Argument.withDescription('Pending approval id')),
+    accept: Flag.boolean('approve').pipe(Flag.withAlias('a'), Flag.withDescription('Approve the request'), Flag.withDefault(false)),
+    reject: Flag.boolean('reject').pipe(Flag.withAlias('r'), Flag.withDescription('Reject the request'), Flag.withDefault(false)),
+}, Effect.fn('approve')(function* ({ runId, approvalId, accept, reject }) {
+    if (accept === reject) {
+        return yield* new CliError.UserError({
+            cause: new Error('Specify exactly one of --approve or --reject'),
+            userMessage: 'Specify exactly one of --approve or --reject',
+        });
+    }
+    const outcome = accept ? 'approve' : 'reject';
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).signal(runId, [decision(approvalId, outcome)]));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('Approve or reject a pending approval'), Command.withShortDescription('Decide an approval'));
+const replay = Command.make('replay', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+    seq: Argument.integer('seq').pipe(Argument.withDescription('Event sequence to replay through')),
+}, Effect.fn('replay')(function* ({ runId, seq }) {
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).replayTo(runId, seq));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('Replay a run to a sequence'), Command.withShortDescription('Replay to seq'));
+const signal = Command.make('signal', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+    type: Argument.string('type').pipe(Argument.withDescription('Event type')),
+    json: Argument.string('json').pipe(Argument.withDescription('Optional JSON payload'), Argument.optional),
+}, Effect.fn('signal')(function* ({ runId, type, json }) {
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).signal(runId, [{ type, payload: parseJsonArg(json) }]));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('Append an external event and wake the run'), Command.withShortDescription('Signal a run'));
+const steer = Command.make('steer', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+    message: Argument.string('message').pipe(Argument.withDescription('Steering message'), Argument.variadic({ min: 1 })),
+    interrupt: Flag.boolean('interrupt').pipe(Flag.withDescription('Interrupt the current turn (use --no-interrupt to disable)'), Flag.withDefault(true)),
+}, Effect.fn('steer')(function* ({ runId, message, interrupt }) {
+    const { url } = yield* loomsBase;
+    const result = yield* tryClient(() => clientFor(url).signal(runId, [steerEvent(message.join(' '), { interrupt })]));
+    yield* Console.log(JSON.stringify(result, null, 2));
+})).pipe(Command.withDescription('Send a steering message to a running agent'), Command.withShortDescription('Steer an agent'));
+const tail = Command.make('tail', {
+    runId: Argument.string('runId').pipe(Argument.withDescription('Run id')),
+}, Effect.fn('tail')(function* ({ runId }) {
+    const { url } = yield* loomsBase;
+    const client = clientFor(url);
+    yield* Console.log(`Tailing ${runId} (ctrl-c to stop)`);
+    yield* Effect.scoped(Effect.gen(function* () {
+        const queue = yield* Queue.unbounded();
+        yield* Effect.acquireRelease(Effect.sync(() => client.subscribeEvents(runId, (event) => {
+            Queue.offerUnsafe(queue, JSON.stringify(event));
+        })), (stop) => Effect.sync(() => stop()));
+        yield* Stream.fromQueue(queue).pipe(Stream.runForEach((line) => Console.log(line)));
+    }));
+})).pipe(Command.withDescription('Stream events for a run'), Command.withShortDescription('Tail run events'));
+export const looms = loomsBase.pipe(Command.withSubcommands([serve, start, events, state, approve, replay, signal, steer, tail]));
+export const cliTestLayer = Layer.mergeAll(FileSystem.layerNoop({}), Path.layer, Stdio.layerTest({}), Layer.succeed(Terminal.Terminal, Terminal.make({
+    columns: Effect.succeed(80),
+    rows: Effect.succeed(24),
+    readInput: Effect.die('unused'),
+    readLine: Effect.die('unused'),
+    display: () => Effect.void,
+})), Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, ChildProcessSpawner.make(() => Effect.die('unused'))));
+/** Run the CLI with an explicit argv (for tests and programmatic use). */
+export const runCli = (argv) => Command.runWith(looms, { version: VERSION })(argv);
+export { VERSION };

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export { runCli, looms, VERSION, cliTestLayer } from './commands';

package/dist/cli/index.js

@@ -0,0 +1 @@
+export { runCli, looms, VERSION, cliTestLayer } from './commands.js';

package/dist/client/client.d.ts

@@ -0,0 +1,69 @@
+import { type DefinitionInput, type DefinitionRef, type EventEnvelope, type EventInput, type JsonValue, type RunState } from '@swirls/looms/core';
+export interface LoomsClientOptions {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+export interface StartResult {
+    runId: string;
+    threadId: string;
+    state: RunState;
+}
+export interface StreamHandle extends AsyncIterable<EventEnvelope> {
+    readonly runId: string;
+}
+export declare function createLoomsClient(options?: LoomsClientOptions): {
+    /** Start a run by `{ kind, definitionName }` when you only have names. */
+    startRun: (args: {
+        kind: string;
+        definitionName: string;
+        input?: JsonValue;
+        runId?: string;
+    }) => Promise<StartResult>;
+    /** Start a run from a definition object (agent, workflow, or your own kind). */
+    start: <TDef extends DefinitionRef>(definition: TDef, input?: DefinitionInput<TDef>) => Promise<StartResult>;
+    getRun: (runId: string) => Promise<{
+        runId: string;
+        state: RunState;
+    }>;
+    getState: (runId: string) => Promise<{
+        runId: string;
+        state: RunState;
+    }>;
+    getEvents: (runId: string, opts?: {
+        fromSeq?: number;
+        limit?: number;
+    }) => Promise<{
+        runId: string;
+        events: EventEnvelope[];
+    }>;
+    signal: (runId: string, events: ReadonlyArray<EventInput>) => Promise<{
+        runId: string;
+        state: RunState;
+    }>;
+    wake: (runId: string) => Promise<{
+        runId: string;
+        state: RunState;
+    }>;
+    replayTo: (runId: string, seq: number) => Promise<{
+        runId: string;
+        step: unknown;
+    }>;
+    project: (runId: string, name: string) => Promise<{
+        runId: string;
+        name: string;
+        value: unknown;
+    }>;
+    subscribeEvents: (runId: string, onEvent: (event: EventEnvelope) => void, reconnectDelayMs?: number) => () => void;
+    /**
+     * Subscribe to the run log, then start execution so deltas arrive live.
+     * Yields events in store order, including live module events such as `agent.turn.text_delta`.
+     */
+    streamRun: (args: {
+        kind: string;
+        definitionName: string;
+        input?: JsonValue;
+        runId?: string;
+    }) => StreamHandle;
+    stream: <TDef extends DefinitionRef>(definition: TDef, input?: DefinitionInput<TDef>) => StreamHandle;
+};
+export type LoomsClient = ReturnType<typeof createLoomsClient>;

package/dist/client/client.js

@@ -0,0 +1,179 @@
+import { Predicate } from 'effect';
+import { createRunId, } from '@swirls/looms/core';
+import { consumeSseStream, delay, eventsFromSseData } from './sse.js';
+export function createLoomsClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? '').replace(/\/$/, '');
+    const fetchImpl = options.fetch ?? fetch;
+    async function request(path, 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());
+    }
+    const subscribeEvents = (runId, onEvent, reconnectDelayMs = 1_000) => {
+        let fromSeq = 1;
+        const controller = new AbortController();
+        const run = async () => {
+            while (!controller.signal.aborted) {
+                try {
+                    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;
+                    }
+                }
+                if (controller.signal.aborted) {
+                    return;
+                }
+                await delay(reconnectDelayMs, controller.signal);
+            }
+        };
+        void run();
+        return () => {
+            controller.abort();
+        };
+    };
+    const startRun = (args) => request('/runs', { method: 'POST', body: JSON.stringify(args) });
+    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();
+                }
+            },
+        };
+    };
+    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', {
+            method: 'POST',
+            body: JSON.stringify({ kind: definition.kind, definitionName: definition.name, input }),
+        }),
+        getRun: (runId) => request(`/runs/${runId}`),
+        getState: (runId) => request(`/runs/${runId}`),
+        getEvents: (runId, opts) => {
+            const params = new URLSearchParams();
+            if (opts?.fromSeq !== undefined) {
+                params.set('fromSeq', String(opts.fromSeq));
+            }
+            if (opts?.limit !== undefined) {
+                params.set('limit', String(opts.limit));
+            }
+            const q = params.toString();
+            return request(`/runs/${runId}/events${q ? `?${q}` : ''}`);
+        },
+        signal: (runId, events) => request(`/runs/${runId}/events`, {
+            method: 'POST',
+            body: JSON.stringify({ 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}`),
+        subscribeEvents,
+        /**
+         * Subscribe to the run log, then start execution so deltas arrive live.
+         * Yields events in store order, including live module events such as `agent.turn.text_delta`.
+         */
+        streamRun,
+        stream: (definition, input) => streamRun({
+            kind: definition.kind,
+            definitionName: definition.name,
+            input,
+        }),
+    };
+}

package/dist/client/index.d.ts

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

package/dist/client/index.js

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

package/dist/client/sse.d.ts

@@ -0,0 +1,10 @@
+import { type EventEnvelope } from '@swirls/looms/core';
+export interface SseFrame {
+    id?: string;
+    event?: string;
+    data: string;
+}
+export declare function parseSseFrame(raw: string): SseFrame | undefined;
+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>;

package/dist/client/sse.js

@@ -0,0 +1,103 @@
+import { Predicate } from 'effect';
+import { decodeLoomsEvent } from '@swirls/looms/core';
+export function parseSseFrame(raw) {
+    let id;
+    let event;
+    const dataLines = [];
+    for (const line of raw.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n')) {
+        if (line.startsWith(':')) {
+            continue;
+        }
+        if (line.startsWith('id:')) {
+            id = line.slice(3).trim();
+            continue;
+        }
+        if (line.startsWith('event:')) {
+            event = line.slice(6).trim();
+            continue;
+        }
+        if (line.startsWith('data:')) {
+            dataLines.push(line.slice(5).trimStart());
+        }
+    }
+    if (dataLines.length === 0) {
+        return undefined;
+    }
+    return { id, event, data: dataLines.join('\n') };
+}
+export async function consumeSseStream(body, onFrame, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const abort = () => {
+        void reader.cancel();
+    };
+    signal?.addEventListener('abort', abort);
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                break;
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const chunks = buffer.split('\n\n');
+            buffer = chunks.pop() ?? '';
+            for (const chunk of chunks) {
+                const frame = parseSseFrame(chunk);
+                if (frame) {
+                    onFrame(frame);
+                }
+            }
+        }
+    }
+    finally {
+        signal?.removeEventListener('abort', abort);
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // reader already cancelled
+        }
+    }
+}
+export function eventsFromSseData(data, runId) {
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+    if (!Predicate.isReadonlyObject(parsed)) {
+        return [];
+    }
+    const batch = 'batch' in parsed && Array.isArray(parsed.batch) ? parsed.batch : [];
+    const events = [];
+    for (const item of batch) {
+        try {
+            events.push(decodeLoomsEvent(
+            // SAFETY: host SSE batch items are encoded Looms event envelopes.
+            item, runId));
+        }
+        catch {
+            // skip a malformed item and keep the rest of the batch
+        }
+    }
+    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 });
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { WakeScheduler } from '@swirls/looms/runtime';
+export interface AlarmStorage {
+    setAlarm(scheduledTime: number | Date): Promise<void>;
+    deleteAlarm(): Promise<void>;
+}
+/**
+ * Adapter that maps actor wake timer scheduling to Cloudflare Durable Object alarms.
+ */
+export declare function alarmScheduler(storage: AlarmStorage): WakeScheduler;

package/dist/cloudflare/alarm-scheduler.js

@@ -0,0 +1,13 @@
+/**
+ * Adapter that maps actor wake timer scheduling to Cloudflare Durable Object alarms.
+ */
+export function alarmScheduler(storage) {
+    return {
+        schedule: async (_runId, at) => {
+            await storage.setAlarm(at);
+        },
+        cancel: async (_runId) => {
+            await storage.deleteAlarm();
+        },
+    };
+}

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

@@ -0,0 +1,24 @@
+import { DurableObject } from 'cloudflare:workers';
+import type { AnyRuntimeModule } from '@swirls/looms/core';
+import type { Projector } from '@swirls/looms/projectors';
+export interface LoomsDurableObjectConfig {
+    readonly modules: readonly AnyRuntimeModule[];
+    readonly projectors?: readonly Projector[];
+    readonly snapshotEvery?: number;
+    readonly maxWakeIterations?: number;
+    readonly trimAfterSnapshot?: {
+        keepSnapshots: number;
+    };
+}
+/**
+ * Base Durable Object class for hosting a Looms actor cell.
+ * Subclasses implement `configure(env)` to supply configured modules.
+ * Works identically on Cloudflare Workers and celld.
+ */
+export declare abstract class LoomsDurableObject<Env = unknown> extends DurableObject<Env> {
+    private cellPromise?;
+    abstract configure(env: Env): LoomsDurableObjectConfig | Promise<LoomsDurableObjectConfig>;
+    private getCell;
+    fetch(req: Request): Promise<Response>;
+    alarm(): Promise<void>;
+}

package/dist/cloudflare/durable-object.js

@@ -0,0 +1,43 @@
+import { DurableObject } from 'cloudflare:workers';
+import { createActorCell } from '@swirls/looms/actor';
+import { alarmScheduler } from './alarm-scheduler.js';
+import { durableObjectEventStore } from './event-store.js';
+/**
+ * Base Durable Object class for hosting a Looms actor cell.
+ * Subclasses implement `configure(env)` to supply configured modules.
+ * Works identically on Cloudflare Workers and celld.
+ */
+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,
+                });
+            })();
+        }
+        return this.cellPromise;
+    }
+    async fetch(req) {
+        const cell = await this.getCell();
+        return cell.fetch(req);
+    }
+    async alarm() {
+        const cell = await this.getCell();
+        await cell.wake();
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { EventStore } from '@swirls/looms/core';
+import { type Projector } from '@swirls/looms/projectors';
+export interface DurableObjectStoreOptions {
+    readonly projectors?: readonly Projector[];
+}
+/**
+ * Creates an EventStore backed by a Durable Object's embedded SQLite database (`ctx.storage.sql`).
+ * Optionally attaches asynchronous projectors (such as S2).
+ */
+export declare function durableObjectEventStore(ctx: DurableObjectState, options?: DurableObjectStoreOptions): EventStore;

package/dist/cloudflare/event-store.js

@@ -0,0 +1,18 @@
+import { sqliteEventStore, sqlStorageExec } from '@swirls/looms/core/sqlite-store';
+import { 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).
+ */
+export function durableObjectEventStore(ctx, options = {}) {
+    const store = sqliteEventStore({
+        exec: sqlStorageExec(ctx.storage.sql, {
+            // DO SQLite rejects BEGIN/COMMIT/ROLLBACK; use the storage transaction API.
+            transaction: (fn) => ctx.storage.transactionSync(fn),
+        }),
+    });
+    if (options.projectors && options.projectors.length > 0) {
+        return withProjectors(store, options.projectors);
+    }
+    return store;
+}

package/dist/cloudflare/index.d.ts

@@ -0,0 +1,4 @@
+export { alarmScheduler, type AlarmStorage } from './alarm-scheduler';
+export { durableObjectEventStore, type DurableObjectStoreOptions } from './event-store';
+export { LoomsDurableObject, type LoomsDurableObjectConfig } from './durable-object';
+export { routeToDurableObject, type DurableObjectNamespaceLike, type DurableObjectStubLike, } from './router';

package/dist/cloudflare/index.js

@@ -0,0 +1,4 @@
+export { alarmScheduler } from './alarm-scheduler.js';
+export { durableObjectEventStore } from './event-store.js';
+export { LoomsDurableObject } from './durable-object.js';
+export { routeToDurableObject, } from './router.js';

package/dist/cloudflare/router.d.ts

@@ -0,0 +1,12 @@
+export interface DurableObjectStubLike {
+    fetch(request: Request): Promise<Response>;
+}
+export interface DurableObjectNamespaceLike<T extends DurableObjectStubLike = DurableObjectStubLike> {
+    getByName(name: string): T;
+}
+/**
+ * Routes incoming HTTP requests to the appropriate Durable Object actor cell.
+ * Handles `/health` locally, returns 501 for global `GET /runs`, and forwards
+ * all other run and event-stream requests to `namespace.getByName(runId)`.
+ */
+export declare function routeToDurableObject(namespace: DurableObjectNamespaceLike, req: Request): Promise<Response | null>;