@swirls/looms 0.2.0 → 0.3.0

package/dist/projectors/postgres.js

@@ -12,9 +12,9 @@ function applyOp(sql, op) {
     switch (op.type) {
         case 'upsertActor':
             return sql `
-        INSERT INTO looms_actors (actor_id, kind, status, definition_name, parent_actor_id, updated_at)
-        VALUES (${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId}, ${date})
-        ON CONFLICT (actor_id) DO UPDATE SET
+        INSERT INTO looms_run_actors (run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at)
+        VALUES (${op.runId}, ${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId}, ${date})
+        ON CONFLICT (run_id, actor_id) DO UPDATE SET
           kind = EXCLUDED.kind,
           status = EXCLUDED.status,
           definition_name = EXCLUDED.definition_name,
@@ -23,24 +23,24 @@ function applyOp(sql, op) {
       `;
         case 'setActorStatus':
             return sql `
-        INSERT INTO looms_actors (actor_id, status, updated_at)
-        VALUES (${op.actorId}, ${op.status}, ${date})
-        ON CONFLICT (actor_id) DO UPDATE SET
+        INSERT INTO looms_run_actors (run_id, actor_id, status, updated_at)
+        VALUES (${op.runId}, ${op.actorId}, ${op.status}, ${date})
+        ON CONFLICT (run_id, actor_id) DO UPDATE SET
           status = EXCLUDED.status,
           updated_at = EXCLUDED.updated_at
       `;
         case 'upsertReview':
             return sql `
-        INSERT INTO looms_reviews (review_id, actor_id, status, title, updated_at)
-        VALUES (${op.reviewId}, ${op.actorId}, ${op.status}, ${op.title}, ${date})
-        ON CONFLICT (review_id) DO UPDATE SET
+        INSERT INTO looms_run_reviews (run_id, review_id, status, title, updated_at)
+        VALUES (${op.runId}, ${op.reviewId}, ${op.status}, ${op.title}, ${date})
+        ON CONFLICT (run_id, review_id) DO UPDATE SET
           status = EXCLUDED.status,
           updated_at = EXCLUDED.updated_at
       `;
         case 'setReviewStatus':
             return sql `
-        UPDATE looms_reviews SET status = ${op.status}, updated_at = ${date}
-        WHERE review_id = ${op.reviewId}
+        UPDATE looms_run_reviews SET status = ${op.status}, updated_at = ${date}
+        WHERE run_id = ${op.runId} AND review_id = ${op.reviewId}
       `;
         default: {
             const exhaustiveCheck = op;
@@ -56,13 +56,14 @@ export function postgres(options) {
         applyOps: (ops) => runProjectorPromise('postgres', () => sql.begin((tx) => Effect.runPromise(Effect.forEach(ops, (op) => Effect.promise(() => Promise.resolve(applyOp(tx, op))), {
             discard: true,
         })))).then(() => undefined),
-        getActor: (actorId) => runProjectorPromise('postgres', () => sql `
-          SELECT actor_id, kind, status, definition_name, parent_actor_id, updated_at
-          FROM looms_actors WHERE actor_id = ${actorId}
+        getActor: (runId, actorId) => runProjectorPromise('postgres', () => sql `
+          SELECT run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at
+          FROM looms_run_actors WHERE run_id = ${runId} AND actor_id = ${actorId}
         `).then((rows) => {
             const row = rows[0];
             return row
                 ? {
+                    runId: row.run_id,
                     actorId: row.actor_id,
                     kind: row.kind,
                     status: row.status,
@@ -72,16 +73,16 @@ export function postgres(options) {
                 }
                 : null;
         }),
-        listReviews: (actorId) => runProjectorPromise('postgres', () => actorId
+        listReviews: (runId) => runProjectorPromise('postgres', () => runId
             ? sql `
-            SELECT review_id, actor_id, status, title, updated_at
-            FROM looms_reviews WHERE actor_id = ${actorId}
+            SELECT run_id, review_id, status, title, updated_at
+            FROM looms_run_reviews WHERE run_id = ${runId}
           `
             : sql `
-            SELECT review_id, actor_id, status, title, updated_at FROM looms_reviews
+            SELECT run_id, review_id, status, title, updated_at FROM looms_run_reviews
           `).then((rows) => rows.map((row) => ({
+            runId: row.run_id,
             reviewId: row.review_id,
-            actorId: row.actor_id,
             status: row.status,
             title: row.title,
             updatedAt: row.updated_at.getTime(),

package/dist/projectors/schema.js

@@ -2,42 +2,44 @@
  * SQL schema for the optional Looms secondary index.
  */
 export const POSTGRES_SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS looms_actors (
-  actor_id TEXT PRIMARY KEY,
+CREATE TABLE IF NOT EXISTS looms_run_actors (
+  run_id TEXT NOT NULL,
+  actor_id TEXT NOT NULL,
   kind TEXT,
   status TEXT,
   definition_name TEXT,
   parent_actor_id TEXT,
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (run_id, actor_id)
 );
 
-CREATE TABLE IF NOT EXISTS looms_reviews (
-  review_id TEXT PRIMARY KEY,
-  actor_id TEXT NOT NULL,
+CREATE TABLE IF NOT EXISTS looms_run_reviews (
+  run_id TEXT NOT NULL,
+  review_id TEXT NOT NULL,
   status TEXT NOT NULL,
   title TEXT NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (run_id, review_id)
 );
-
-CREATE INDEX IF NOT EXISTS looms_reviews_actor_id_idx ON looms_reviews (actor_id);
 `.trim();
 export const SQLITE_SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS looms_actors (
-  actor_id TEXT PRIMARY KEY,
+CREATE TABLE IF NOT EXISTS looms_run_actors (
+  run_id TEXT NOT NULL,
+  actor_id TEXT NOT NULL,
   kind TEXT,
   status TEXT,
   definition_name TEXT,
   parent_actor_id TEXT,
-  updated_at INTEGER NOT NULL
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (run_id, actor_id)
 );
 
-CREATE TABLE IF NOT EXISTS looms_reviews (
-  review_id TEXT PRIMARY KEY,
-  actor_id TEXT NOT NULL,
+CREATE TABLE IF NOT EXISTS looms_run_reviews (
+  run_id TEXT NOT NULL,
+  review_id TEXT NOT NULL,
   status TEXT NOT NULL,
   title TEXT NOT NULL,
-  updated_at INTEGER NOT NULL
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (run_id, review_id)
 );
-
-CREATE INDEX IF NOT EXISTS looms_reviews_actor_id_idx ON looms_reviews (actor_id);
 `.trim();

package/dist/projectors/sqlite.js

@@ -9,35 +9,39 @@ function hasDb(options) {
 function applyOp(db, op) {
     switch (op.type) {
         case 'upsertActor':
-            db.run(`INSERT INTO looms_actors (actor_id, kind, status, definition_name, parent_actor_id, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON CONFLICT (actor_id) DO UPDATE SET
+            db.run(`INSERT INTO looms_run_actors (run_id, actor_id, kind, status, definition_name, parent_actor_id, updated_at)
+         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,
-           updated_at = excluded.updated_at`, [op.actorId, op.kind, op.status, op.definitionName, op.parentActorId, op.updatedAt]);
+           updated_at = excluded.updated_at`, [
+                op.runId,
+                op.actorId,
+                op.kind,
+                op.status,
+                op.definitionName,
+                op.parentActorId,
+                op.updatedAt,
+            ]);
             return;
         case 'setActorStatus':
-            db.run(`INSERT INTO looms_actors (actor_id, status, updated_at)
-         VALUES (?, ?, ?)
-         ON CONFLICT (actor_id) DO UPDATE SET
+            db.run(`INSERT INTO looms_run_actors (run_id, actor_id, status, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT (run_id, actor_id) DO UPDATE SET
            status = excluded.status,
-           updated_at = excluded.updated_at`, [op.actorId, op.status, op.updatedAt]);
+           updated_at = excluded.updated_at`, [op.runId, op.actorId, op.status, op.updatedAt]);
             return;
         case 'upsertReview':
-            db.run(`INSERT INTO looms_reviews (review_id, actor_id, status, title, updated_at)
+            db.run(`INSERT INTO looms_run_reviews (run_id, review_id, status, title, updated_at)
          VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT (review_id) DO UPDATE SET
+         ON CONFLICT (run_id, review_id) DO UPDATE SET
            status = excluded.status,
-           updated_at = excluded.updated_at`, [op.reviewId, op.actorId, op.status, op.title, op.updatedAt]);
+           updated_at = excluded.updated_at`, [op.runId, op.reviewId, op.status, op.title, op.updatedAt]);
             return;
         case 'setReviewStatus':
-            db.run(`UPDATE looms_reviews SET status = ?, updated_at = ? WHERE review_id = ?`, [
-                op.status,
-                op.updatedAt,
-                op.reviewId,
-            ]);
+            db.run(`UPDATE looms_run_reviews SET status = ?, updated_at = ? WHERE run_id = ? AND review_id = ?`, [op.status, op.updatedAt, op.runId, op.reviewId]);
             return;
         default: {
             const exhaustiveCheck = op;
@@ -60,13 +64,14 @@ export function sqlite(options = {}) {
             });
             apply(ops);
         }),
-        getActor: (actorId) => runProjectorSync('sqlite', () => {
+        getActor: (runId, 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 = ?`)
-                .get(actorId);
+                .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 = ?`)
+                .get(runId, actorId);
             return row
                 ? {
+                    runId: row.run_id,
                     actorId: row.actor_id,
                     kind: row.kind,
                     status: row.status,
@@ -76,18 +81,18 @@ export function sqlite(options = {}) {
                 }
                 : null;
         }),
-        listReviews: (actorId) => runProjectorSync('sqlite', () => {
-            const rows = actorId
+        listReviews: (runId) => runProjectorSync('sqlite', () => {
+            const rows = runId
                 ? db
-                    .query(`SELECT review_id, actor_id, status, title, updated_at
-                 FROM looms_reviews WHERE actor_id = ?`)
-                    .all(actorId)
+                    .query(`SELECT run_id, review_id, status, title, updated_at
+                 FROM looms_run_reviews WHERE run_id = ?`)
+                    .all(runId)
                 : db
-                    .query(`SELECT review_id, actor_id, status, title, updated_at FROM looms_reviews`)
+                    .query(`SELECT run_id, review_id, status, title, updated_at FROM looms_run_reviews`)
                     .all();
             return rows.map((row) => ({
+                runId: row.run_id,
                 reviewId: row.review_id,
-                actorId: row.actor_id,
                 status: row.status,
                 title: row.title,
                 updatedAt: row.updated_at,

package/dist/react/materialize.js

@@ -1,4 +1,4 @@
-import { isJsonObject, isJsonString } from '@swirls/looms/core';
+import { completedRunStatus, isJsonObject, isJsonString, } from '@swirls/looms/core';
 import { emptyTables } from './tables.js';
 function payloadObject(event) {
     return isJsonObject(event.payload) ? event.payload : {};
@@ -7,6 +7,16 @@ function readString(obj, key) {
     const value = obj[key];
     return isJsonString(value) ? value : undefined;
 }
+function setRunStatus(tables, runId, status) {
+    const existing = tables.runs.get(runId);
+    tables.runs.set(runId, {
+        runId,
+        status,
+        rootThreadId: existing?.rootThreadId ?? null,
+        kind: existing?.kind ?? null,
+        definitionName: existing?.definitionName ?? null,
+    });
+}
 export function materializeEvents(events, from = emptyTables()) {
     const tables = {
         runs: from.runs,
@@ -28,17 +38,12 @@ export function materializeEvents(events, from = emptyTables()) {
                 tables.runs.set(event.runId, next);
                 break;
             }
-            case 'runtime.run.completed': {
-                const existing = tables.runs.get(event.runId);
-                tables.runs.set(event.runId, {
-                    runId: event.runId,
-                    status: readString(payload, 'error') ? 'failed' : 'completed',
-                    rootThreadId: existing?.rootThreadId ?? null,
-                    kind: existing?.kind ?? null,
-                    definitionName: existing?.definitionName ?? null,
-                });
+            case 'runtime.run.completed':
+                setRunStatus(tables, event.runId, completedRunStatus(payload));
+                break;
+            case 'runtime.run.cancelled':
+                setRunStatus(tables, event.runId, 'cancelled');
                 break;
-            }
             case 'runtime.thread.started': {
                 const threadId = readString(payload, 'threadId') ?? event.threadId;
                 const kind = readString(payload, 'kind');

package/dist/react/react.d.ts

@@ -1,5 +1,5 @@
 import { type ReactNode } from 'react';
-import { type ProjectionDefinition, type ThreadTree } from '@swirls/looms/core';
+import { type ProjectionDefinition, type RunStatus, type ThreadTree } from '@swirls/looms/core';
 import { createFold, foldEvents, type EventFoldDefinition } from './derived';
 import type { AnyEventEnvelope, RegisteredEvent } from './register';
 import { createLoomsStore, type CoalesceOption, type LoomsClientStore, type LoomsConnectionStatus } from './store';
@@ -30,7 +30,11 @@ export declare function useProjection<S, TEvent extends AnyEventEnvelope = Regis
 /** 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 {
-    readonly status: string;
+    readonly status: RunStatus;
+    /** True once the run is completed, failed, or cancelled and accepts no new signals. */
+    readonly finished: boolean;
+    /** True when the run failed or was cancelled, so a fork can continue it from where it stopped. */
+    readonly resumable: boolean;
     readonly kind: string | undefined;
     readonly definitionName: string | undefined;
     readonly rootThreadId: string | undefined;

package/dist/react/react.js

@@ -1,6 +1,6 @@
 import { Effect, Fiber } from 'effect';
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
-import { threadTree, toThreadTree } from '@swirls/looms/core';
+import { isTerminalStatus, threadTree, toThreadTree, } from '@swirls/looms/core';
 import { createFold, foldEvents } from './derived.js';
 import { createLoomsStore, } from './store.js';
 const LoomsContext = createContext({ endpoint: '' });
@@ -125,8 +125,11 @@ function shallowEqualSummary(a, b) {
 export function useRunSummary(store) {
     const selector = useCallback((s) => {
         const run = s.getState().runs.get(s.storeId);
+        const status = run?.status ?? 'running';
         return {
-            status: run?.status ?? 'running',
+            status,
+            finished: isTerminalStatus(status),
+            resumable: status === 'failed' || status === 'cancelled',
             kind: run?.kind ?? undefined,
             definitionName: run?.definitionName ?? undefined,
             rootThreadId: run?.rootThreadId ?? undefined,

package/dist/react/tables.d.ts

@@ -1,6 +1,7 @@
+import type { RunStatus, ThreadStatus } from '@swirls/looms/core';
 export interface RunRow {
     runId: string;
-    status: string;
+    status: RunStatus;
     rootThreadId: string | null;
     kind: string | null;
     definitionName: string | null;
@@ -11,7 +12,7 @@ export interface ThreadRow {
     kind: string;
     definitionName: string;
     parentThreadId: string | null;
-    status: string;
+    status: ThreadStatus;
 }
 /** Materialized run/thread rows. Event log lives only in `store.events()` / EventIndex. */
 export interface MaterializedTables {

package/dist/runtime/cancellation.js

@@ -1,29 +1,15 @@
 import { Clock, Effect } from 'effect';
-import { createEvent, EventStoreTag, foldRun, } from '@swirls/looms/core';
+import { createEvent, descendantThreadIds, EventStoreTag, foldRun, } from '@swirls/looms/core';
 import { RuntimeExecutionError } from './errors.js';
 import { waitSatisfiedEvents, workerTask } from './helpers.js';
 import { notifyObserver } from './observer.js';
 import { isWorkerEffect } from './worker-effect-dispatch.js';
-function descendantThreadIds(state, targetThreadId) {
-    return Object.values(state.threads)
-        .filter((record) => {
-        let parentThreadId = record.parentThreadId;
-        while (parentThreadId) {
-            if (parentThreadId === targetThreadId) {
-                return true;
-            }
-            parentThreadId = state.threads[parentThreadId]?.parentThreadId ?? null;
-        }
-        return false;
-    })
-        .map((record) => record.threadId);
-}
 /**
  * Cancel a thread and its descendants. Worker attempts in flight are asked to stop and must
  * acknowledge; attempts waiting to retry were never handed out and are cancelled outright.
  */
 function planCancellation(input) {
-    const { runId, state, registry, now } = input;
+    const { runId, seq, state, registry, now } = input;
     const targetThreadId = input.threadId ?? state.rootThreadId ?? '';
     const idempotencyKey = `cancel:${targetThreadId}`;
     if (state.processedIdempotencyKeys.includes(idempotencyKey)) {
@@ -65,18 +51,18 @@ function planCancellation(input) {
             idempotencyKey,
         }));
     }
-    const threadEvents = [
-        ...descendants.map((_, index) => descendants[descendants.length - 1 - index]),
-        targetThreadId,
-    ]
+    const threadEvents = [...descendants.toReversed(), targetThreadId]
         .filter((threadId) => threadId.length > 0)
-        .map((threadId) => createEvent(runId, {
-        type: 'runtime.thread.cancelled',
-        payload: { threadId, reason: 'cancelled' },
-        threadId,
-        origin: { type: 'external' },
-        idempotencyKey,
-    }));
+        .map((threadId) => {
+        const payload = { threadId, reason: 'cancelled' };
+        return createEvent(runId, {
+            type: 'runtime.thread.cancelled',
+            payload: threadId === targetThreadId ? { ...payload, resumeSeq: seq } : payload,
+            threadId,
+            origin: { type: 'external' },
+            idempotencyKey,
+        });
+    });
     const batch = [...effectEvents, ...threadEvents];
     const folded = foldRun(batch, registry, { runId, initial: state });
     const satisfied = waitSatisfiedEvents(folded, batch).map((event) => createEvent(runId, event));
@@ -91,6 +77,7 @@ export function createCancellation(options) {
             return yield* repository.commit(store, runId, (current) => {
                 const plan = planCancellation({
                     runId,
+                    seq: current.seq,
                     state: current.state,
                     threadId,
                     registry,

package/dist/runtime/errors.d.ts

@@ -19,6 +19,45 @@ export declare class StartRunConflictError extends StartRunConflictError_base<{
 }> {
     constructor(runId: string, requested: RunStartIdentity, existing: DurableRunStartIdentity, mismatches: readonly (keyof RunStartIdentity)[]);
 }
+declare const RunTerminalError_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: "RunTerminalError";
+} & Readonly<A>;
+export declare class RunTerminalError extends RunTerminalError_base<{
+    readonly runId: string;
+    readonly status: string;
+    readonly message: string;
+}> {
+    constructor(runId: string, status: string);
+}
+declare const RunNotFoundError_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: "RunNotFoundError";
+} & Readonly<A>;
+export declare class RunNotFoundError extends RunNotFoundError_base<{
+    readonly runId: string;
+    readonly message: string;
+}> {
+    constructor(runId: string);
+}
+declare const RunNotFinishedError_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: "RunNotFinishedError";
+} & Readonly<A>;
+export declare class RunNotFinishedError extends RunNotFinishedError_base<{
+    readonly runId: string;
+    readonly status: string;
+    readonly message: string;
+}> {
+    constructor(runId: string, status: string);
+}
+declare const ForkConflictError_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: "ForkConflictError";
+} & Readonly<A>;
+export declare class ForkConflictError extends ForkConflictError_base<{
+    readonly runId: string;
+    readonly sourceRunId: string;
+    readonly message: string;
+}> {
+    constructor(runId: string, sourceRunId: string);
+}
 declare const DuplicateEffectDispatchError_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: "DuplicateEffectDispatchError";
 } & Readonly<A>;

package/dist/runtime/errors.js

@@ -11,6 +11,38 @@ export class StartRunConflictError extends Data.TaggedError('StartRunConflictErr
         this.name = 'StartRunConflictError';
     }
 }
+export class RunTerminalError extends Data.TaggedError('RunTerminalError') {
+    constructor(runId, status) {
+        super({ runId, status, message: `Run "${runId}" is ${status} and accepts no new events` });
+        this.name = 'RunTerminalError';
+    }
+}
+export class RunNotFoundError extends Data.TaggedError('RunNotFoundError') {
+    constructor(runId) {
+        super({ runId, message: `Run "${runId}" does not exist` });
+        this.name = 'RunNotFoundError';
+    }
+}
+export class RunNotFinishedError extends Data.TaggedError('RunNotFinishedError') {
+    constructor(runId, status) {
+        super({
+            runId,
+            status,
+            message: `Run "${runId}" is ${status}; only finished runs can be forked`,
+        });
+        this.name = 'RunNotFinishedError';
+    }
+}
+export class ForkConflictError extends Data.TaggedError('ForkConflictError') {
+    constructor(runId, sourceRunId) {
+        super({
+            runId,
+            sourceRunId,
+            message: `Run "${runId}" already exists and is not a fork of "${sourceRunId}"`,
+        });
+        this.name = 'ForkConflictError';
+    }
+}
 export class DuplicateEffectDispatchError extends Data.TaggedError('DuplicateEffectDispatchError') {
     constructor(runId, effectId, threadId) {
         super({

package/dist/runtime/helpers.d.ts

@@ -43,6 +43,8 @@ export declare function threadStartedEvents(definitions: ReadonlyMap<string, Reg
     parentThreadId: string | null;
 }): Effect.Effect<ReadonlyArray<EventInput>, UnknownDefinitionError>;
 export declare function synthesizedThreadFailed(before: RunState, after: RunState, written: readonly EventEnvelope[]): EventInput[];
+/** Cancel whatever is still live below each thread `written` cancels, deepest first. */
+export declare function cascadedCancellations(state: RunState, written: readonly EventEnvelope[]): EventInput[];
 export declare function waitSatisfiedEvents(state: RunState, events: readonly EventEnvelope[]): EventInput[];
 export declare function createEffectFailedEvent(runId: string, item: {
     effectId: string;

package/dist/runtime/helpers.js

@@ -1,5 +1,5 @@
 import { Data, Effect, Layer, Predicate } from 'effect';
-import { asJson, createEvent, definitionKey, makeMemorySnapshotStore, matchingWaits, snapshotStoreOf, validateEventInput, validateEventsEffect, validateInputEffect, withSnapshotStore, InvalidEventError, } from '@swirls/looms/core';
+import { asJson, createEvent, definitionKey, descendantThreadIds, isTerminalStatus, makeMemorySnapshotStore, matchingWaits, snapshotStoreOf, validateEventInput, validateEventsEffect, validateInputEffect, withSnapshotStore, InvalidEventError, } from '@swirls/looms/core';
 export function workerTask(runId, item, attempt) {
     return {
         runId,
@@ -180,6 +180,28 @@ export function synthesizedThreadFailed(before, after, written) {
     }
     return out;
 }
+/** Cancel whatever is still live below each thread `written` cancels, deepest first. */
+export function cascadedCancellations(state, written) {
+    const cancelled = written.flatMap((event) => {
+        if (event.type !== 'runtime.thread.cancelled') {
+            return [];
+        }
+        const payload = Predicate.isObject(event.payload) ? event.payload : {};
+        const threadId = Predicate.isString(payload.threadId) ? payload.threadId : event.threadId;
+        return threadId ? [threadId] : [];
+    });
+    const live = new Set(cancelled
+        .flatMap((threadId) => descendantThreadIds(state, threadId))
+        .filter((threadId) => {
+        const record = state.threads[threadId];
+        return record !== undefined && !isTerminalStatus(record.status);
+    }));
+    return [...live].toReversed().map((threadId) => ({
+        type: 'runtime.thread.cancelled',
+        payload: { threadId, reason: 'cancelled' },
+        threadId,
+    }));
+}
 export function waitSatisfiedEvents(state, events) {
     const produced = [];
     const remaining = { ...state.waits };

package/dist/runtime/index.d.ts

@@ -1,4 +1,4 @@
-export { createRuntime, createTimeoutScheduler, DuplicateEffectDispatchError, MaxWakeIterationsError, RunOverloadedError, StartRunConflictError, type CreateRuntimeOptions, type EffectWorker, type EffectWorkerTask, type LoomsRuntime, type RunOperationalStatus, type RegisteredDefinition, type StartRunArgs, type WakeError, type WakeScheduler, type WorkerCallback, type WorkerCallbackInput, } from './runtime';
+export { createRuntime, createTimeoutScheduler, DuplicateEffectDispatchError, ForkConflictError, MaxWakeIterationsError, RunNotFinishedError, RunNotFoundError, RunOverloadedError, RunTerminalError, StartRunConflictError, type CreateRuntimeOptions, type EffectWorker, type EffectWorkerTask, type LoomsRuntime, type RunOperationalStatus, type RegisteredDefinition, type StartRunArgs, type WakeError, type WakeScheduler, type WorkerCallback, type WorkerCallbackInput, } from './runtime';
 export { createLooms, type Looms, type CreateLoomsOptions, type StartResult } from './looms';
 export { serveHttp, createFetchHandler, isLoomsApiPath, type FetchHandlerOptions, authAllowed, authDenied, bearerAuth, defaultAuthorize, type AuthDecision, type AuthorizedAccess, type Authorize, type BearerTokens, type RouteAccess, type RouteInfo, type RunningServer, type LoomsFetchResult, } from './server';
 export { createEventStreamResponse, type EventStreamOptions } from './sse';

package/dist/runtime/index.js

@@ -1,4 +1,4 @@
-export { createRuntime, createTimeoutScheduler, DuplicateEffectDispatchError, MaxWakeIterationsError, RunOverloadedError, StartRunConflictError, } from './runtime.js';
+export { createRuntime, createTimeoutScheduler, DuplicateEffectDispatchError, ForkConflictError, MaxWakeIterationsError, RunNotFinishedError, RunNotFoundError, RunOverloadedError, RunTerminalError, StartRunConflictError, } from './runtime.js';
 export { createLooms } from './looms.js';
 export { serveHttp, createFetchHandler, isLoomsApiPath, authAllowed, authDenied, bearerAuth, defaultAuthorize, } from './server.js';
 export { createEventStreamResponse } from './sse.js';

package/dist/runtime/looms.d.ts

@@ -89,6 +89,10 @@ export interface Looms {
     project<S>(runId: string, definition: ProjectionDefinition<S>): Promise<S>;
     replayTo(runId: string, seq: number): Promise<ReplayStep | null>;
     cancel(runId: string, threadId?: string): Promise<RunState>;
+    /** Start a new run that continues where a finished run ended. */
+    fork(sourceRunId: string, options?: {
+        runId?: string;
+    }): Promise<StartResult>;
     workerCallback(runId: string, input: WorkerCallbackInput): Promise<RunState>;
     fetch(req: Request): Promise<Response | null>;
     serve(options?: {

package/dist/runtime/looms.js

@@ -98,6 +98,7 @@ export function createLooms(options = {}) {
         project: (runId, definition) => runEffect((i) => i.runtime.project(runId, definition)),
         replayTo: (runId, seq) => runEffect((i) => i.runtime.replayTo(runId, seq)),
         cancel: (runId, threadId) => runEffect((i) => i.runtime.cancel(runId, threadId)),
+        fork: (sourceRunId, forkOpts) => runEffect((i) => i.runtime.fork(sourceRunId, forkOpts)),
         workerCallback: (runId, input) => runEffect((i) => i.runtime.workerCallback(runId, input)),
         fetch: (req) => {
             if (!handlesPath(new URL(req.url).pathname, debuggerMount)) {

package/dist/runtime/run-start.js

@@ -5,9 +5,7 @@ function canonicalJson(value) {
         return `[${value.map(canonicalJson).join(',')}]`;
     }
     if (Predicate.isObject(value)) {
-        const keys = Object.keys(value);
-        // oxlint-disable-next-line unicorn/no-array-sort
-        keys.sort();
+        const keys = Object.keys(value).toSorted();
         return `{${keys
             .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key] ?? null)}`)
             .join(',')}}`;

package/dist/runtime/runtime.d.ts

@@ -2,7 +2,7 @@ import { type AnyRuntimeModule } from '@swirls/looms/core';
 export type { RegisteredDefinition } from '@swirls/looms/core';
 export type { WakeScheduler } from './wake-scheduler';
 export { createTimeoutScheduler } from './wake-scheduler';
-export { DuplicateEffectDispatchError, MaxWakeIterationsError, StartRunConflictError, } from './errors';
+export { DuplicateEffectDispatchError, ForkConflictError, MaxWakeIterationsError, RunNotFinishedError, RunNotFoundError, RunTerminalError, StartRunConflictError, } from './errors';
 export { RunOverloadedError } from './ingress';
 export type { CreateRuntimeOptions, EffectWorker, EffectWorkerTask, LoomsRuntime, RunOperationalStatus, StartResult, StartRunArgs, WakeError, } from './types';
 export type { WorkerCallback, WorkerCallbackInput } from '@swirls/looms/core';