@swirls/looms 0.0.2 → 0.2.0

package/dist/workflow/module.d.ts

@@ -10,44 +10,204 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
         readonly nodeId: import("effect/Schema").String;
         readonly result: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
         readonly error: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly branch: import("effect/Schema").optional<import("effect/Schema").String>;
     }>;
     'node.skipped': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
         readonly reason: import("effect/Schema").String;
+        readonly cause: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"inactive">, import("effect/Schema").Literal<"policy">]>, never>;
     }>;
     'spawn.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
+        readonly attempt: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Finite, never>;
         readonly childThreadId: 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 loopIndex: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").NullOr<import("effect/Schema").Finite>, never>;
+    }>;
+    'map.requested': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly attempt: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").Finite, never>;
+        readonly kind: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").String;
+        readonly definitionVersion: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").String, never>;
+        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;
     }>;
     'sleep.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
         readonly waitId: import("effect/Schema").String;
-        readonly wakeAt: import("effect/Schema").Number;
+        readonly wakeAt: import("effect/Schema").Finite;
     }>;
     'effects.requested': import("effect/Schema").Struct<{
         readonly nodeId: import("effect/Schema").String;
-        readonly effects: import("effect/Schema").$Array<import("effect/Schema").Schema<import("@swirls/looms/core").RuntimeEffect>>;
+        readonly effects: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.spawn">;
+            readonly childThreadId: 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>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.wait">;
+            readonly waitId: import("effect/Schema").String;
+            readonly on: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>]>;
+                readonly match: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+            }>, import("effect/Schema").Struct<{
+                readonly timerAt: import("effect/Schema").Finite;
+            }>]>;
+            readonly tag: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.emit">;
+            readonly event: import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").String;
+                readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly threadId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly parentThreadId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly causationId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly correlationId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly effectId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+                readonly origin: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"thread">;
+                    readonly threadId: import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"external">;
+                    readonly actorId: import("effect/Schema").optional<import("effect/Schema").String>;
+                }>, import("effect/Schema").Struct<{
+                    readonly type: import("effect/Schema").Literal<"system">;
+                }>]>>;
+                readonly ephemeral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly id: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly ts: import("effect/Schema").optional<import("effect/Schema").Finite>;
+                readonly idempotencyKey: import("effect/Schema").optional<import("effect/Schema").NullOr<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.complete">;
+            readonly output: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"runtime.fail">;
+            readonly error: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            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").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>;
+        }>]>>;
     }>;
 }>, {
     schedule: import("@swirls/looms/core").EffectDefinition<{
         readonly definitionName?: string | undefined;
+        readonly definitionVersion: string;
         readonly nodes?: {
             readonly [x: string]: {
                 readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
                 readonly result: import("effect/Schema").Json;
                 readonly error: string | null;
+                readonly attempts?: number | undefined;
+                readonly branch?: string | undefined;
+                readonly skipCause?: "inactive" | "policy" | undefined;
+                readonly iteration?: {
+                    readonly index: number;
+                    readonly previous: import("effect/Schema").Json;
+                } | undefined;
             };
         } | undefined;
         readonly input?: import("effect/Schema").Json | undefined;
     }, import("./definitions-store").WorkflowDefinitionsTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.ambiguous";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.attempt.started";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.cancel.requested";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.cancelled";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.completed";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.dispatched";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.failed";
         readonly payload: {
             readonly effectId: string;
             readonly error: string;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.heartbeat";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly heartbeatAt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.queued";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.retry.scheduled";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly nextAttemptAt: number;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.timed_out";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly timeout: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.worker.started";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.cancelled";
+        readonly payload: {
+            readonly reason?: string | undefined;
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.run.completed";
         readonly payload: {
@@ -60,7 +220,9 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly rootThreadId?: string | undefined;
             readonly kind: string;
             readonly definitionName: string;
+            readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
+            readonly requestedThreadId?: string | null | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.signal.received";
@@ -74,6 +236,11 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly stateHash: string;
             readonly state?: import("effect/Schema").Json | undefined;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.cancel.requested";
+        readonly payload: {
+            readonly threadId: string;
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.thread.cancelled";
         readonly payload: {
@@ -98,6 +265,7 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly threadId: string;
             readonly kind: string;
             readonly definitionName: string;
+            readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
             readonly parentThreadId: string | null;
         };
@@ -142,7 +310,75 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
         readonly type: "workflow.effects.requested";
         readonly payload: {
             readonly nodeId: string;
-            readonly effects: readonly import("@swirls/looms/core").RuntimeEffect[];
+            readonly effects: readonly ({
+                readonly type: "runtime.spawn";
+                readonly childThreadId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly input: import("effect/Schema").Json;
+            } | {
+                readonly type: "runtime.wait";
+                readonly waitId: string;
+                readonly on: {
+                    readonly type: string | readonly string[];
+                    readonly match?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly timerAt: number;
+                };
+                readonly tag?: import("effect/Schema").Json | undefined;
+            } | {
+                readonly type: "runtime.emit";
+                readonly event: {
+                    readonly type: string;
+                    readonly payload: import("effect/Schema").Json;
+                    readonly threadId?: string | null | undefined;
+                    readonly parentThreadId?: string | null | undefined;
+                    readonly causationId?: string | null | undefined;
+                    readonly correlationId?: string | null | undefined;
+                    readonly effectId?: string | null | undefined;
+                    readonly origin?: {
+                        readonly type: "thread";
+                        readonly threadId: string;
+                    } | {
+                        readonly type: "external";
+                        readonly actorId?: string | undefined;
+                    } | {
+                        readonly type: "system";
+                    } | undefined;
+                    readonly ephemeral?: boolean | undefined;
+                    readonly id?: string | undefined;
+                    readonly ts?: number | undefined;
+                    readonly idempotencyKey?: string | null | undefined;
+                };
+                readonly tag?: string | undefined;
+            } | {
+                readonly type: "runtime.complete";
+                readonly output: import("effect/Schema").Json;
+            } | {
+                readonly type: "runtime.fail";
+                readonly error: string;
+            } | {
+                readonly type: "runtime.cancel";
+                readonly threadId: string;
+                readonly tag?: string | undefined;
+            } | {
+                readonly type: string;
+                readonly input: import("effect/Schema").Json;
+                readonly tag?: string | undefined;
+            })[];
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "workflow.map.requested";
+        readonly payload: {
+            readonly nodeId: string;
+            readonly attempt: number;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly items: readonly import("effect/Schema").Json[];
+            readonly concurrency: number;
+            readonly limitBytes: number;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "workflow.node.finished";
@@ -150,12 +386,14 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly nodeId: string;
             readonly result: import("effect/Schema").Json;
             readonly error: string | null;
+            readonly branch?: string | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "workflow.node.skipped";
         readonly payload: {
             readonly nodeId: string;
             readonly reason: string;
+            readonly cause: "inactive" | "policy";
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "workflow.node.started";
@@ -173,25 +411,126 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
         readonly type: "workflow.spawn.requested";
         readonly payload: {
             readonly nodeId: string;
+            readonly attempt: number;
             readonly childThreadId: string;
             readonly kind: string;
             readonly definitionName: string;
+            readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
+            readonly loopIndex: number | null;
         };
     })>;
     runNode: import("@swirls/looms/core").EffectDefinition<{
         readonly definitionName?: string | undefined;
+        readonly definitionVersion: string;
         readonly nodeId: string;
+        readonly attempt: number;
+        readonly iteration?: {
+            readonly index: number;
+            readonly previous: import("effect/Schema").Json;
+        } | undefined;
         readonly input?: import("effect/Schema").Json | undefined;
-        readonly results?: {
-            readonly [x: string]: import("effect/Schema").Json;
+        readonly nodes?: {
+            readonly [x: string]: {
+                readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
+                readonly result: import("effect/Schema").Json;
+                readonly error: string | null;
+                readonly attempts?: number | undefined;
+                readonly branch?: string | undefined;
+                readonly skipCause?: "inactive" | "policy" | undefined;
+                readonly iteration?: {
+                    readonly index: number;
+                    readonly previous: import("effect/Schema").Json;
+                } | undefined;
+            };
         } | undefined;
     }, import("./definitions-store").WorkflowDefinitionsTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.ambiguous";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.attempt.started";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.cancel.requested";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.cancelled";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.completed";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.dispatched";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.effect.failed";
         readonly payload: {
             readonly effectId: string;
             readonly error: string;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.heartbeat";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly heartbeatAt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.queued";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.retry.scheduled";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly nextAttemptAt: number;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.timed_out";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly timeout: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.worker.started";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.cancelled";
+        readonly payload: {
+            readonly reason?: string | undefined;
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.run.completed";
         readonly payload: {
@@ -204,7 +543,9 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly rootThreadId?: string | undefined;
             readonly kind: string;
             readonly definitionName: string;
+            readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
+            readonly requestedThreadId?: string | null | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.signal.received";
@@ -218,6 +559,11 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly stateHash: string;
             readonly state?: import("effect/Schema").Json | undefined;
         };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.cancel.requested";
+        readonly payload: {
+            readonly threadId: string;
+        };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "runtime.thread.cancelled";
         readonly payload: {
@@ -242,6 +588,7 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly threadId: string;
             readonly kind: string;
             readonly definitionName: string;
+            readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
             readonly parentThreadId: string | null;
         };
@@ -286,7 +633,75 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
         readonly type: "workflow.effects.requested";
         readonly payload: {
             readonly nodeId: string;
-            readonly effects: readonly import("@swirls/looms/core").RuntimeEffect[];
+            readonly effects: readonly ({
+                readonly type: "runtime.spawn";
+                readonly childThreadId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly input: import("effect/Schema").Json;
+            } | {
+                readonly type: "runtime.wait";
+                readonly waitId: string;
+                readonly on: {
+                    readonly type: string | readonly string[];
+                    readonly match?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly timerAt: number;
+                };
+                readonly tag?: import("effect/Schema").Json | undefined;
+            } | {
+                readonly type: "runtime.emit";
+                readonly event: {
+                    readonly type: string;
+                    readonly payload: import("effect/Schema").Json;
+                    readonly threadId?: string | null | undefined;
+                    readonly parentThreadId?: string | null | undefined;
+                    readonly causationId?: string | null | undefined;
+                    readonly correlationId?: string | null | undefined;
+                    readonly effectId?: string | null | undefined;
+                    readonly origin?: {
+                        readonly type: "thread";
+                        readonly threadId: string;
+                    } | {
+                        readonly type: "external";
+                        readonly actorId?: string | undefined;
+                    } | {
+                        readonly type: "system";
+                    } | undefined;
+                    readonly ephemeral?: boolean | undefined;
+                    readonly id?: string | undefined;
+                    readonly ts?: number | undefined;
+                    readonly idempotencyKey?: string | null | undefined;
+                };
+                readonly tag?: string | undefined;
+            } | {
+                readonly type: "runtime.complete";
+                readonly output: import("effect/Schema").Json;
+            } | {
+                readonly type: "runtime.fail";
+                readonly error: string;
+            } | {
+                readonly type: "runtime.cancel";
+                readonly threadId: string;
+                readonly tag?: string | undefined;
+            } | {
+                readonly type: string;
+                readonly input: import("effect/Schema").Json;
+                readonly tag?: string | undefined;
+            })[];
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "workflow.map.requested";
+        readonly payload: {
+            readonly nodeId: string;
+            readonly attempt: number;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly items: readonly import("effect/Schema").Json[];
+            readonly concurrency: number;
+            readonly limitBytes: number;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "workflow.node.finished";
@@ -294,12 +709,14 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly nodeId: string;
             readonly result: import("effect/Schema").Json;
             readonly error: string | null;
+            readonly branch?: string | undefined;
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "workflow.node.skipped";
         readonly payload: {
             readonly nodeId: string;
             readonly reason: string;
+            readonly cause: "inactive" | "policy";
         };
     }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
         readonly type: "workflow.node.started";
@@ -317,141 +734,155 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
         readonly type: "workflow.spawn.requested";
         readonly payload: {
             readonly nodeId: string;
+            readonly attempt: number;
             readonly childThreadId: string;
             readonly kind: string;
             readonly definitionName: string;
+            readonly definitionVersion: string;
             readonly input: import("effect/Schema").Json;
+            readonly loopIndex: number | null;
         };
     })>;
 }, {
     workflow: import("@swirls/looms/core").ThreadDefinition<{
-        definitionName?: string;
-        concurrency: number;
-        input: import("@swirls/looms/core").JsonValue;
-        nodeIds: string[];
-        nodes: {
-            [x: string]: {
+        readonly definitionName?: string | undefined;
+        readonly definitionVersion?: string | undefined;
+        readonly nodes: {
+            readonly [x: string]: {
                 readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
                 readonly result: import("effect/Schema").Json;
                 readonly error: string | null;
+                readonly attempts?: number | undefined;
+                readonly branch?: string | undefined;
+                readonly skipCause?: "inactive" | "policy" | undefined;
+                readonly iteration?: {
+                    readonly index: number;
+                    readonly previous: import("effect/Schema").Json;
+                } | undefined;
+            };
+        };
+        readonly concurrency: number;
+        readonly input: import("effect/Schema").Json;
+        readonly nodeIds: string[];
+        readonly needsSchedule: boolean;
+        readonly runningNodes: string[];
+        readonly pendingSpawns: {
+            readonly childThreadId: string;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly nodeId: string;
+            readonly attempt: number;
+            readonly input: import("effect/Schema").Json;
+            readonly loopIndex: number | null;
+        }[];
+        readonly pendingMaps: {
+            readonly nodeId: string;
+            readonly attempt: number;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly items: readonly import("effect/Schema").Json[];
+            readonly concurrency: number;
+            readonly limitBytes: number;
+            readonly nextIndex: number;
+            readonly outputs: {
+                readonly [x: string]: import("effect/Schema").Json;
+            };
+        }[];
+        readonly pendingSleeps: {
+            readonly waitId: string;
+            readonly wakeAt: number;
+            readonly nodeId: string;
+        }[];
+        readonly pendingEffects: {
+            readonly nodeId: string;
+            readonly effects: ({
+                readonly type: "runtime.spawn";
+                readonly childThreadId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly input: import("effect/Schema").Json;
             } | {
-                status: string;
-                result: string | number | boolean | import("effect/Schema").JsonArray | import("effect/Schema").JsonObject | null;
-                error: string | null;
-            };
-        };
-        runningNodes: string[];
-        pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-        pendingSleeps: import("./threads").WorkflowPendingSleep[];
-        pendingEffects: import("./threads").WorkflowPendingEffects[];
-        pendingEmits: import("./threads").WorkflowPendingEmit[];
-        status: "completed" | "failed" | "running";
-        error: string | null;
-        needsSchedule: boolean;
-    } | {
-        definitionName?: string;
-        nodes: {
-            [nodeId: string]: import("./definitions").NodeState;
-        };
-        concurrency: number;
-        input: import("@swirls/looms/core").JsonValue;
-        nodeIds: string[];
-        needsSchedule: boolean;
-        runningNodes: string[];
-        pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-        pendingSleeps: import("./threads").WorkflowPendingSleep[];
-        pendingEmits: import("./threads").WorkflowPendingEmit[];
-        status: 'running' | 'completed' | 'failed';
-        error: string | null;
-        pendingEffects: (import("./threads").WorkflowPendingEffects | {
-            nodeId: string;
-            effects: (import("@swirls/looms/core").InvokeEffect | import("@swirls/looms/core").WaitEffect | {
-                type: 'runtime.wait';
-                waitId: string;
-                on: import("@swirls/looms/core").WaitCondition;
-                tag: {
-                    nodeId: string;
+                readonly type: "runtime.wait";
+                readonly waitId: string;
+                readonly on: {
+                    readonly type: string | readonly string[];
+                    readonly match?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly timerAt: number;
                 };
+                readonly tag?: import("effect/Schema").Json | undefined;
             } | {
-                type: 'runtime.cancel';
-                threadId: string;
-                tag: string;
+                readonly type: "runtime.emit";
+                readonly event: {
+                    readonly type: string;
+                    readonly payload: import("effect/Schema").Json;
+                    readonly threadId?: string | null | undefined;
+                    readonly parentThreadId?: string | null | undefined;
+                    readonly causationId?: string | null | undefined;
+                    readonly correlationId?: string | null | undefined;
+                    readonly effectId?: string | null | undefined;
+                    readonly origin?: {
+                        readonly type: "thread";
+                        readonly threadId: string;
+                    } | {
+                        readonly type: "external";
+                        readonly actorId?: string | undefined;
+                    } | {
+                        readonly type: "system";
+                    } | undefined;
+                    readonly ephemeral?: boolean | undefined;
+                    readonly id?: string | undefined;
+                    readonly ts?: number | undefined;
+                    readonly idempotencyKey?: string | null | undefined;
+                };
+                readonly tag?: string | undefined;
             } | {
-                type: 'runtime.complete';
-                output: import("@swirls/looms/core").JsonValue;
-                tag: string;
+                readonly type: "runtime.complete";
+                readonly output: import("effect/Schema").Json;
             } | {
-                type: 'runtime.emit';
-                event: import("@swirls/looms/core").EventInput;
-                tag: string;
+                readonly type: "runtime.fail";
+                readonly error: string;
             } | {
-                type: 'runtime.fail';
-                error: string;
-                tag: string;
-            })[];
-        })[];
-    } | {
-        definitionName?: string;
-        concurrency: number;
-        input: import("@swirls/looms/core").JsonValue;
-        nodeIds: string[];
-        needsSchedule: boolean;
-        status: 'running' | 'completed' | 'failed';
-        error: string | null;
-        nodes: {
-            [x: string]: {
-                readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
-                readonly result: import("effect/Schema").Json;
-                readonly error: string | null;
+                readonly type: "runtime.cancel";
+                readonly threadId: string;
+                readonly tag?: string | undefined;
             } | {
-                status: string;
-                result: null;
-                error: string;
-            };
-        };
-        runningNodes: string[];
-        pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-        pendingSleeps: import("./threads").WorkflowPendingSleep[];
-        pendingEffects: import("./threads").WorkflowPendingEffects[];
-        pendingEmits: (import("./threads").WorkflowPendingEmit | {
-            id: string;
-            event: {
-                type: string;
-                payload: {
-                    nodeId: string;
-                    result: null;
-                    error: string;
-                };
-                threadId: string;
-            };
-        })[];
-    } | {
-        definitionName?: string;
-        nodes: {
-            [nodeId: string]: import("./definitions").NodeState;
-        };
-        concurrency: number;
-        input: import("@swirls/looms/core").JsonValue;
-        nodeIds: string[];
-        needsSchedule: boolean;
-        runningNodes: string[];
-        status: 'running' | 'completed' | 'failed';
-        error: string | null;
-        pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-        pendingSleeps: import("./threads").WorkflowPendingSleep[];
-        pendingEffects: import("./threads").WorkflowPendingEffects[];
-        pendingEmits: (import("./threads").WorkflowPendingEmit | {
-            id: string;
-            event: {
-                type: string;
-                payload: {
-                    nodeId: string;
-                    result: string | number | boolean | import("@swirls/looms/core").JsonObject | readonly import("@swirls/looms/core").JsonValue[] | null;
-                    error: string | null;
-                };
-                threadId: string;
+                readonly type: string;
+                readonly input: import("effect/Schema").Json;
+                readonly tag?: string | undefined;
+            })[];
+        }[];
+        readonly pendingEmits: {
+            readonly id: string;
+            readonly event: {
+                readonly type: string;
+                readonly payload: import("effect/Schema").Json;
+                readonly threadId?: string | null | undefined;
+                readonly parentThreadId?: string | null | undefined;
+                readonly causationId?: string | null | undefined;
+                readonly correlationId?: string | null | undefined;
+                readonly effectId?: string | null | undefined;
+                readonly origin?: {
+                    readonly type: "thread";
+                    readonly threadId: string;
+                } | {
+                    readonly type: "external";
+                    readonly actorId?: string | undefined;
+                } | {
+                    readonly type: "system";
+                } | undefined;
+                readonly ephemeral?: boolean | undefined;
+                readonly id?: string | undefined;
+                readonly ts?: number | undefined;
+                readonly idempotencyKey?: string | null | undefined;
             };
-        })[];
+        }[];
+        readonly pendingCancels: string[];
+        readonly status: "completed" | "failed" | "running";
+        readonly error: string | null;
     }>;
 }, {
     nodes: import("@swirls/looms/core").ProjectionDefinition<{
@@ -460,39 +891,123 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
                 readonly result: import("effect/Schema").Json;
                 readonly error: string | null;
-            };
-        };
-    } | {
-        nodes: {
-            [x: string]: {
-                readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
-                readonly result: import("effect/Schema").Json;
-                readonly error: string | null;
-            } | {
-                status: string;
-                result: string | number | boolean | import("effect/Schema").JsonArray | import("effect/Schema").JsonObject | null;
-                error: string | null;
+                readonly attempts?: number | undefined;
+                readonly branch?: string | undefined;
+                readonly skipCause?: "inactive" | "policy" | undefined;
+                readonly iteration?: {
+                    readonly index: number;
+                    readonly previous: import("effect/Schema").Json;
+                } | undefined;
             };
         };
     }>;
-}, any> & {
+}, import("effect/Context").Service.Any> & {
     readonly effects: {
         schedule: import("@swirls/looms/core").EffectDefinition<{
             readonly definitionName?: string | undefined;
+            readonly definitionVersion: string;
             readonly nodes?: {
                 readonly [x: string]: {
                     readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
                     readonly result: import("effect/Schema").Json;
                     readonly error: string | null;
+                    readonly attempts?: number | undefined;
+                    readonly branch?: string | undefined;
+                    readonly skipCause?: "inactive" | "policy" | undefined;
+                    readonly iteration?: {
+                        readonly index: number;
+                        readonly previous: import("effect/Schema").Json;
+                    } | undefined;
                 };
             } | undefined;
             readonly input?: import("effect/Schema").Json | undefined;
         }, import("./definitions-store").WorkflowDefinitionsTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.ambiguous";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.attempt.started";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.cancel.requested";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.cancelled";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.completed";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.dispatched";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.failed";
             readonly payload: {
                 readonly effectId: string;
                 readonly error: string;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.heartbeat";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly heartbeatAt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.queued";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.retry.scheduled";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly nextAttemptAt: number;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.timed_out";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly timeout: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.worker.started";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.cancelled";
+            readonly payload: {
+                readonly reason?: string | undefined;
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.run.completed";
             readonly payload: {
@@ -505,7 +1020,9 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly rootThreadId?: string | undefined;
                 readonly kind: string;
                 readonly definitionName: string;
+                readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
+                readonly requestedThreadId?: string | null | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.signal.received";
@@ -519,6 +1036,11 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly stateHash: string;
                 readonly state?: import("effect/Schema").Json | undefined;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.cancel.requested";
+            readonly payload: {
+                readonly threadId: string;
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.thread.cancelled";
             readonly payload: {
@@ -543,6 +1065,7 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly threadId: string;
                 readonly kind: string;
                 readonly definitionName: string;
+                readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
                 readonly parentThreadId: string | null;
             };
@@ -587,7 +1110,75 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly type: "workflow.effects.requested";
             readonly payload: {
                 readonly nodeId: string;
-                readonly effects: readonly import("@swirls/looms/core").RuntimeEffect[];
+                readonly effects: readonly ({
+                    readonly type: "runtime.spawn";
+                    readonly childThreadId: string;
+                    readonly kind: string;
+                    readonly definitionName: string;
+                    readonly definitionVersion: string;
+                    readonly input: import("effect/Schema").Json;
+                } | {
+                    readonly type: "runtime.wait";
+                    readonly waitId: string;
+                    readonly on: {
+                        readonly type: string | readonly string[];
+                        readonly match?: import("effect/Schema").Json | undefined;
+                    } | {
+                        readonly timerAt: number;
+                    };
+                    readonly tag?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly type: "runtime.emit";
+                    readonly event: {
+                        readonly type: string;
+                        readonly payload: import("effect/Schema").Json;
+                        readonly threadId?: string | null | undefined;
+                        readonly parentThreadId?: string | null | undefined;
+                        readonly causationId?: string | null | undefined;
+                        readonly correlationId?: string | null | undefined;
+                        readonly effectId?: string | null | undefined;
+                        readonly origin?: {
+                            readonly type: "thread";
+                            readonly threadId: string;
+                        } | {
+                            readonly type: "external";
+                            readonly actorId?: string | undefined;
+                        } | {
+                            readonly type: "system";
+                        } | undefined;
+                        readonly ephemeral?: boolean | undefined;
+                        readonly id?: string | undefined;
+                        readonly ts?: number | undefined;
+                        readonly idempotencyKey?: string | null | undefined;
+                    };
+                    readonly tag?: string | undefined;
+                } | {
+                    readonly type: "runtime.complete";
+                    readonly output: import("effect/Schema").Json;
+                } | {
+                    readonly type: "runtime.fail";
+                    readonly error: string;
+                } | {
+                    readonly type: "runtime.cancel";
+                    readonly threadId: string;
+                    readonly tag?: string | undefined;
+                } | {
+                    readonly type: string;
+                    readonly input: import("effect/Schema").Json;
+                    readonly tag?: string | undefined;
+                })[];
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "workflow.map.requested";
+            readonly payload: {
+                readonly nodeId: string;
+                readonly attempt: number;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly items: readonly import("effect/Schema").Json[];
+                readonly concurrency: number;
+                readonly limitBytes: number;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "workflow.node.finished";
@@ -595,12 +1186,14 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly nodeId: string;
                 readonly result: import("effect/Schema").Json;
                 readonly error: string | null;
+                readonly branch?: string | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "workflow.node.skipped";
             readonly payload: {
                 readonly nodeId: string;
                 readonly reason: string;
+                readonly cause: "inactive" | "policy";
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "workflow.node.started";
@@ -618,25 +1211,126 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly type: "workflow.spawn.requested";
             readonly payload: {
                 readonly nodeId: string;
+                readonly attempt: number;
                 readonly childThreadId: string;
                 readonly kind: string;
                 readonly definitionName: string;
+                readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
+                readonly loopIndex: number | null;
             };
         })>;
         runNode: import("@swirls/looms/core").EffectDefinition<{
             readonly definitionName?: string | undefined;
+            readonly definitionVersion: string;
             readonly nodeId: string;
+            readonly attempt: number;
+            readonly iteration?: {
+                readonly index: number;
+                readonly previous: import("effect/Schema").Json;
+            } | undefined;
             readonly input?: import("effect/Schema").Json | undefined;
-            readonly results?: {
-                readonly [x: string]: import("effect/Schema").Json;
+            readonly nodes?: {
+                readonly [x: string]: {
+                    readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
+                    readonly result: import("effect/Schema").Json;
+                    readonly error: string | null;
+                    readonly attempts?: number | undefined;
+                    readonly branch?: string | undefined;
+                    readonly skipCause?: "inactive" | "policy" | undefined;
+                    readonly iteration?: {
+                        readonly index: number;
+                        readonly previous: import("effect/Schema").Json;
+                    } | undefined;
+                };
             } | undefined;
         }, import("./definitions-store").WorkflowDefinitionsTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.ambiguous";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.attempt.started";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.cancel.requested";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.cancelled";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.completed";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.dispatched";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.effect.failed";
             readonly payload: {
                 readonly effectId: string;
                 readonly error: string;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.heartbeat";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly heartbeatAt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.queued";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.retry.scheduled";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly nextAttemptAt: number;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.timed_out";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly timeout: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.worker.started";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.cancelled";
+            readonly payload: {
+                readonly reason?: string | undefined;
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.run.completed";
             readonly payload: {
@@ -649,7 +1343,9 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly rootThreadId?: string | undefined;
                 readonly kind: string;
                 readonly definitionName: string;
+                readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
+                readonly requestedThreadId?: string | null | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.signal.received";
@@ -663,6 +1359,11 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly stateHash: string;
                 readonly state?: import("effect/Schema").Json | undefined;
             };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.cancel.requested";
+            readonly payload: {
+                readonly threadId: string;
+            };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "runtime.thread.cancelled";
             readonly payload: {
@@ -687,6 +1388,7 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly threadId: string;
                 readonly kind: string;
                 readonly definitionName: string;
+                readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
                 readonly parentThreadId: string | null;
             };
@@ -731,7 +1433,75 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly type: "workflow.effects.requested";
             readonly payload: {
                 readonly nodeId: string;
-                readonly effects: readonly import("@swirls/looms/core").RuntimeEffect[];
+                readonly effects: readonly ({
+                    readonly type: "runtime.spawn";
+                    readonly childThreadId: string;
+                    readonly kind: string;
+                    readonly definitionName: string;
+                    readonly definitionVersion: string;
+                    readonly input: import("effect/Schema").Json;
+                } | {
+                    readonly type: "runtime.wait";
+                    readonly waitId: string;
+                    readonly on: {
+                        readonly type: string | readonly string[];
+                        readonly match?: import("effect/Schema").Json | undefined;
+                    } | {
+                        readonly timerAt: number;
+                    };
+                    readonly tag?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly type: "runtime.emit";
+                    readonly event: {
+                        readonly type: string;
+                        readonly payload: import("effect/Schema").Json;
+                        readonly threadId?: string | null | undefined;
+                        readonly parentThreadId?: string | null | undefined;
+                        readonly causationId?: string | null | undefined;
+                        readonly correlationId?: string | null | undefined;
+                        readonly effectId?: string | null | undefined;
+                        readonly origin?: {
+                            readonly type: "thread";
+                            readonly threadId: string;
+                        } | {
+                            readonly type: "external";
+                            readonly actorId?: string | undefined;
+                        } | {
+                            readonly type: "system";
+                        } | undefined;
+                        readonly ephemeral?: boolean | undefined;
+                        readonly id?: string | undefined;
+                        readonly ts?: number | undefined;
+                        readonly idempotencyKey?: string | null | undefined;
+                    };
+                    readonly tag?: string | undefined;
+                } | {
+                    readonly type: "runtime.complete";
+                    readonly output: import("effect/Schema").Json;
+                } | {
+                    readonly type: "runtime.fail";
+                    readonly error: string;
+                } | {
+                    readonly type: "runtime.cancel";
+                    readonly threadId: string;
+                    readonly tag?: string | undefined;
+                } | {
+                    readonly type: string;
+                    readonly input: import("effect/Schema").Json;
+                    readonly tag?: string | undefined;
+                })[];
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "workflow.map.requested";
+            readonly payload: {
+                readonly nodeId: string;
+                readonly attempt: number;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly items: readonly import("effect/Schema").Json[];
+                readonly concurrency: number;
+                readonly limitBytes: number;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "workflow.node.finished";
@@ -739,12 +1509,14 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                 readonly nodeId: string;
                 readonly result: import("effect/Schema").Json;
                 readonly error: string | null;
+                readonly branch?: string | undefined;
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "workflow.node.skipped";
             readonly payload: {
                 readonly nodeId: string;
                 readonly reason: string;
+                readonly cause: "inactive" | "policy";
             };
         }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
             readonly type: "workflow.node.started";
@@ -762,142 +1534,156 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
             readonly type: "workflow.spawn.requested";
             readonly payload: {
                 readonly nodeId: string;
+                readonly attempt: number;
                 readonly childThreadId: string;
                 readonly kind: string;
                 readonly definitionName: string;
+                readonly definitionVersion: string;
                 readonly input: import("effect/Schema").Json;
+                readonly loopIndex: number | null;
             };
         })>;
     };
     readonly threads: {
         workflow: import("@swirls/looms/core").ThreadDefinition<{
-            definitionName?: string;
-            concurrency: number;
-            input: import("@swirls/looms/core").JsonValue;
-            nodeIds: string[];
-            nodes: {
-                [x: string]: {
+            readonly definitionName?: string | undefined;
+            readonly definitionVersion?: string | undefined;
+            readonly nodes: {
+                readonly [x: string]: {
                     readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
                     readonly result: import("effect/Schema").Json;
                     readonly error: string | null;
-                } | {
-                    status: string;
-                    result: string | number | boolean | import("effect/Schema").JsonArray | import("effect/Schema").JsonObject | null;
-                    error: string | null;
+                    readonly attempts?: number | undefined;
+                    readonly branch?: string | undefined;
+                    readonly skipCause?: "inactive" | "policy" | undefined;
+                    readonly iteration?: {
+                        readonly index: number;
+                        readonly previous: import("effect/Schema").Json;
+                    } | undefined;
                 };
             };
-            runningNodes: string[];
-            pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-            pendingSleeps: import("./threads").WorkflowPendingSleep[];
-            pendingEffects: import("./threads").WorkflowPendingEffects[];
-            pendingEmits: import("./threads").WorkflowPendingEmit[];
-            status: "completed" | "failed" | "running";
-            error: string | null;
-            needsSchedule: boolean;
-        } | {
-            definitionName?: string;
-            nodes: {
-                [nodeId: string]: import("./definitions").NodeState;
-            };
-            concurrency: number;
-            input: import("@swirls/looms/core").JsonValue;
-            nodeIds: string[];
-            needsSchedule: boolean;
-            runningNodes: string[];
-            pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-            pendingSleeps: import("./threads").WorkflowPendingSleep[];
-            pendingEmits: import("./threads").WorkflowPendingEmit[];
-            status: 'running' | 'completed' | 'failed';
-            error: string | null;
-            pendingEffects: (import("./threads").WorkflowPendingEffects | {
-                nodeId: string;
-                effects: (import("@swirls/looms/core").InvokeEffect | import("@swirls/looms/core").WaitEffect | {
-                    type: 'runtime.wait';
-                    waitId: string;
-                    on: import("@swirls/looms/core").WaitCondition;
-                    tag: {
-                        nodeId: string;
+            readonly concurrency: number;
+            readonly input: import("effect/Schema").Json;
+            readonly nodeIds: string[];
+            readonly needsSchedule: boolean;
+            readonly runningNodes: string[];
+            readonly pendingSpawns: {
+                readonly childThreadId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly nodeId: string;
+                readonly attempt: number;
+                readonly input: import("effect/Schema").Json;
+                readonly loopIndex: number | null;
+            }[];
+            readonly pendingMaps: {
+                readonly nodeId: string;
+                readonly attempt: number;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly items: readonly import("effect/Schema").Json[];
+                readonly concurrency: number;
+                readonly limitBytes: number;
+                readonly nextIndex: number;
+                readonly outputs: {
+                    readonly [x: string]: import("effect/Schema").Json;
+                };
+            }[];
+            readonly pendingSleeps: {
+                readonly waitId: string;
+                readonly wakeAt: number;
+                readonly nodeId: string;
+            }[];
+            readonly pendingEffects: {
+                readonly nodeId: string;
+                readonly effects: ({
+                    readonly type: "runtime.spawn";
+                    readonly childThreadId: string;
+                    readonly kind: string;
+                    readonly definitionName: string;
+                    readonly definitionVersion: string;
+                    readonly input: import("effect/Schema").Json;
+                } | {
+                    readonly type: "runtime.wait";
+                    readonly waitId: string;
+                    readonly on: {
+                        readonly type: string | readonly string[];
+                        readonly match?: import("effect/Schema").Json | undefined;
+                    } | {
+                        readonly timerAt: number;
                     };
+                    readonly tag?: import("effect/Schema").Json | undefined;
                 } | {
-                    type: 'runtime.cancel';
-                    threadId: string;
-                    tag: string;
+                    readonly type: "runtime.emit";
+                    readonly event: {
+                        readonly type: string;
+                        readonly payload: import("effect/Schema").Json;
+                        readonly threadId?: string | null | undefined;
+                        readonly parentThreadId?: string | null | undefined;
+                        readonly causationId?: string | null | undefined;
+                        readonly correlationId?: string | null | undefined;
+                        readonly effectId?: string | null | undefined;
+                        readonly origin?: {
+                            readonly type: "thread";
+                            readonly threadId: string;
+                        } | {
+                            readonly type: "external";
+                            readonly actorId?: string | undefined;
+                        } | {
+                            readonly type: "system";
+                        } | undefined;
+                        readonly ephemeral?: boolean | undefined;
+                        readonly id?: string | undefined;
+                        readonly ts?: number | undefined;
+                        readonly idempotencyKey?: string | null | undefined;
+                    };
+                    readonly tag?: string | undefined;
                 } | {
-                    type: 'runtime.complete';
-                    output: import("@swirls/looms/core").JsonValue;
-                    tag: string;
+                    readonly type: "runtime.complete";
+                    readonly output: import("effect/Schema").Json;
                 } | {
-                    type: 'runtime.emit';
-                    event: import("@swirls/looms/core").EventInput;
-                    tag: string;
+                    readonly type: "runtime.fail";
+                    readonly error: string;
                 } | {
-                    type: 'runtime.fail';
-                    error: string;
-                    tag: string;
-                })[];
-            })[];
-        } | {
-            definitionName?: string;
-            concurrency: number;
-            input: import("@swirls/looms/core").JsonValue;
-            nodeIds: string[];
-            needsSchedule: boolean;
-            status: 'running' | 'completed' | 'failed';
-            error: string | null;
-            nodes: {
-                [x: string]: {
-                    readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
-                    readonly result: import("effect/Schema").Json;
-                    readonly error: string | null;
+                    readonly type: "runtime.cancel";
+                    readonly threadId: string;
+                    readonly tag?: string | undefined;
                 } | {
-                    status: string;
-                    result: null;
-                    error: string;
-                };
-            };
-            runningNodes: string[];
-            pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-            pendingSleeps: import("./threads").WorkflowPendingSleep[];
-            pendingEffects: import("./threads").WorkflowPendingEffects[];
-            pendingEmits: (import("./threads").WorkflowPendingEmit | {
-                id: string;
-                event: {
-                    type: string;
-                    payload: {
-                        nodeId: string;
-                        result: null;
-                        error: string;
-                    };
-                    threadId: string;
-                };
-            })[];
-        } | {
-            definitionName?: string;
-            nodes: {
-                [nodeId: string]: import("./definitions").NodeState;
-            };
-            concurrency: number;
-            input: import("@swirls/looms/core").JsonValue;
-            nodeIds: string[];
-            needsSchedule: boolean;
-            runningNodes: string[];
-            status: 'running' | 'completed' | 'failed';
-            error: string | null;
-            pendingSpawns: import("./threads").WorkflowPendingSpawn[];
-            pendingSleeps: import("./threads").WorkflowPendingSleep[];
-            pendingEffects: import("./threads").WorkflowPendingEffects[];
-            pendingEmits: (import("./threads").WorkflowPendingEmit | {
-                id: string;
-                event: {
-                    type: string;
-                    payload: {
-                        nodeId: string;
-                        result: string | number | boolean | import("@swirls/looms/core").JsonObject | readonly import("@swirls/looms/core").JsonValue[] | null;
-                        error: string | null;
-                    };
-                    threadId: string;
+                    readonly type: string;
+                    readonly input: import("effect/Schema").Json;
+                    readonly tag?: string | undefined;
+                })[];
+            }[];
+            readonly pendingEmits: {
+                readonly id: string;
+                readonly event: {
+                    readonly type: string;
+                    readonly payload: import("effect/Schema").Json;
+                    readonly threadId?: string | null | undefined;
+                    readonly parentThreadId?: string | null | undefined;
+                    readonly causationId?: string | null | undefined;
+                    readonly correlationId?: string | null | undefined;
+                    readonly effectId?: string | null | undefined;
+                    readonly origin?: {
+                        readonly type: "thread";
+                        readonly threadId: string;
+                    } | {
+                        readonly type: "external";
+                        readonly actorId?: string | undefined;
+                    } | {
+                        readonly type: "system";
+                    } | undefined;
+                    readonly ephemeral?: boolean | undefined;
+                    readonly id?: string | undefined;
+                    readonly ts?: number | undefined;
+                    readonly idempotencyKey?: string | null | undefined;
                 };
-            })[];
+            }[];
+            readonly pendingCancels: string[];
+            readonly status: "completed" | "failed" | "running";
+            readonly error: string | null;
         }>;
     };
     readonly projections: {
@@ -907,18 +1693,13 @@ export declare function workflow(options?: WorkflowModuleOptions): import("@swir
                     readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
                     readonly result: import("effect/Schema").Json;
                     readonly error: string | null;
-                };
-            };
-        } | {
-            nodes: {
-                [x: string]: {
-                    readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
-                    readonly result: import("effect/Schema").Json;
-                    readonly error: string | null;
-                } | {
-                    status: string;
-                    result: string | number | boolean | import("effect/Schema").JsonArray | import("effect/Schema").JsonObject | null;
-                    error: string | null;
+                    readonly attempts?: number | undefined;
+                    readonly branch?: string | undefined;
+                    readonly skipCause?: "inactive" | "policy" | undefined;
+                    readonly iteration?: {
+                        readonly index: number;
+                        readonly previous: import("effect/Schema").Json;
+                    } | undefined;
                 };
             };
         }>;