@swirls/looms 0.0.2 → 0.2.0

package/dist/projectors/sqlite.js

@@ -1,5 +1,6 @@
 import { Database } from 'bun:sqlite';
 import { createIndexProjector, } from './index-model.js';
+import { runProjectorSync } from './projector.js';
 import { SQLITE_SCHEMA_SQL } from './schema.js';
 export { SQLITE_SCHEMA_SQL } from './schema.js';
 function hasDb(options) {
@@ -48,39 +49,38 @@ export function sqlite(options = {}) {
     const createdDb = !hasDb(options);
     const db = hasDb(options) ? options.db : new Database(options.path ?? ':memory:');
     const backend = {
-        init: async () => {
+        init: () => runProjectorSync('sqlite', () => {
             db.exec(SQLITE_SCHEMA_SQL);
-        },
-        applyOps: async (ops) => {
+        }),
+        applyOps: (ops) => runProjectorSync('sqlite', () => {
             const apply = db.transaction((batch) => {
                 for (const op of batch) {
                     applyOp(db, op);
                 }
             });
             apply(ops);
-        },
-        getActor: async (actorId) => {
+        }),
+        getActor: (actorId) => runProjectorSync('sqlite', () => {
             const row = db
                 .query(`SELECT actor_id, kind, status, definition_name, parent_actor_id, updated_at
-           FROM looms_actors WHERE actor_id = ?`)
+             FROM looms_actors WHERE actor_id = ?`)
                 .get(actorId);
-            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,
-            };
-        },
-        listReviews: async (actorId) => {
+            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,
+                }
+                : null;
+        }),
+        listReviews: (actorId) => runProjectorSync('sqlite', () => {
             const rows = actorId
                 ? db
                     .query(`SELECT review_id, actor_id, status, title, updated_at
-               FROM looms_reviews WHERE actor_id = ?`)
+                 FROM looms_reviews WHERE actor_id = ?`)
                     .all(actorId)
                 : db
                     .query(`SELECT review_id, actor_id, status, title, updated_at FROM looms_reviews`)
@@ -92,12 +92,12 @@ export function sqlite(options = {}) {
                 title: row.title,
                 updatedAt: row.updated_at,
             }));
-        },
-        dispose: async () => {
+        }),
+        dispose: () => runProjectorSync('sqlite', () => {
             if (createdDb) {
                 db.close();
             }
-        },
+        }),
     };
     return createIndexProjector('sqlite', backend);
 }

package/dist/projectors/with-projectors.d.ts

@@ -1,12 +1,17 @@
 import { Layer } from 'effect';
 import { EventStoreTag, type EventStore, type EventEnvelope } from '@swirls/looms/core';
-import type { Projector, ProjectorErrorHandler } from './projector';
+import type { ProjectorDelivery } from './delivery';
+import { type Projector, type ProjectorErrorHandler } from './projector';
 export interface WithProjectorsOptions {
     onError?: ProjectorErrorHandler;
+    /** Durable cursor runner. When present, appends trigger catch-up from its persisted cursor. */
+    delivery?: ProjectorDelivery;
 }
 /**
  * Wrap an EventStore so every successful append is also projected.
- * Projection failures are isolated so the primary log stays authoritative.
+ * The primary log stays authoritative: once an append commits, projection can never turn it into
+ * a failure. With a durable delivery runner, failures are persisted for retry; without one, they
+ * are reported to `onError` and the projection is skipped.
  */
 export declare function withProjectors(store: EventStore, projectors: ReadonlyArray<Projector>, options?: WithProjectorsOptions): EventStore;
 /** Project events after the fact (e.g. from a runtime hook). */

package/dist/projectors/with-projectors.js

@@ -1,51 +1,50 @@
 import { Effect, Layer } from 'effect';
 import { EventStoreTag, snapshotStoreOf, withSnapshotStore, } from '@swirls/looms/core';
+import { runProjectorEffect } from './projector.js';
 function defaultOnError(error, projector) {
-    console.warn(`[@swirls/looms/projectors] ${projector.name} failed to project: ${error.message}`);
+    Effect.runFork(Effect.logWarning(`[@swirls/looms/projectors] ${projector.name} failed to project`, error));
+}
+function logDeliveryFailure(runId, cause) {
+    return Effect.logWarning(`[@swirls/looms/projectors] delivery for ${runId} failed`, cause);
 }
 /**
  * Wrap an EventStore so every successful append is also projected.
- * Projection failures are isolated so the primary log stays authoritative.
+ * The primary log stays authoritative: once an append commits, projection can never turn it into
+ * a failure. With a durable delivery runner, failures are persisted for retry; without one, they
+ * are reported to `onError` and the projection is skipped.
  */
 export function withProjectors(store, projectors, options) {
     const onError = options?.onError ?? defaultOnError;
+    const delivery = options?.delivery;
+    const project = (runId, sequences) => {
+        if (delivery) {
+            return delivery.deliver(runId).pipe(Effect.catch((cause) => logDeliveryFailure(runId, cause)));
+        }
+        const fromSeq = sequences[0];
+        if (fromSeq === undefined) {
+            return Effect.void;
+        }
+        return store.read(runId, { fromSeq, limit: sequences.length }).pipe(Effect.flatMap((written) => Effect.forEach(projectors, (projector) => runProjectorEffect(projector.name, () => projector.project(written)).pipe(Effect.catch((error) => Effect.sync(() => {
+            onError(error, projector, written);
+        }))), { concurrency: 'unbounded', discard: true })), Effect.catch((cause) => logDeliveryFailure(runId, cause)));
+    };
     const wrapped = {
-        append: (runId, events, appendOptions) => Effect.gen(function* () {
-            const result = yield* store.append(runId, events, appendOptions);
-            const fromSeq = result.sequences[0];
-            if (fromSeq !== undefined && projectors.length > 0) {
-                const written = yield* store.read(runId, {
-                    fromSeq,
-                    limit: result.sequences.length,
-                });
-                yield* Effect.promise(async () => {
-                    for (const projector of projectors) {
-                        try {
-                            await projector.project(written);
-                        }
-                        catch (cause) {
-                            onError(cause instanceof Error ? cause : new Error(String(cause)), projector, written);
-                        }
-                    }
-                });
-            }
-            return result;
-        }),
+        append: (runId, events, appendOptions) => store
+            .append(runId, events, appendOptions)
+            .pipe(Effect.tap((result) => projectors.length === 0 ? Effect.void : project(runId, result.sequences))),
         read: (runId, readOptions) => store.read(runId, readOptions),
         tail: (runId) => store.tail(runId),
         bounds: store.bounds ? (runId) => store.bounds(runId) : undefined,
         trim: store.trim ? (runId, beforeSeq) => store.trim(runId, beforeSeq) : undefined,
         subscribe: (runId, subscribeOptions) => store.subscribe(runId, subscribeOptions),
-        listRuns: () => store.listRuns(),
+        listRuns: store.listRuns,
     };
     const snapshots = snapshotStoreOf(store);
     return snapshots ? withSnapshotStore(wrapped, snapshots) : wrapped;
 }
 /** Project events after the fact (e.g. from a runtime hook). */
-export async function projectEvents(projectors, events) {
-    for (const projector of projectors) {
-        await projector.project(events);
-    }
+export function projectEvents(projectors, events) {
+    return Effect.runPromise(Effect.forEach(projectors, (projector) => runProjectorEffect(projector.name, () => projector.project(events)), { concurrency: 'unbounded', discard: true }));
 }
 /**
  * Layer that decorates a base EventStore with projection.

package/dist/react/notify.js

@@ -1,9 +1,9 @@
-import { Predicate } from 'effect';
+import { DateTime, Effect, Fiber, Predicate } from 'effect';
 /** Quiet→burst threshold for `adaptive` coalesce (ms since last notify). */
 const ADAPTIVE_BURST_WINDOW_MS = 8;
 function nowMs() {
     const perf = globalThis.performance;
-    return perf === undefined ? Date.now() : perf.now();
+    return perf === undefined ? DateTime.toEpochMillis(DateTime.nowUnsafe()) : perf.now();
 }
 export function createNotifyScheduler(coalesce, onNotify) {
     let notifyScheduled = false;
@@ -17,12 +17,15 @@ export function createNotifyScheduler(coalesce, onNotify) {
         lastNotifyAt = nowMs();
         onNotify();
     };
+    const scheduleTimer = (delayMs) => {
+        notifyTimer = Effect.runFork(Effect.sleep(delayMs).pipe(Effect.andThen(Effect.sync(fire))));
+    };
     const scheduleFrame = () => {
         if (Predicate.isFunction(globalThis.requestAnimationFrame)) {
             notifyRaf = requestAnimationFrame(fire);
         }
         else {
-            notifyTimer = setTimeout(fire, 0);
+            scheduleTimer(0);
         }
     };
     const cancel = () => {
@@ -31,7 +34,7 @@ export function createNotifyScheduler(coalesce, onNotify) {
         }
         notifyScheduled = false;
         if (notifyTimer !== undefined) {
-            clearTimeout(notifyTimer);
+            Effect.runFork(Fiber.interrupt(notifyTimer));
             notifyTimer = undefined;
         }
         if (notifyRaf !== undefined && Predicate.isFunction(globalThis.cancelAnimationFrame)) {
@@ -54,7 +57,7 @@ export function createNotifyScheduler(coalesce, onNotify) {
                 scheduleFrame();
             }
             else {
-                notifyTimer = setTimeout(fire, 0);
+                scheduleTimer(0);
             }
             return;
         }
@@ -64,11 +67,11 @@ export function createNotifyScheduler(coalesce, onNotify) {
         }
         if (Predicate.isObject(coalesce) && 'delayMs' in coalesce) {
             const delayMs = Predicate.isNumber(coalesce.delayMs) ? Math.max(0, coalesce.delayMs) : 0;
-            notifyTimer = setTimeout(fire, delayMs);
+            scheduleTimer(delayMs);
             return;
         }
-        const _exhaustive = coalesce;
-        void _exhaustive;
+        const exhaustiveCheck = coalesce;
+        void exhaustiveCheck;
     };
     const flush = () => {
         if (notifyScheduled) {

package/dist/react/react.d.ts

@@ -24,10 +24,9 @@ export interface UseRunStoreOptions {
  * Retains the store in memory while mounted; does NOT trigger component re-renders.
  * Use data hooks (`useRunEvents`, `useProjection`, `useRunSummary`, etc.) to subscribe.
  */
-export declare function useRunStore<TEvent extends AnyEventEnvelope = RegisteredEvent>(runId: string, options?: UseRunStoreOptions): LoomsClientStore<TEvent>;
-/** Subscribe to incremental projection state, with optional slice selector. */
+export declare function useRunStore(runId: string, options?: UseRunStoreOptions): LoomsClientStore;
+/** Subscribe to incremental projection state. */
 export declare function useProjection<S, TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, definition: ProjectionDefinition<S>): S;
-export declare function useProjection<S, Selected, TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, definition: ProjectionDefinition<S>, selector: (state: S) => Selected, isEqual?: (a: Selected, b: Selected) => boolean): Selected;
 /** Subscribe to arbitrary store derivations with an equality check. */
 export declare function useRunSelector<Selected, TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, selector: (store: LoomsClientStore<TEvent>) => Selected, isEqual?: (a: Selected, b: Selected) => boolean): Selected;
 export interface RunSummary {

package/dist/react/react.js

@@ -1,3 +1,4 @@
+import { Effect, Fiber } from 'effect';
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
 import { threadTree, toThreadTree } from '@swirls/looms/core';
 import { createFold, foldEvents } from './derived.js';
@@ -16,11 +17,13 @@ function disposeEntry(key) {
     entry.store.dispose();
     registry.delete(key);
 }
+function scheduleDisposal(key) {
+    return Effect.runFork(Effect.sleep(GRACE_MS).pipe(Effect.andThen(Effect.sync(() => disposeEntry(key)))));
+}
 function peekStore(runId, endpoint, reconnectDelayMs, coalesce) {
     const key = registryKey(endpoint, runId);
     const existing = registry.get(key);
     if (existing) {
-        // SAFETY: registry stores share the app-registered event catalog.
         return existing.store;
     }
     const store = createLoomsStore({
@@ -30,10 +33,9 @@ function peekStore(runId, endpoint, reconnectDelayMs, coalesce) {
         coalesce,
     });
     registry.set(key, {
-        // SAFETY: store is created with TEvent which defaults to RegisteredEvent.
-        store: store,
+        store,
         refs: 0,
-        timer: setTimeout(() => disposeEntry(key), GRACE_MS),
+        disposal: scheduleDisposal(key),
     });
     return store;
 }
@@ -45,9 +47,9 @@ function retainStore(runId, endpoint, reconnectDelayMs, coalesce) {
         return;
     }
     entry.refs += 1;
-    if (entry.timer !== undefined) {
-        clearTimeout(entry.timer);
-        entry.timer = undefined;
+    if (entry.disposal !== undefined) {
+        Effect.runFork(Fiber.interrupt(entry.disposal));
+        entry.disposal = undefined;
     }
 }
 function releaseStore(runId, endpoint) {
@@ -57,8 +59,8 @@ function releaseStore(runId, endpoint) {
         return;
     }
     entry.refs = Math.max(0, entry.refs - 1);
-    if (entry.refs === 0 && entry.timer === undefined) {
-        entry.timer = setTimeout(() => disposeEntry(key), GRACE_MS);
+    if (entry.refs === 0 && entry.disposal === undefined) {
+        entry.disposal = scheduleDisposal(key);
     }
 }
 /** Root provider that supplies the Looms host endpoint to run stores. */
@@ -87,27 +89,9 @@ function useStoreSnapshot(store, getSnapshot) {
     const subscribe = useCallback((onChange) => store.subscribe(onChange), [store]);
     return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
-function identitySelector(value) {
-    return value;
-}
-export function useProjection(store, definition, selector, isEqual = Object.is) {
-    const lastSelected = useRef(undefined);
-    const lastState = useRef(undefined);
-    // SAFETY: When selector is undefined, Selected equals S so identitySelector satisfies the signature.
-    const select = selector ?? identitySelector;
-    const getSnapshot = useCallback(() => {
-        const state = store.project(definition);
-        if (lastState.current === state && lastSelected.current !== undefined) {
-            return lastSelected.current;
-        }
-        const nextSelected = select(state);
-        lastState.current = state;
-        if (lastSelected.current !== undefined && isEqual(lastSelected.current, nextSelected)) {
-            return lastSelected.current;
-        }
-        lastSelected.current = nextSelected;
-        return nextSelected;
-    }, [store, definition, select, isEqual]);
+/** Subscribe to incremental projection state. */
+export function useProjection(store, definition) {
+    const getSnapshot = useCallback(() => store.project(definition), [store, definition]);
     return useStoreSnapshot(store, getSnapshot);
 }
 /** Subscribe to arbitrary store derivations with an equality check. */

package/dist/react/sse.d.ts

@@ -1 +1 @@
-export { consumeSseStream, delay, eventsFromSseData, parseSseFrame, type SseFrame, } from '@swirls/looms/client';
+export { consumeSseStream, consumeSseStreamEffect, delay, eventsFromSseData, parseSseFrame, type SseFrame, } from '@swirls/looms/client';

package/dist/react/sse.js

@@ -1 +1 @@
-export { consumeSseStream, delay, eventsFromSseData, parseSseFrame, } from '@swirls/looms/client';
+export { consumeSseStream, consumeSseStreamEffect, delay, eventsFromSseData, parseSseFrame, } from '@swirls/looms/client';

package/dist/react/store.d.ts

@@ -12,7 +12,7 @@ export interface LoomsClientStoreOptions {
     storeId: string;
     /**
      * Base URL of the Looms host (e.g. http://127.0.0.1:8787).
-     * Opens `${endpoint}/api/events?runId=&live=true` as an SSE stream.
+     * Opens `${endpoint}/runs/:id/events?live=true` as an SSE stream.
      */
     endpoint: string;
     /** Backoff between SSE reconnects. */
@@ -45,7 +45,7 @@ export interface LoomsClientStore<TEvent extends AnyEventEnvelope = RegisteredEv
     project<S>(definition: ProjectionDefinition<S>): S;
     fold<S>(definition: EventFoldDefinition<S, TEvent>): S;
     flush: () => void;
-    commit: (event: EventInput) => Promise<void>;
+    commit: (event: EventInput | readonly EventInput[]) => Promise<void>;
     sync: () => Promise<void>;
     dispose: () => void;
 }
@@ -53,4 +53,4 @@ export interface LoomsClientStore<TEvent extends AnyEventEnvelope = RegisteredEv
  * In-memory client store that follows a run's event log over SSE and
  * materializes generic `runs` / `threads` tables.
  */
-export declare function createLoomsStore<TEvent extends AnyEventEnvelope = RegisteredEvent>(options: LoomsClientStoreOptions): LoomsClientStore<TEvent>;
+export declare function createLoomsStore(options: LoomsClientStoreOptions): LoomsClientStore;