@swirls/looms 0.4.0 → 0.5.1

package/dist/projectors/sqlite.js

@@ -1,21 +1,54 @@
 import { Database } from 'bun:sqlite';
 import { createIndexProjector, } from './index-model.js';
 import { runProjectorSync } from './projector.js';
-import { SQLITE_SCHEMA_SQL } from './schema.js';
+import { SQLITE_ADDED_ACTOR_COLUMNS, SQLITE_INDEXES_SQL, SQLITE_TABLES_SQL } from './schema.js';
 export { SQLITE_SCHEMA_SQL } from './schema.js';
+const ACTOR_COLUMNS = `run_id, actor_id, kind, status, definition_name, parent_actor_id,
+  launched_by_run_id, launched_by_effect_id, correlation_id, updated_at`;
 function hasDb(options) {
     return 'db' in options;
 }
+function actorFromRow(row) {
+    return {
+        runId: row.run_id,
+        actorId: row.actor_id,
+        kind: row.kind,
+        status: row.status,
+        definitionName: row.definition_name,
+        parentActorId: row.parent_actor_id,
+        launchedByRunId: row.launched_by_run_id,
+        launchedByEffectId: row.launched_by_effect_id,
+        correlationId: row.correlation_id,
+        updatedAt: row.updated_at,
+    };
+}
+/** Creates the tables, adds columns a database from an earlier release lacks, then indexes them. */
+function migrate(db) {
+    db.exec(SQLITE_TABLES_SQL);
+    const existing = new Set(db
+        .query('PRAGMA table_info(looms_run_actors)')
+        .all()
+        .map((column) => column.name));
+    for (const column of SQLITE_ADDED_ACTOR_COLUMNS) {
+        if (!existing.has(column)) {
+            db.exec(`ALTER TABLE looms_run_actors ADD COLUMN ${column} TEXT`);
+        }
+    }
+    db.exec(SQLITE_INDEXES_SQL);
+}
 function applyOp(db, op) {
     switch (op.type) {
         case 'upsertActor':
-            db.run(`INSERT INTO looms_run_actors (run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
+            db.run(`INSERT INTO looms_run_actors (${ACTOR_COLUMNS})
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT (run_id, actor_id) DO UPDATE SET
            kind = excluded.kind,
            status = excluded.status,
            definition_name = excluded.definition_name,
            parent_actor_id = excluded.parent_actor_id,
+           launched_by_run_id = excluded.launched_by_run_id,
+           launched_by_effect_id = excluded.launched_by_effect_id,
+           correlation_id = excluded.correlation_id,
            updated_at = excluded.updated_at`, [
                 op.runId,
                 op.actorId,
@@ -23,6 +56,9 @@ function applyOp(db, op) {
                 op.status,
                 op.definitionName,
                 op.parentActorId,
+                op.launchedByRunId,
+                op.launchedByEffectId,
+                op.correlationId,
                 op.updatedAt,
             ]);
             return;
@@ -53,9 +89,7 @@ export function sqlite(options = {}) {
     const createdDb = !hasDb(options);
     const db = hasDb(options) ? options.db : new Database(options.path ?? ':memory:');
     const backend = {
-        init: () => runProjectorSync('sqlite', () => {
-            db.exec(SQLITE_SCHEMA_SQL);
-        }),
+        init: () => runProjectorSync('sqlite', () => migrate(db)),
         applyOps: (ops) => runProjectorSync('sqlite', () => {
             const apply = db.transaction((batch) => {
                 for (const op of batch) {
@@ -66,21 +100,15 @@ export function sqlite(options = {}) {
         }),
         getActor: (runId, actorId) => runProjectorSync('sqlite', () => {
             const row = db
-                .query(`SELECT run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at
-             FROM looms_run_actors WHERE run_id = ? AND actor_id = ?`)
+                .query(`SELECT ${ACTOR_COLUMNS} FROM looms_run_actors WHERE run_id = ? AND actor_id = ?`)
                 .get(runId, actorId);
-            return row
-                ? {
-                    runId: row.run_id,
-                    actorId: row.actor_id,
-                    kind: row.kind,
-                    status: row.status,
-                    definitionName: row.definition_name,
-                    parentActorId: row.parent_actor_id,
-                    updatedAt: row.updated_at,
-                }
-                : null;
+            return row ? actorFromRow(row) : null;
         }),
+        listLaunched: (runId) => runProjectorSync('sqlite', () => db
+            .query(`SELECT ${ACTOR_COLUMNS} FROM looms_run_actors
+             WHERE launched_by_run_id = ? AND actor_id = run_id ORDER BY updated_at`)
+            .all(runId)
+            .map(actorFromRow)),
         listReviews: (runId) => runProjectorSync('sqlite', () => {
             const rows = runId
                 ? db

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

@@ -1,4 +1,4 @@
-import { Layer } from 'effect';
+import { Effect, Layer } from 'effect';
 import { EventStoreTag, type EventStore, type EventEnvelope } from '@swirls/looms/core';
 import type { ProjectorDelivery } from './delivery';
 import { type Projector, type ProjectorErrorHandler } from './projector';
@@ -6,6 +6,12 @@ export interface WithProjectorsOptions {
     onError?: ProjectorErrorHandler;
     /** Durable cursor runner. When present, appends trigger catch-up from its persisted cursor. */
     delivery?: ProjectorDelivery;
+    /**
+     * Runs projection after the append commits, without making the append wait.
+     * The callback has to keep the effect alive, for example with a Durable Object's `waitUntil`.
+     * Without it, projection still finishes before `append` returns.
+     */
+    scheduleDelivery?: (runId: string, delivery: Effect.Effect<void>) => void;
 }
 /**
  * Wrap an EventStore so every successful append is also projected.

package/dist/projectors/with-projectors.js

@@ -16,6 +16,7 @@ function logDeliveryFailure(runId, cause) {
 export function withProjectors(store, projectors, options) {
     const onError = options?.onError ?? defaultOnError;
     const delivery = options?.delivery;
+    const scheduleDelivery = options?.scheduleDelivery;
     const project = (runId, sequences) => {
         if (delivery) {
             return delivery.deliver(runId).pipe(Effect.catch((cause) => logDeliveryFailure(runId, cause)));
@@ -29,9 +30,18 @@ export function withProjectors(store, projectors, options) {
         }))), { concurrency: 'unbounded', discard: true })), Effect.catch((cause) => logDeliveryFailure(runId, cause)));
     };
     const wrapped = {
-        append: (runId, events, appendOptions) => store
-            .append(runId, events, appendOptions)
-            .pipe(Effect.tap((result) => projectors.length === 0 ? Effect.void : project(runId, result.sequences))),
+        append: (runId, events, appendOptions) => store.append(runId, events, appendOptions).pipe(Effect.tap((result) => {
+            if (projectors.length === 0) {
+                return Effect.void;
+            }
+            const work = project(runId, result.sequences);
+            if (!scheduleDelivery) {
+                return work;
+            }
+            return Effect.sync(() => {
+                scheduleDelivery(runId, work);
+            });
+        })),
         read: (runId, readOptions) => store.read(runId, readOptions),
         tail: (runId) => store.tail(runId),
         bounds: store.bounds ? (runId) => store.bounds(runId) : undefined,

package/dist/react/materialize.js

@@ -1,4 +1,4 @@
-import { completedRunStatus, isJsonObject, isJsonString, } from '@swirls/looms/core';
+import { completedRunStatus, isJsonObject, isJsonString, readAttributes, readRunLaunchSource, } from '@swirls/looms/core';
 import { emptyTables } from './tables.js';
 function payloadObject(event) {
     return isJsonObject(event.payload) ? event.payload : {};
@@ -15,6 +15,8 @@ function setRunStatus(tables, runId, status) {
         rootThreadId: existing?.rootThreadId ?? null,
         kind: existing?.kind ?? null,
         definitionName: existing?.definitionName ?? null,
+        launchedBy: existing?.launchedBy ?? null,
+        attributes: existing?.attributes ?? {},
     });
 }
 export function materializeEvents(events, from = emptyTables()) {
@@ -34,6 +36,8 @@ export function materializeEvents(events, from = emptyTables()) {
                     rootThreadId,
                     kind: readString(payload, 'kind') ?? existing?.kind ?? null,
                     definitionName: readString(payload, 'definitionName') ?? existing?.definitionName ?? null,
+                    launchedBy: readRunLaunchSource(payload.launchedBy) ?? existing?.launchedBy ?? null,
+                    attributes: readAttributes(payload.attributes),
                 };
                 tables.runs.set(event.runId, next);
                 break;

package/dist/react/react.d.ts

@@ -1,22 +1,27 @@
 import { type ReactNode } from 'react';
-import { type AnyEventEnvelope, type ProjectionDefinition, type RegisteredEvent, type RunStatus, type ThreadTree } from '@swirls/looms/core';
+import { type AnyEventEnvelope, type ProjectionDefinition, type RegisteredEvent, type RunAttributes, type RunLaunchSource, type RunStatus, type SubscriptionTransport, type ThreadTree } from '@swirls/looms/core';
 import { defineLiveFold, foldLive, type LiveFoldDefinition } from './derived';
 import { createLoomsStore, type CoalesceOption, type LoomsClientStore, type LoomsConnectionStatus } from './store';
 export interface LoomsProviderProps {
     children: ReactNode;
     endpoint?: string;
     coalesce?: CoalesceOption;
+    transport?: SubscriptionTransport;
 }
 interface ProviderContextValue {
     endpoint: string;
     coalesce?: CoalesceOption;
+    transport?: SubscriptionTransport;
 }
 /** Root provider that supplies the Looms host endpoint to run stores. */
-export declare function LoomsProvider({ children, endpoint, coalesce }: LoomsProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<ProviderContextValue>>;
+export declare function LoomsProvider({ children, endpoint, coalesce, transport, }: LoomsProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<ProviderContextValue>>;
 export interface UseRunStoreOptions {
     endpoint?: string;
     reconnectDelayMs?: number;
     coalesce?: CoalesceOption;
+    transport?: SubscriptionTransport;
+    threadId?: string;
+    includeEphemeral?: boolean;
 }
 /**
  * Acquires a non-subscribing handle to the run store.
@@ -38,6 +43,9 @@ export interface RunSummary {
     readonly definitionName: string | undefined;
     readonly rootThreadId: string | undefined;
     readonly startedAt: number | undefined;
+    /** The effect in another run that launched this one. */
+    readonly launchedBy: RunLaunchSource | undefined;
+    readonly attributes: RunAttributes;
     readonly connection: LoomsConnectionStatus;
 }
 /** Lightweight subscription to top-level run metadata and connection status. */

package/dist/react/react.js

@@ -1,13 +1,19 @@
 import { Effect, Fiber } from 'effect';
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
-import { isTerminalStatus, threadTree, toThreadTree, } from '@swirls/looms/core';
+import { isTerminalStatus, sameStringRecord, threadTree, toThreadTree, } from '@swirls/looms/core';
 import { defineLiveFold, foldLive } from './derived.js';
 import { createLoomsStore, } from './store.js';
 const LoomsContext = createContext({ endpoint: '' });
 const GRACE_MS = 5_000;
 const registry = new Map();
-function registryKey(endpoint, runId) {
-    return `${endpoint}\0${runId}`;
+function registryKey(runId, identity) {
+    return [
+        identity.endpoint,
+        runId,
+        identity.transport ?? '',
+        identity.threadId ?? '',
+        identity.includeEphemeral === false ? '0' : '1',
+    ].join('\0');
 }
 function disposeEntry(key) {
     const entry = registry.get(key);
@@ -20,17 +26,20 @@ function disposeEntry(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);
+function peekStore(runId, identity) {
+    const key = registryKey(runId, identity);
     const existing = registry.get(key);
     if (existing) {
         return existing.store;
     }
     const store = createLoomsStore({
         storeId: runId,
-        endpoint,
-        reconnectDelayMs,
-        coalesce,
+        endpoint: identity.endpoint,
+        reconnectDelayMs: identity.reconnectDelayMs,
+        coalesce: identity.coalesce,
+        transport: identity.transport,
+        threadId: identity.threadId,
+        includeEphemeral: identity.includeEphemeral,
     });
     registry.set(key, {
         store,
@@ -39,9 +48,9 @@ function peekStore(runId, endpoint, reconnectDelayMs, coalesce) {
     });
     return store;
 }
-function retainStore(runId, endpoint, reconnectDelayMs, coalesce) {
-    const key = registryKey(endpoint, runId);
-    peekStore(runId, endpoint, reconnectDelayMs, coalesce);
+function retainStore(runId, identity) {
+    const key = registryKey(runId, identity);
+    peekStore(runId, identity);
     const entry = registry.get(key);
     if (!entry) {
         return;
@@ -52,8 +61,8 @@ function retainStore(runId, endpoint, reconnectDelayMs, coalesce) {
         entry.disposal = undefined;
     }
 }
-function releaseStore(runId, endpoint) {
-    const key = registryKey(endpoint, runId);
+function releaseStore(runId, identity) {
+    const key = registryKey(runId, identity);
     const entry = registry.get(key);
     if (!entry) {
         return;
@@ -64,8 +73,8 @@ function releaseStore(runId, endpoint) {
     }
 }
 /** Root provider that supplies the Looms host endpoint to run stores. */
-export function LoomsProvider({ children, endpoint = '', coalesce }) {
-    const value = useMemo(() => ({ endpoint, coalesce }), [endpoint, coalesce]);
+export function LoomsProvider({ children, endpoint = '', coalesce, transport, }) {
+    const value = useMemo(() => ({ endpoint, coalesce, transport }), [endpoint, coalesce, transport]);
     return createElement(LoomsContext.Provider, { value, children });
 }
 /**
@@ -78,11 +87,22 @@ export function useRunStore(runId, options) {
     const endpoint = options?.endpoint ?? context.endpoint;
     const reconnectDelayMs = options?.reconnectDelayMs;
     const coalesce = options?.coalesce ?? context.coalesce;
-    const store = peekStore(runId, endpoint, reconnectDelayMs, coalesce);
+    const transport = options?.transport ?? context.transport;
+    const threadId = options?.threadId;
+    const includeEphemeral = options?.includeEphemeral;
+    const identity = {
+        endpoint,
+        reconnectDelayMs,
+        coalesce,
+        transport,
+        threadId,
+        includeEphemeral,
+    };
+    const store = peekStore(runId, identity);
     useEffect(() => {
-        retainStore(runId, endpoint, reconnectDelayMs, coalesce);
-        return () => releaseStore(runId, endpoint);
-    }, [runId, endpoint, reconnectDelayMs, coalesce]);
+        retainStore(runId, identity);
+        return () => releaseStore(runId, identity);
+    }, [runId, endpoint, reconnectDelayMs, coalesce, transport, threadId, includeEphemeral]);
     return store;
 }
 function useStoreSnapshot(store, getSnapshot) {
@@ -119,6 +139,8 @@ function shallowEqualSummary(a, b) {
         a.definitionName === b.definitionName &&
         a.rootThreadId === b.rootThreadId &&
         a.startedAt === b.startedAt &&
+        a.launchedBy === b.launchedBy &&
+        sameStringRecord(a.attributes, b.attributes) &&
         a.connection === b.connection);
 }
 /** Lightweight subscription to top-level run metadata and connection status. */
@@ -134,6 +156,8 @@ export function useRunSummary(store) {
             definitionName: run?.definitionName ?? undefined,
             rootThreadId: run?.rootThreadId ?? undefined,
             startedAt: s.query.startedAt(),
+            launchedBy: run?.launchedBy ?? undefined,
+            attributes: run?.attributes ?? {},
             connection: s.status(),
         };
     }, []);

package/dist/react/store.d.ts

@@ -1,4 +1,5 @@
-import { type AnyEventEnvelope, type EventInput, type ProjectionDefinition, type RegisteredEvent } from '@swirls/looms/core';
+import type { SubscriptionSocketConstructor } from '@swirls/looms/client';
+import { type AnyEventEnvelope, type EventInput, type ProjectionDefinition, type RegisteredEvent, type SubscriptionTransport } from '@swirls/looms/core';
 import { type LiveFoldDefinition } from './derived';
 import { type CoalesceOption } from './notify';
 import { type MaterializedTables } from './tables';
@@ -14,10 +15,18 @@ export interface LoomsClientStoreOptions {
      * Opens `${endpoint}/runs/:id/events?live=true` as an SSE stream.
      */
     endpoint: string;
-    /** Backoff between SSE reconnects. */
+    /** Backoff between reconnects. The delay stays fixed, matching the SSE client. */
     reconnectDelayMs?: number;
     fetch?: typeof fetch;
     coalesce?: CoalesceOption;
+    /**
+     * `undefined` keeps the current SSE path. `websocket` and `auto` use a hibernating
+     * socket when a constructor is available.
+     */
+    transport?: SubscriptionTransport;
+    threadId?: string;
+    includeEphemeral?: boolean;
+    webSocket?: SubscriptionSocketConstructor;
 }
 export interface LoomsStoreQuery<TEvent extends AnyEventEnvelope = RegisteredEvent> {
     events: (options?: {

package/dist/react/store.js

@@ -1,9 +1,9 @@
 import { Data, Effect, Fiber, Option, Predicate, Schema } from 'effect';
-import { decodeLoomsEvent, stringifyJson, } from '@swirls/looms/core';
+import { decodeLoomsEvent, readSubscriptionData, stringifyJson, } from '@swirls/looms/core';
 import { EventIndex, ProjectionCache } from './derived.js';
 import { materializeEvents } from './materialize.js';
 import { createNotifyScheduler } from './notify.js';
-import { consumeSseStreamEffect, eventsFromSseData } from './sse.js';
+import { consumeSseStreamEffect } from './sse.js';
 import { emptyTables } from './tables.js';
 class LoomsStoreError extends Data.TaggedError('LoomsStoreError') {
     constructor(message, cause) {
@@ -11,6 +11,18 @@ class LoomsStoreError extends Data.TaggedError('LoomsStoreError') {
         this.name = 'LoomsStoreError';
     }
 }
+function socketConstructor(options) {
+    if (options.transport !== 'websocket' && options.transport !== 'auto') {
+        return undefined;
+    }
+    if (options.webSocket) {
+        return options.webSocket;
+    }
+    if (!('WebSocket' in globalThis) || !Predicate.isFunction(globalThis.WebSocket)) {
+        return undefined;
+    }
+    return globalThis.WebSocket;
+}
 function eventSourceCtor() {
     if (typeof EventSource === 'undefined') {
         return undefined;
@@ -42,6 +54,7 @@ export function createLoomsStore(options) {
     let liveStarted = false;
     let liveAbort;
     let eventSource;
+    let socket;
     let reconnectFiber;
     let syncing = null;
     const publishedEvents = () => {
@@ -88,11 +101,33 @@ export function createLoomsStore(options) {
         version += 1;
         notify.schedule();
     };
-    const applyEncoded = (data) => {
-        applyBatch(eventsFromSseData(data, options.storeId));
+    const applyLiveData = (data) => {
+        const read = readSubscriptionData(data, options.storeId);
+        switch (read.kind) {
+            case 'events':
+                applyBatch(read.events.slice());
+                return 'continue';
+            case 'resync':
+                fromSeq = read.head;
+                return 'resync';
+            case 'hello':
+            case 'ignore':
+                return 'continue';
+            default: {
+                const unexpected = read;
+                return unexpected;
+            }
+        }
     };
     const liveUrl = () => {
-        return `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?live=true&fromSeq=${fromSeq}`;
+        const params = new URLSearchParams({ live: 'true', fromSeq: String(fromSeq) });
+        if (options.threadId) {
+            params.set('threadId', options.threadId);
+        }
+        if (options.includeEphemeral === false) {
+            params.set('includeEphemeral', 'false');
+        }
+        return `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?${params.toString()}`;
     };
     const pull = Effect.gen(function* () {
         const url = `${endpoint}/runs/${encodeURIComponent(options.storeId)}/events?fromSeq=${fromSeq}`;
@@ -135,7 +170,7 @@ export function createLoomsStore(options) {
         });
         return syncing;
     };
-    const scheduleReconnect = (Ctor) => {
+    const scheduleReconnect = (start) => {
         if (disposed || !liveStarted || reconnectFiber !== undefined) {
             return;
         }
@@ -150,7 +185,7 @@ export function createLoomsStore(options) {
                 catch: (cause) => new LoomsStoreError('Event resync failed', cause),
             }).pipe(Effect.ignore);
             if (!disposed && liveStarted) {
-                startEventSource(Ctor);
+                start();
             }
         }));
     };
@@ -165,7 +200,16 @@ export function createLoomsStore(options) {
             setStatus('live');
         });
         es.addEventListener('message', (msg) => {
-            applyEncoded(msg.data);
+            if (applyLiveData(msg.data) === 'resync') {
+                es.close();
+                if (eventSource === es) {
+                    eventSource = undefined;
+                }
+                setStatus('reconnecting');
+                scheduleReconnect(() => {
+                    startEventSource(Ctor);
+                });
+            }
         });
         es.addEventListener('error', () => {
             live = es.readyState === Ctor.OPEN;
@@ -178,7 +222,9 @@ export function createLoomsStore(options) {
                 if (eventSource === es) {
                     eventSource = undefined;
                 }
-                scheduleReconnect(Ctor);
+                scheduleReconnect(() => {
+                    startEventSource(Ctor);
+                });
             }
             else if (!live) {
                 setStatus('reconnecting');
@@ -209,9 +255,7 @@ export function createLoomsStore(options) {
                     }
                     live = true;
                     setStatus('live');
-                    return yield* consumeSseStreamEffect(body, (frame) => {
-                        applyEncoded(frame.data);
-                    });
+                    return yield* consumeSseStreamEffect(body, (frame) => applyLiveData(frame.data) === 'resync' ? false : undefined);
                 }).pipe(Effect.catch(() => Effect.sync(() => {
                     live = false;
                     if (!disposed) {
@@ -226,12 +270,58 @@ export function createLoomsStore(options) {
         });
         void Effect.runPromise(run, { signal: controller.signal }).catch(() => undefined);
     };
+    const startWebSocket = (Ctor) => {
+        if (disposed || !liveStarted) {
+            return;
+        }
+        let url;
+        try {
+            const http = new URL(liveUrl());
+            http.protocol = http.protocol === 'https:' ? 'wss:' : 'ws:';
+            url = http.toString();
+        }
+        catch {
+            startFetchStream();
+            return;
+        }
+        const ws = new Ctor(url);
+        socket = ws;
+        ws.addEventListener('open', () => {
+            live = true;
+            setStatus('live');
+        });
+        ws.addEventListener('message', (event) => {
+            if (!Predicate.isString(event.data)) {
+                return;
+            }
+            if (applyLiveData(event.data) === 'resync') {
+                ws.close();
+            }
+        });
+        ws.addEventListener('close', () => {
+            live = false;
+            if (socket === ws) {
+                socket = undefined;
+            }
+            if (!disposed && liveStarted) {
+                setStatus('reconnecting');
+                scheduleReconnect(() => {
+                    startWebSocket(Ctor);
+                });
+            }
+        });
+    };
     const startLive = () => {
         if (!options.storeId || (liveStarted && !disposed)) {
             return;
         }
         liveStarted = true;
         disposed = false;
+        const socketCtor = socketConstructor(options);
+        if (socketCtor) {
+            startWebSocket(socketCtor);
+            return;
+        }
         const ctor = options.fetch === undefined ? eventSourceCtor() : undefined;
         if (ctor) {
             startEventSource(ctor);
@@ -249,6 +339,8 @@ export function createLoomsStore(options) {
         }
         eventSource?.close();
         eventSource = undefined;
+        socket?.close();
+        socket = undefined;
         liveAbort?.abort();
         liveAbort = undefined;
     };

package/dist/react/tables.d.ts

@@ -1,10 +1,13 @@
-import type { RunStatus, ThreadStatus } from '@swirls/looms/core';
+import type { RunAttributes, RunLaunchSource, RunStatus, ThreadStatus } from '@swirls/looms/core';
 export interface RunRow {
     runId: string;
     status: RunStatus;
     rootThreadId: string | null;
     kind: string | null;
     definitionName: string | null;
+    /** The effect in another run that launched this one. */
+    launchedBy: RunLaunchSource | null;
+    attributes: RunAttributes;
 }
 export interface ThreadRow {
     threadId: string;

package/dist/runtime/cancellation.d.ts

@@ -1,4 +1,4 @@
-import { type ComposedRegistry } from '@swirls/looms/core';
+import { type ComposedRegistry, type RunLauncher } from '@swirls/looms/core';
 import type { RunIngress } from './ingress';
 import { type RuntimeObserver } from './observer';
 import type { RuntimeRepository } from './repository';
@@ -12,5 +12,6 @@ export interface CancellationOptions {
     readonly observer?: RuntimeObserver;
     readonly wake: LoomsRuntime['wake'];
     readonly withRunIngress: RunIngress;
+    readonly launcher: () => RunLauncher;
 }
 export declare function createCancellation(options: CancellationOptions): LoomsRuntime['cancel'];

package/dist/runtime/cancellation.js

@@ -75,6 +75,32 @@ export function createCancellation(options) {
             const store = yield* EventStoreTag;
             const now = yield* Clock.currentTimeMillis;
             return yield* repository.commit(store, runId, (current) => {
+                const rootCancel = threadId === undefined || threadId === current.state.rootThreadId;
+                const deferClose = rootCancel &&
+                    !current.state.childCloseSent &&
+                    current.state.launchedRuns.some((child) => child.close === 'wait');
+                if (deferClose) {
+                    const requested = createEvent(runId, {
+                        type: 'runtime.child.close.requested',
+                        payload: { policy: 'wait' },
+                        threadId: current.state.rootThreadId,
+                        origin: { type: 'system' },
+                        idempotencyKey: `child-close:${current.state.rootThreadId ?? runId}`,
+                    });
+                    return Effect.succeed({
+                        events: [requested],
+                        value: {
+                            plan: {
+                                events: [],
+                                threadIds: new Set(),
+                                workerCancellations: [],
+                            },
+                            now,
+                            childRunIds: current.state.launchedRuns.map((child) => child.runId),
+                        },
+                        idempotencyKey: `signal:child-close:${current.state.rootThreadId ?? runId}`,
+                    });
+                }
                 const plan = planCancellation({
                     runId,
                     seq: current.seq,
@@ -84,14 +110,21 @@ export function createCancellation(options) {
                     worker,
                     now,
                 });
+                const childRunIds = [];
                 return Effect.succeed({
                     events: plan.events,
-                    value: { plan, now },
+                    value: { plan, now, childRunIds },
                     idempotencyKey: `signal:cancel:${threadId ?? current.state.rootThreadId ?? ''}`,
                 });
             });
         }));
-        const { plan, now } = committed.value;
+        const { plan, now, childRunIds } = committed.value;
+        if (childRunIds.length > 0) {
+            yield* Effect.forEach(childRunIds, (childRunId) => options.launcher().cancel(childRunId), {
+                concurrency: 1,
+                discard: true,
+            });
+        }
         if (committed.append) {
             executionContexts.abort(runId, plan.threadIds, 'Effect cancelled');
             for (const { item, execution } of plan.workerCancellations) {

package/dist/runtime/child-run.d.ts

@@ -0,0 +1,10 @@
+import { Effect } from 'effect';
+import { type EventInput, type RunLauncher, type RunState } from '@swirls/looms/core';
+/** Tell the launching run that this child has reached a terminal status. */
+export declare function notifyLaunchingParent(launcher: RunLauncher, runId: string, state: RunState): Effect.Effect<void, Error>;
+/**
+ * When a run asked to wait for child cancellation and those children are gone, cancel the
+ * run's own threads. The caller appends these events from the parent wake, which must not
+ * call `runtime.cancel` on itself.
+ */
+export declare function childCloseCancellations(state: RunState): EventInput[];