@swirls/looms 0.2.0 → 0.4.0

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,7 +1,6 @@
 import { type ReactNode } from 'react';
-import { type ProjectionDefinition, type ThreadTree } from '@swirls/looms/core';
-import { createFold, foldEvents, type EventFoldDefinition } from './derived';
-import type { AnyEventEnvelope, RegisteredEvent } from './register';
+import { type AnyEventEnvelope, type ProjectionDefinition, type RegisteredEvent, type RunStatus, 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;
@@ -30,7 +29,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;
@@ -51,10 +54,10 @@ export declare function useEventCounts<TEvent extends AnyEventEnvelope = Registe
 export declare function useEventBySeq<TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, seq: number | undefined): TEvent | undefined;
 /** Subscribe to the latest event of a given type. */
 export declare function useLatestEvent<TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, type: string): TEvent | undefined;
-/** Subscribe to a custom incremental fold. */
-export declare function useEventFold<S, TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, fold: EventFoldDefinition<S, TEvent>): S;
+/** Subscribe to a live fold, which includes ephemeral events. */
+export declare function useLiveFold<S, TEvent extends AnyEventEnvelope = RegisteredEvent>(store: LoomsClientStore<TEvent>, fold: LiveFoldDefinition<S, TEvent>): S;
 export { createLoomsStore };
-export { createFold, foldEvents };
+export { defineLiveFold, foldLive };
 export type { LoomsClientStore, LoomsClientStoreOptions, LoomsConnectionStatus, LoomsStoreQuery, CoalesceOption, StoreListener, } from './store';
-export type { EventFoldDefinition } from './derived';
-export type { LoomsRegister, RegisteredEvent, AnyEventEnvelope } from './register';
+export type { LiveFoldDefinition } from './derived';
+export type { LoomsRegister, RegisteredEvent, AnyEventEnvelope } from '@swirls/looms/core';

package/dist/react/react.js

@@ -1,7 +1,7 @@
 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';
+import { isTerminalStatus, 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;
@@ -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,
@@ -162,10 +165,10 @@ export function useLatestEvent(store, type) {
     const selector = useCallback((s) => s.query.latest(type), [type]);
     return useRunSelector(store, selector);
 }
-/** Subscribe to a custom incremental fold. */
-export function useEventFold(store, fold) {
+/** Subscribe to a live fold, which includes ephemeral events. */
+export function useLiveFold(store, fold) {
     const getSnapshot = useCallback(() => store.fold(fold), [store, fold]);
     return useStoreSnapshot(store, getSnapshot);
 }
 export { createLoomsStore };
-export { createFold, foldEvents };
+export { defineLiveFold, foldLive };

package/dist/react/store.d.ts

@@ -1,7 +1,6 @@
-import { type EventInput, type ProjectionDefinition } from '@swirls/looms/core';
-import { type EventFoldDefinition } from './derived';
+import { type AnyEventEnvelope, type EventInput, type ProjectionDefinition, type RegisteredEvent } from '@swirls/looms/core';
+import { type LiveFoldDefinition } from './derived';
 import { type CoalesceOption } from './notify';
-import type { AnyEventEnvelope, RegisteredEvent } from './register';
 import { type MaterializedTables } from './tables';
 export type { CoalesceOption } from './notify';
 /** Fired after the store version bumps. Re-read via `events()` / `getState()` / `query`. */
@@ -30,7 +29,7 @@ export interface LoomsStoreQuery<TEvent extends AnyEventEnvelope = RegisteredEve
     bySeq: (seq: number) => TEvent | undefined;
     startedAt: () => number | undefined;
     latest: (type: string) => TEvent | undefined;
-    fold: <S>(def: EventFoldDefinition<S, TEvent>) => S;
+    fold: <S>(def: LiveFoldDefinition<S, TEvent>) => S;
 }
 export interface LoomsClientStore<TEvent extends AnyEventEnvelope = RegisteredEvent> {
     storeId: string;
@@ -43,7 +42,7 @@ export interface LoomsClientStore<TEvent extends AnyEventEnvelope = RegisteredEv
     query: LoomsStoreQuery<TEvent>;
     subscribe: (listener: StoreListener) => () => void;
     project<S>(definition: ProjectionDefinition<S>): S;
-    fold<S>(definition: EventFoldDefinition<S, TEvent>): S;
+    fold<S>(definition: LiveFoldDefinition<S, TEvent>): S;
     flush: () => void;
     commit: (event: EventInput | readonly EventInput[]) => Promise<void>;
     sync: () => Promise<void>;

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';

package/dist/runtime/runtime.js

@@ -1,8 +1,8 @@
 import { Clock, Effect, ManagedRuntime, Predicate } from 'effect';
-import { composeModules, createEvent, createThreadId, createRunId, DEFAULT_DEFINITION_VERSION, DEFAULT_SNAPSHOT_EVERY, definitionKey, EventStoreTag, foldRun, project, replayTo, summarizeRun, } from '@swirls/looms/core';
+import { composeModules, createEvent, createThreadId, createRunId, DEFAULT_DEFINITION_VERSION, DEFAULT_SNAPSHOT_EVERY, definitionKey, descendantThreadIds, EventStoreTag, foldRun, isRunTerminal, planFork, project, replayTo, summarizeRun, } from '@swirls/looms/core';
 import { createCancellation } from './cancellation.js';
 import { nextRuntimeDeadline } from './deadline-transition-planner.js';
-import { RuntimeExecutionError } from './errors.js';
+import { ForkConflictError, RunNotFinishedError, RunNotFoundError, RunTerminalError, RuntimeExecutionError, } from './errors.js';
 import { admitExternalEvents, moduleServices, resolveSnapshotStore, RunCursorCache, threadStartedEvents, UnknownDefinitionError, validateAndCreateEvents, waitSatisfiedEvents, } from './helpers.js';
 import { createRunIngress } from './ingress.js';
 import { notifyObserver } from './observer.js';
@@ -13,26 +13,21 @@ import { createWakeEngine } from './wake-engine.js';
 import { createTimeoutScheduler } from './wake-scheduler.js';
 import { createWorkerCallbacks } from './worker-callbacks.js';
 export { createTimeoutScheduler } from './wake-scheduler.js';
-export { DuplicateEffectDispatchError, MaxWakeIterationsError, StartRunConflictError, } from './errors.js';
+export { DuplicateEffectDispatchError, ForkConflictError, MaxWakeIterationsError, RunNotFinishedError, RunNotFoundError, RunTerminalError, StartRunConflictError, } from './errors.js';
 export { RunOverloadedError } from './ingress.js';
 function currentTimeMillis() {
     return Math.floor(performance.timeOrigin + performance.now());
 }
-/** Threads whose in-process effects an admitted signal interrupts. */
-function interruptedThreadIds(events, rules) {
-    const threadIds = new Set();
-    for (const event of events) {
+/** Threads whose in-process effects an admitted signal interrupts: each named one and its subtree. */
+function interruptedThreadIds(events, rules, state) {
+    const named = events.flatMap((event) => {
         const payload = Predicate.isObject(event.payload) ? event.payload : {};
-        if (event.type === 'runtime.thread.cancel.requested' && Predicate.isString(payload.threadId)) {
-            threadIds.add(payload.threadId);
-        }
-        for (const rule of rules) {
-            for (const threadId of rule(event)) {
-                threadIds.add(threadId);
-            }
-        }
-    }
-    return threadIds;
+        const cancelled = event.type === 'runtime.thread.cancel.requested' && Predicate.isString(payload.threadId)
+            ? [payload.threadId]
+            : [];
+        return [...cancelled, ...rules.flatMap((rule) => rule(event))];
+    });
+    return new Set(named.flatMap((threadId) => [threadId, ...descendantThreadIds(state, threadId)]));
 }
 const DEFAULT_RUN_CACHE_SIZE = 0;
 const RESCAN_CONCURRENCY = 16;
@@ -83,6 +78,9 @@ export function createRuntime(options) {
                 ...input,
                 idempotencyKey: input.idempotencyKey ?? signalKey,
             })), { origin: { type: 'external' } });
+            if (isRunTerminal(current.state)) {
+                return yield* new RunTerminalError(runId, current.state.status);
+            }
             const folded = foldRun(batch, registry, { runId, initial: current.state });
             const satisfiedEvents = waitSatisfiedEvents(folded, batch).map((input) => createEvent(runId, input));
             return {
@@ -92,7 +90,7 @@ export function createRuntime(options) {
             };
         }));
         if (committed.append) {
-            executionContexts.abort(runId, interruptedThreadIds(events, registry.interruptRules), 'Effect interrupted');
+            executionContexts.abort(runId, interruptedThreadIds(events, registry.interruptRules, committed.value), 'Effect interrupted');
         }
         return committed.value;
     });
@@ -295,6 +293,35 @@ export function createRuntime(options) {
         },
         signal: (runId, events, signalOpts) => admitExternalEvents(events).pipe(Effect.flatMap((admitted) => withRunIngress(runId, signalAdmitted(runId, admitted, signalOpts))), Effect.andThen(runtime.wake(runId))),
         cancel: cancellation,
+        fork: (sourceRunId, forkOptions) => {
+            const runId = forkOptions?.runId ?? createRunId();
+            return withRunIngress(runId, Effect.gen(function* () {
+                const store = yield* EventStoreTag;
+                const source = yield* loadCursor(store, sourceRunId);
+                if (source.seq === 0) {
+                    return yield* new RunNotFoundError(sourceRunId);
+                }
+                if (!isRunTerminal(source.state)) {
+                    return yield* new RunNotFinishedError(sourceRunId, source.state.status);
+                }
+                const plan = yield* planFork({
+                    sourceRunId,
+                    runId,
+                    events: yield* store.read(sourceRunId),
+                    registry,
+                });
+                // Appending at tail 0 numbers the copied events 1..n, the seqs they had in the source.
+                yield* commit(store, runId, (existing) => {
+                    if (existing.seq === 0) {
+                        return Effect.succeed({ events: plan.events, value: undefined });
+                    }
+                    return existing.state.forkedFrom?.runId === sourceRunId
+                        ? Effect.succeed({ events: [], value: undefined })
+                        : Effect.fail(new ForkConflictError(runId, sourceRunId));
+                });
+                return plan.rootThreadId;
+            })).pipe(Effect.flatMap((threadId) => runtime.wake(runId).pipe(Effect.map((state) => ({ runId, threadId, state })))));
+        },
         wake: wakeEngine,
         dispose: Effect.sync(() => scheduler.dispose?.()).pipe(Effect.andThen(services.disposeEffect)),
     };

package/dist/runtime/server/http.d.ts

@@ -29,6 +29,8 @@ export declare const EventInputBodySchema: Schema.Struct<{
 export declare function isLoomsApiPath(path: string): boolean;
 export declare function provideStore<A, E>(effect: Effect.Effect<A, E, EventStoreTag>, store: EventStore): Effect.Effect<A, E>;
 export declare const readJson: (req: Request) => Effect.Effect<JsonValue, RequestBodyError>;
+/** `readJson` for routes whose body is optional: a request without one reads as `{}`. */
+export declare const readOptionalJson: (req: Request) => Effect.Effect<JsonValue, RequestBodyError>;
 export declare function extractIdempotencyKey(req: Request, bodyKey?: string): string | undefined;
 export declare function acceptsEventStream(req: Request): boolean;
 export declare function readIntegerQuery(url: URL, name: string, options: {

package/dist/runtime/server/http.js

@@ -1,6 +1,6 @@
 import { Data, Effect, Schema } from 'effect';
-import { EventStoreTag, InvalidEventError, InvalidInputError, JsonValueSchema, } from '@swirls/looms/core';
-import { RunOverloadedError, StartRunConflictError } from '../runtime.js';
+import { EventStoreTag, ForkSourceError, InvalidEventError, InvalidInputError, JsonValueSchema, } from '@swirls/looms/core';
+import { ForkConflictError, RunNotFinishedError, RunNotFoundError, RunOverloadedError, RunTerminalError, StartRunConflictError, } from '../runtime.js';
 export class RequestBodyError extends Data.TaggedError('RequestBodyError') {
     constructor(cause) {
         super({ cause, message: 'Invalid JSON request body' });
@@ -25,6 +25,10 @@ export const readJson = (req) => Effect.tryPromise({
     try: () => req.json(),
     catch: (cause) => new RequestBodyError(cause),
 }).pipe(Effect.flatMap(Schema.decodeUnknownEffect(JsonValueSchema)), Effect.mapError((cause) => cause instanceof RequestBodyError ? cause : new RequestBodyError(cause)));
+/** `readJson` for routes whose body is optional: a request without one reads as `{}`. */
+export const readOptionalJson = (req) => req.body === null || req.headers.get('content-length') === '0'
+    ? Effect.succeed({})
+    : readJson(req);
 export function extractIdempotencyKey(req, bodyKey) {
     return (bodyKey ??
         req.headers.get('idempotency-key') ??
@@ -59,8 +63,19 @@ export function toErrorResponse(err) {
     if (err instanceof RunOverloadedError) {
         return Response.json({ error: err.message }, { status: 429 });
     }
+    if (err instanceof RunNotFoundError) {
+        return Response.json({ error: err.message }, { status: 404 });
+    }
+    if (err instanceof RunTerminalError) {
+        return Response.json({ error: err.message, status: err.status }, { status: 409 });
+    }
     if (err instanceof StartRunConflictError) {
         return Response.json({ error: err.message, mismatches: err.mismatches }, { status: 409 });
     }
+    if (err instanceof RunNotFinishedError ||
+        err instanceof ForkConflictError ||
+        err instanceof ForkSourceError) {
+        return Response.json({ error: err.message }, { status: 409 });
+    }
     return Response.json({ error: err.message }, { status: 500 });
 }