@swirls/looms 0.4.0 → 0.5.1

package/dist/workflow/module.js

@@ -1,13 +1,14 @@
-import { defineModule } from '@swirls/looms/core';
+import { defineModule, makeDefinitionStore } from '@swirls/looms/core';
 import { WorkflowDefinitionsLive } from './definitions-store.js';
 import { runNodeEffect, scheduleEffect } from './effects.js';
 import { nodes } from './projections.js';
 import { workflowModule } from './scope.js';
 import { workflowThread } from './threads.js';
 export function workflow(options = {}) {
-    const definitions = options.definitions ?? [];
+    const listed = options.definitions ?? [];
+    const definitions = makeDefinitionStore('workflow', listed);
     return defineModule(workflowModule, () => ({
-        definitions,
+        definitions: listed,
         threads: { workflow: workflowThread },
         effects: {
             schedule: scheduleEffect,
@@ -15,5 +16,8 @@ export function workflow(options = {}) {
         },
         projections: { nodes },
         services: () => WorkflowDefinitionsLive(definitions),
+        bindHost(host) {
+            definitions.useResolver(host.definitionResolver);
+        },
     }));
 }

package/dist/workflow/scope.d.ts

@@ -23,6 +23,8 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
         readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
         readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
         readonly loopIndex: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").NullOr<import("effect/Schema").Finite>, never>;
+        readonly execution: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"thread">, import("effect/Schema").Literal<"run">]>, never>;
+        readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
     }>;
     'map.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
@@ -33,6 +35,8 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
         readonly items: import("effect/Schema").$Array<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
         readonly concurrency: import("effect/Schema").Finite;
         readonly limitBytes: import("effect/Schema").Finite;
+        readonly execution: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"thread">, import("effect/Schema").Literal<"run">]>, never>;
+        readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
     }>;
     'sleep.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
@@ -76,6 +80,9 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
                     readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
                 }>, import("effect/Schema").Struct<{
                     readonly type: import("effect/Schema").Literal<"system">;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"run">;
+                    readonly runId: import("effect/Schema").String;
                 }>]>>;
                 readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
                 readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -93,10 +100,24 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
             readonly type: import("effect/Schema").Literal<"runtime.cancel">;
             readonly threadId: import("effect/Schema").String;
             readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.launch">;
+            readonly runId: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").String;
+            readonly definitionName: import("effect/Schema").String;
+            readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
+            readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.cancelRun">;
+            readonly runId: import("effect/Schema").String;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
         }>, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").String;
             readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
             readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly at: import("effect/Schema").optional<import("effect/Schema").Finite>;
         }>]>>;
     }>;
 }>, undefined>, import("@swirls/looms/core").EventCatalog<"workflow", {
@@ -123,6 +144,8 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
         readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
         readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
         readonly loopIndex: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").NullOr<import("effect/Schema").Finite>, never>;
+        readonly execution: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"thread">, import("effect/Schema").Literal<"run">]>, never>;
+        readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
     }>;
     'map.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
@@ -133,6 +156,8 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
         readonly items: import("effect/Schema").$Array<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
         readonly concurrency: import("effect/Schema").Finite;
         readonly limitBytes: import("effect/Schema").Finite;
+        readonly execution: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"thread">, import("effect/Schema").Literal<"run">]>, never>;
+        readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
     }>;
     'sleep.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
@@ -176,6 +201,9 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
                     readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
                 }>, import("effect/Schema").Struct<{
                     readonly type: import("effect/Schema").Literal<"system">;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"run">;
+                    readonly runId: import("effect/Schema").String;
                 }>]>>;
                 readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
                 readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -193,10 +221,24 @@ export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"w
             readonly type: import("effect/Schema").Literal<"runtime.cancel">;
             readonly threadId: import("effect/Schema").String;
             readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.launch">;
+            readonly runId: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").String;
+            readonly definitionName: import("effect/Schema").String;
+            readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
+            readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly close: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"terminate">, import("effect/Schema").Literal<"wait">]>, never>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.cancelRun">;
+            readonly runId: import("effect/Schema").String;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
         }>, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").String;
             readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
             readonly tag: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly at: import("effect/Schema").optional<import("effect/Schema").Finite>;
         }>]>>;
     }>;
 }>, undefined>;

package/dist/workflow/threads.d.ts

@@ -9,6 +9,8 @@ export declare const WorkflowPendingSpawnSchema: Schema.Struct<{
     readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
     readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
     readonly loopIndex: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+    readonly execution: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"thread">, Schema.Literal<"run">]>, never>;
+    readonly close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
 }>;
 export type WorkflowPendingSpawn = Schema.Schema.Type<typeof WorkflowPendingSpawnSchema>;
 export declare const WorkflowPendingMapSchema: Schema.Struct<{
@@ -23,6 +25,8 @@ export declare const WorkflowPendingMapSchema: Schema.Struct<{
     /** Items before this index have been started; later ones wait for a free slot. */
     readonly nextIndex: Schema.Finite;
     readonly outputs: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly execution: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"thread">, Schema.Literal<"run">]>, never>;
+    readonly close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
 }>;
 export type WorkflowPendingMap = Schema.Schema.Type<typeof WorkflowPendingMapSchema>;
 export declare const WorkflowPendingSleepSchema: Schema.Struct<{
@@ -68,6 +72,9 @@ export declare const WorkflowPendingEffectsSchema: Schema.Struct<{
                 readonly actorId: Schema.optional<Schema.String>;
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"system">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"run">;
+                readonly runId: Schema.String;
             }>]>>;
             readonly ephemeral: Schema.optional<Schema.Boolean>;
             readonly id: Schema.optional<Schema.String>;
@@ -85,10 +92,24 @@ export declare const WorkflowPendingEffectsSchema: Schema.Struct<{
         readonly type: Schema.Literal<"runtime.cancel">;
         readonly threadId: Schema.String;
         readonly tag: Schema.optional<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.launch">;
+        readonly runId: Schema.String;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
+        readonly tag: Schema.optional<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.cancelRun">;
+        readonly runId: Schema.String;
+        readonly tag: Schema.optional<Schema.String>;
     }>, Schema.Struct<{
         readonly type: Schema.String;
         readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly tag: Schema.optional<Schema.String>;
+        readonly at: Schema.optional<Schema.Finite>;
     }>]>>>;
 }>;
 export type WorkflowPendingEffects = Schema.Schema.Type<typeof WorkflowPendingEffectsSchema>;
@@ -110,6 +131,9 @@ export declare const WorkflowPendingEmitSchema: Schema.Struct<{
             readonly actorId: Schema.optional<Schema.String>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"system">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run">;
+            readonly runId: Schema.String;
         }>]>>;
         readonly ephemeral: Schema.optional<Schema.Boolean>;
         readonly id: Schema.optional<Schema.String>;
@@ -147,6 +171,8 @@ export declare const WorkflowStateSchema: Schema.Struct<{
         readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
         readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly loopIndex: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+        readonly execution: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"thread">, Schema.Literal<"run">]>, never>;
+        readonly close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
     }>>>;
     readonly pendingMaps: Schema.withDecodingDefaultKey<Schema.mutable<Schema.$Array<Schema.Struct<{
         readonly nodeId: Schema.String;
@@ -160,6 +186,8 @@ export declare const WorkflowStateSchema: Schema.Struct<{
         /** Items before this index have been started; later ones wait for a free slot. */
         readonly nextIndex: Schema.Finite;
         readonly outputs: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly execution: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"thread">, Schema.Literal<"run">]>, never>;
+        readonly close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
     }>>>, never>;
     readonly pendingSleeps: Schema.mutable<Schema.$Array<Schema.Struct<{
         readonly waitId: Schema.String;
@@ -203,6 +231,9 @@ export declare const WorkflowStateSchema: Schema.Struct<{
                     readonly actorId: Schema.optional<Schema.String>;
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"system">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"run">;
+                    readonly runId: Schema.String;
                 }>]>>;
                 readonly ephemeral: Schema.optional<Schema.Boolean>;
                 readonly id: Schema.optional<Schema.String>;
@@ -220,10 +251,24 @@ export declare const WorkflowStateSchema: Schema.Struct<{
             readonly type: Schema.Literal<"runtime.cancel">;
             readonly threadId: Schema.String;
             readonly tag: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.launch">;
+            readonly runId: Schema.String;
+            readonly kind: Schema.String;
+            readonly definitionName: Schema.String;
+            readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
+            readonly tag: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.cancelRun">;
+            readonly runId: Schema.String;
+            readonly tag: Schema.optional<Schema.String>;
         }>, Schema.Struct<{
             readonly type: Schema.String;
             readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
             readonly tag: Schema.optional<Schema.String>;
+            readonly at: Schema.optional<Schema.Finite>;
         }>]>>>;
     }>>>;
     readonly pendingEmits: Schema.mutable<Schema.$Array<Schema.Struct<{
@@ -244,6 +289,9 @@ export declare const WorkflowStateSchema: Schema.Struct<{
                 readonly actorId: Schema.optional<Schema.String>;
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"system">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"run">;
+                readonly runId: Schema.String;
             }>]>>;
             readonly ephemeral: Schema.optional<Schema.Boolean>;
             readonly id: Schema.optional<Schema.String>;
@@ -288,6 +336,8 @@ export declare const workflowThread: import("@swirls/looms/core").ThreadDefiniti
         readonly attempt: number;
         readonly input: Schema.Json;
         readonly loopIndex: number | null;
+        readonly execution: "run" | "thread";
+        readonly close: "terminate" | "wait";
     }[];
     readonly pendingMaps: {
         readonly nodeId: string;
@@ -302,6 +352,8 @@ export declare const workflowThread: import("@swirls/looms/core").ThreadDefiniti
         readonly outputs: {
             readonly [x: string]: Schema.Json;
         };
+        readonly execution: "run" | "thread";
+        readonly close: "terminate" | "wait";
     }[];
     readonly pendingSleeps: {
         readonly waitId: string;
@@ -345,6 +397,9 @@ export declare const workflowThread: import("@swirls/looms/core").ThreadDefiniti
                     readonly actorId?: string | undefined;
                 } | {
                     readonly type: "system";
+                } | {
+                    readonly type: "run";
+                    readonly runId: string;
                 } | undefined;
                 readonly ephemeral?: boolean | undefined;
                 readonly id?: string | undefined;
@@ -362,10 +417,24 @@ export declare const workflowThread: import("@swirls/looms/core").ThreadDefiniti
             readonly type: "runtime.cancel";
             readonly threadId: string;
             readonly tag?: string | undefined;
+        } | {
+            readonly type: "runtime.launch";
+            readonly runId: string;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly input: Schema.Json;
+            readonly close: "terminate" | "wait";
+            readonly tag?: string | undefined;
+        } | {
+            readonly type: "runtime.cancelRun";
+            readonly runId: string;
+            readonly tag?: string | undefined;
         } | {
             readonly type: string;
             readonly input: Schema.Json;
             readonly tag?: string | undefined;
+            readonly at?: number | undefined;
         })[];
     }[];
     readonly pendingEmits: {
@@ -386,6 +455,9 @@ export declare const workflowThread: import("@swirls/looms/core").ThreadDefiniti
                 readonly actorId?: string | undefined;
             } | {
                 readonly type: "system";
+            } | {
+                readonly type: "run";
+                readonly runId: string;
             } | undefined;
             readonly ephemeral?: boolean | undefined;
             readonly id?: string | undefined;

package/dist/workflow/threads.js

@@ -1,5 +1,5 @@
 import { Effect, Predicate, Schema } from 'effect';
-import { cancel, createWaitId, DEFAULT_DEFINITION_VERSION, EventInputSchema, emit, fail, invoke, isJsonObject, isWithdrawnError, RuntimeEffectSchema, spawn, stableEffectId, wait, utf8JsonBytes, waitOutcome, } from '@swirls/looms/core';
+import { cancel, cancelRun, createWaitId, DEFAULT_DEFINITION_VERSION, deterministicRunId, EventInputSchema, emit, fail, invoke, isJsonObject, isWithdrawnError, launch, RuntimeEffectSchema, spawn, stableEffectId, wait, utf8JsonBytes, waitOutcome, } from '@swirls/looms/core';
 import { NodeStateSchema } from './definitions.js';
 import { runNodeEffect, scheduleEffect } from './effects.js';
 import { iterationChildWorkflowId, nodeRunKey, WorkflowValueTooLargeError } from './graph.js';
@@ -15,6 +15,8 @@ export const WorkflowPendingSpawnSchema = Schema.Struct({
     attempt: attemptNumber,
     input: Schema.Json,
     loopIndex: Schema.NullOr(Schema.Finite).pipe(Schema.withDecodingDefaultKey(Effect.succeed(null))),
+    execution: Schema.Union([Schema.Literal('thread'), Schema.Literal('run')]).pipe(Schema.withDecodingDefaultKey(Effect.succeed('thread'))),
+    close: Schema.Union([Schema.Literal('terminate'), Schema.Literal('wait')]).pipe(Schema.withDecodingDefaultKey(Effect.succeed('terminate'))),
 });
 export const WorkflowPendingMapSchema = Schema.Struct({
     nodeId: Schema.String,
@@ -28,6 +30,8 @@ export const WorkflowPendingMapSchema = Schema.Struct({
     /** Items before this index have been started; later ones wait for a free slot. */
     nextIndex: Schema.Finite,
     outputs: Schema.Record(Schema.String, Schema.Json),
+    execution: Schema.Union([Schema.Literal('thread'), Schema.Literal('run')]).pipe(Schema.withDecodingDefaultKey(Effect.succeed('thread'))),
+    close: Schema.Union([Schema.Literal('terminate'), Schema.Literal('wait')]).pipe(Schema.withDecodingDefaultKey(Effect.succeed('terminate'))),
 });
 export const WorkflowPendingSleepSchema = Schema.Struct({
     waitId: Schema.String,
@@ -87,7 +91,26 @@ function runNodeInvocation(state, nodeId) {
         nodes: state.nodes,
     }, `runNode_${nodeRunKey(nodeId, attempts, node?.iteration?.index)}`);
 }
-function spawnAndWait(threadId, child, childThreadId, input, tag) {
+function spawnAndWait(runId, threadId, child, childThreadId, input, tag) {
+    if (child.execution === 'run') {
+        const childRunId = deterministicRunId(runId, childThreadId);
+        return [
+            launch({
+                runId: childRunId,
+                kind: child.kind,
+                definitionName: child.definitionName,
+                definitionVersion: child.definitionVersion,
+                input,
+                close: child.close,
+                tag: `launch_${childRunId}`,
+            }),
+            wait({
+                waitId: createWaitId(threadId, `spawn_${childRunId}`),
+                on: { type: 'runtime.child.settled', match: { runId: childRunId } },
+                tag,
+            }),
+        ];
+    }
     return [
         spawn({
             childThreadId,
@@ -106,11 +129,17 @@ function spawnAndWait(threadId, child, childThreadId, input, tag) {
         }),
     ];
 }
+function childMode(execution, close) {
+    return {
+        execution: execution === 'run' ? 'run' : 'thread',
+        close: close === 'wait' ? 'wait' : 'terminate',
+    };
+}
 function mapChildThreadId(threadId, map, index) {
     return iterationChildWorkflowId(threadId, map.nodeId, 'map', map.attempt, index);
 }
 /** Every effect a node currently needs, attributed to that node. */
-function nodeEffects(state, threadId) {
+function nodeEffects(state, threadId, runId) {
     const effects = [];
     const add = (nodeId, items) => {
         for (const effect of items) {
@@ -122,7 +151,7 @@ function nodeEffects(state, threadId) {
     }
     for (const item of state.pendingSpawns) {
         const tag = { nodeId: item.nodeId, attempt: item.attempt };
-        add(item.nodeId, spawnAndWait(threadId, item, item.childThreadId, item.input, {
+        add(item.nodeId, spawnAndWait(runId, threadId, item, item.childThreadId, item.input, {
             ...tag,
             loopIndex: item.loopIndex,
         }));
@@ -130,7 +159,7 @@ function nodeEffects(state, threadId) {
     for (const map of state.pendingMaps) {
         for (let index = 0; index < map.nextIndex; index++) {
             if (!(String(index) in map.outputs)) {
-                add(map.nodeId, spawnAndWait(threadId, map, mapChildThreadId(threadId, map, index), map.items[index] ?? null, { nodeId: map.nodeId, attempt: map.attempt, index }));
+                add(map.nodeId, spawnAndWait(runId, threadId, map, mapChildThreadId(threadId, map, index), map.items[index] ?? null, { nodeId: map.nodeId, attempt: map.attempt, index }));
             }
         }
     }
@@ -144,50 +173,80 @@ function nodeEffects(state, threadId) {
     }
     return effects;
 }
-function nodeIdForEffect(state, threadId, effectId) {
-    const match = nodeEffects(state, threadId).find((item) => stableEffectId(threadId, item.effect) === effectId);
+function nodeIdForEffect(state, threadId, runId, effectId) {
+    const match = nodeEffects(state, threadId, runId).find((item) => stableEffectId(threadId, item.effect) === effectId);
     return match?.nodeId ?? null;
 }
+function childTarget(runId, childThreadId, execution) {
+    return execution === 'run' ? deterministicRunId(runId, childThreadId) : childThreadId;
+}
 /** Children a node started that have not reported back yet. */
-function unsettledChildren(state, nodeId, threadId) {
-    const children = state.pendingSpawns
-        .filter((item) => item.nodeId === nodeId)
-        .map((item) => item.childThreadId);
+function unsettledChildren(state, nodeId, threadId, runId) {
+    const children = [];
+    for (const item of state.pendingSpawns) {
+        if (item.nodeId !== nodeId) {
+            continue;
+        }
+        const execution = item.execution === 'run' ? 'run' : 'thread';
+        children.push({
+            key: item.childThreadId,
+            target: childTarget(runId, item.childThreadId, execution),
+            execution,
+            close: item.close === 'wait' ? 'wait' : 'terminate',
+        });
+    }
     for (const map of state.pendingMaps) {
         if (map.nodeId !== nodeId) {
             continue;
         }
+        const execution = map.execution === 'run' ? 'run' : 'thread';
+        const close = map.close === 'wait' ? 'wait' : 'terminate';
         for (let index = 0; index < map.nextIndex; index++) {
-            if (!(String(index) in map.outputs)) {
-                children.push(mapChildThreadId(threadId, map, index));
+            if (String(index) in map.outputs) {
+                continue;
             }
+            const key = mapChildThreadId(threadId, map, index);
+            children.push({
+                key,
+                target: childTarget(runId, key, execution),
+                execution,
+                close,
+            });
         }
     }
     return children;
 }
 /**
  * Drops a node's pending work and cancels the children it leaves running. `settled` is the child
- * whose result is finishing the node, which must not be cancelled.
+ * whose result is finishing the node, which must not be cancelled. A `wait` child run stays
+ * pending until it settles, so the node does not finish ahead of that cancellation.
  */
-function withoutPendingWork(state, nodeId, threadId, settled = null) {
-    const cancels = unsettledChildren(state, nodeId, threadId).filter((childThreadId) => childThreadId !== settled && !state.pendingCancels.includes(childThreadId));
+function withoutPendingWork(state, nodeId, threadId, runId, settled = null) {
+    const children = unsettledChildren(state, nodeId, threadId, runId);
+    const cancels = children
+        .map((child) => child.target)
+        .filter((target) => target !== settled && !state.pendingCancels.includes(target));
+    const keptSpawns = new Set(children
+        .filter((child) => child.execution === 'run' && child.close === 'wait' && child.target !== settled)
+        .map((child) => child.key));
+    const keepMap = children.some((child) => child.execution === 'run' && child.close === 'wait' && child.target !== settled);
     return {
         ...state,
         pendingCancels: cancels.length === 0 ? state.pendingCancels : [...state.pendingCancels, ...cancels],
-        pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
-        pendingMaps: state.pendingMaps.filter((item) => item.nodeId !== nodeId),
+        pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId || keptSpawns.has(item.childThreadId)),
+        pendingMaps: state.pendingMaps.filter((item) => item.nodeId !== nodeId || keepMap),
         pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
         pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
     };
 }
-function stopNode(state, nodeId, threadId) {
+function stopNode(state, nodeId, threadId, runId) {
     return {
-        ...withoutPendingWork(state, nodeId, threadId),
+        ...withoutPendingWork(state, nodeId, threadId, runId),
         runningNodes: state.runningNodes.filter((id) => id !== nodeId),
     };
 }
 /** Drops a node's pending work and emits the event that durably finishes it. */
-function finishNode(state, nodeId, result, error, threadId, settled = null) {
+function finishNode(state, nodeId, result, error, threadId, runId, settled = null) {
     const id = `finished_${nodeId}`;
     const event = {
         type: 'workflow.node.finished',
@@ -195,24 +254,25 @@ function finishNode(state, nodeId, result, error, threadId, settled = null) {
         threadId,
     };
     return {
-        ...withoutPendingWork(state, nodeId, threadId, settled),
+        ...withoutPendingWork(state, nodeId, threadId, runId, settled),
         pendingEmits: [...state.pendingEmits.filter((item) => item.id !== id), { id, event }],
     };
 }
-function recordMapOutput(state, map, index, output, threadId) {
+function recordMapOutput(state, map, index, output, threadId, runId) {
     if (String(index) in map.outputs) {
         return state;
     }
-    const settled = mapChildThreadId(threadId, map, index);
+    const childThreadId = mapChildThreadId(threadId, map, index);
+    const settled = childTarget(runId, childThreadId, map.execution === 'run' ? 'run' : 'thread');
     const outputs = { ...map.outputs, [String(index)]: output };
     const size = utf8JsonBytes(outputs);
     if (size > map.limitBytes) {
         const error = new WorkflowValueTooLargeError(`Node ${map.nodeId} outputs`, size, map.limitBytes);
-        return finishNode(state, map.nodeId, null, error.message, threadId, settled);
+        return finishNode(state, map.nodeId, null, error.message, threadId, runId, settled);
     }
     if (Object.keys(outputs).length === map.items.length) {
         const ordered = map.items.map((_, i) => outputs[String(i)] ?? null);
-        return finishNode(state, map.nodeId, ordered, null, threadId, settled);
+        return finishNode(state, map.nodeId, ordered, null, threadId, runId, settled);
     }
     const nextIndex = Math.min(map.items.length, map.nextIndex + 1);
     return {
@@ -298,7 +358,7 @@ export const workflowThread = workflowModule.thread({
                 }
                 const failed = Predicate.isString(error) && error.length > 0;
                 return {
-                    ...stopNode(state, nodeId, ctx.threadId),
+                    ...stopNode(state, nodeId, ctx.threadId, ctx.runId),
                     nodes: {
                         ...state.nodes,
                         [nodeId]: {
@@ -317,7 +377,7 @@ export const workflowThread = workflowModule.thread({
             case 'workflow.node.skipped': {
                 const { nodeId, reason, cause } = event.payload;
                 return {
-                    ...stopNode(state, nodeId, ctx.threadId),
+                    ...stopNode(state, nodeId, ctx.threadId, ctx.runId),
                     nodes: {
                         ...state.nodes,
                         [nodeId]: {
@@ -340,7 +400,10 @@ export const workflowThread = workflowModule.thread({
                     ...state,
                     pendingSpawns: [
                         ...state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
-                        event.payload,
+                        {
+                            ...event.payload,
+                            ...childMode(event.payload.execution, event.payload.close),
+                        },
                     ],
                 };
             }
@@ -355,6 +418,7 @@ export const workflowThread = workflowModule.thread({
                         ...state.pendingMaps.filter((item) => item.nodeId !== nodeId),
                         {
                             ...event.payload,
+                            ...childMode(event.payload.execution, event.payload.close),
                             nextIndex: Math.min(event.payload.concurrency, event.payload.items.length),
                             outputs: {},
                         },
@@ -408,14 +472,14 @@ export const workflowThread = workflowModule.thread({
                 }
                 const effectId = event.payload.effectId;
                 const nodeId = Predicate.isString(effectId)
-                    ? nodeIdForEffect(state, ctx.threadId, effectId)
+                    ? nodeIdForEffect(state, ctx.threadId, ctx.runId, effectId)
                     : null;
                 if (!nodeId) {
                     return state;
                 }
                 const message = `Node ${nodeId} failed: ${error}`;
                 return {
-                    ...finishNode(stopNode(state, nodeId, ctx.threadId), nodeId, null, message, ctx.threadId),
+                    ...finishNode(stopNode(state, nodeId, ctx.threadId, ctx.runId), nodeId, null, message, ctx.threadId, ctx.runId),
                     nodes: {
                         ...state.nodes,
                         [nodeId]: {
@@ -439,7 +503,7 @@ export const workflowThread = workflowModule.thread({
                 const { result, error } = waitOutcome(event.payload.event, tag, { waited: true });
                 const map = state.pendingMaps.find((item) => item.nodeId === nodeId);
                 if (error === null && map && Predicate.isNumber(tag.index)) {
-                    return recordMapOutput(state, map, tag.index, result, ctx.threadId);
+                    return recordMapOutput(state, map, tag.index, result, ctx.threadId, ctx.runId);
                 }
                 const node = state.nodes[nodeId];
                 if (error === null && node && Predicate.isNumber(tag.loopIndex)) {
@@ -454,10 +518,14 @@ export const workflowThread = workflowModule.thread({
                 }
                 const satisfied = event.payload.event;
                 const satisfiedPayload = Predicate.isObject(satisfied) ? satisfied.payload : undefined;
-                const settled = Predicate.isObject(satisfiedPayload) && Predicate.isString(satisfiedPayload.threadId)
-                    ? satisfiedPayload.threadId
+                const settled = Predicate.isObject(satisfiedPayload)
+                    ? Predicate.isString(satisfiedPayload.runId)
+                        ? satisfiedPayload.runId
+                        : Predicate.isString(satisfiedPayload.threadId)
+                            ? satisfiedPayload.threadId
+                            : null
                     : null;
-                return finishNode(state, nodeId, result, error, ctx.threadId, settled);
+                return finishNode(state, nodeId, result, error, ctx.threadId, ctx.runId, settled);
             }
             default:
                 return state;
@@ -468,14 +536,14 @@ export const workflowThread = workflowModule.thread({
         if (state.needsSchedule) {
             effects.push(scheduleInvocation(state));
         }
-        for (const item of nodeEffects(state, ctx.threadId)) {
+        for (const item of nodeEffects(state, ctx.threadId, ctx.runId)) {
             effects.push(item.effect);
         }
         for (const emitReq of state.pendingEmits) {
             effects.push(emit(emitReq.event));
         }
-        for (const childThreadId of state.pendingCancels) {
-            effects.push(cancel(childThreadId));
+        for (const childId of state.pendingCancels) {
+            effects.push(childId.startsWith('run_') ? cancelRun(childId, `cancel_${childId}`) : cancel(childId));
         }
         if (state.status === 'failed') {
             effects.push(fail(state.error ?? 'Workflow execution failed'));