@swirls/looms 0.0.2 → 0.2.0

package/dist/workflow/threads.d.ts

@@ -1,171 +1,399 @@
 import { Schema } from 'effect';
-import { type EventInput, type JsonValue, type RuntimeEffect } from '@swirls/looms/core';
-import { type NodeState } from './definitions';
 export { NodeStateSchema, NodeStatusSchema, type NodeState, type NodeStatus } from './definitions';
-export interface WorkflowPendingSpawn {
-    readonly childThreadId: string;
-    readonly kind: string;
-    readonly definitionName: string;
-    readonly nodeId: string;
-    readonly input: JsonValue;
-}
-export interface WorkflowPendingSleep {
-    readonly waitId: string;
-    readonly wakeAt: number;
-    readonly nodeId: string;
-}
-export interface WorkflowPendingEffects {
-    readonly nodeId: string;
-    readonly effects: RuntimeEffect[];
-}
-export interface WorkflowPendingEmit {
-    readonly id: string;
-    readonly event: EventInput;
-}
-export interface WorkflowState {
-    definitionName?: string;
-    nodes: {
-        [nodeId: string]: NodeState;
-    };
-    concurrency: number;
-    input: JsonValue;
-    nodeIds: string[];
-    needsSchedule: boolean;
-    runningNodes: string[];
-    pendingSpawns: WorkflowPendingSpawn[];
-    pendingSleeps: WorkflowPendingSleep[];
-    pendingEffects: WorkflowPendingEffects[];
-    pendingEmits: WorkflowPendingEmit[];
-    status: 'running' | 'completed' | 'failed';
-    error: string | null;
-}
-export declare const WorkflowStateSchema: Schema.Schema<WorkflowState>;
+export declare const WorkflowPendingSpawnSchema: Schema.Struct<{
+    readonly childThreadId: Schema.String;
+    readonly kind: Schema.String;
+    readonly definitionName: Schema.String;
+    readonly definitionVersion: Schema.String;
+    readonly nodeId: Schema.String;
+    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>;
+}>;
+export type WorkflowPendingSpawn = Schema.Schema.Type<typeof WorkflowPendingSpawnSchema>;
+export declare const WorkflowPendingMapSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
+    readonly kind: Schema.String;
+    readonly definitionName: Schema.String;
+    readonly definitionVersion: Schema.String;
+    readonly items: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly concurrency: Schema.Finite;
+    readonly limitBytes: Schema.Finite;
+    /** 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>>;
+}>;
+export type WorkflowPendingMap = Schema.Schema.Type<typeof WorkflowPendingMapSchema>;
+export declare const WorkflowPendingSleepSchema: Schema.Struct<{
+    readonly waitId: Schema.String;
+    readonly wakeAt: Schema.Finite;
+    readonly nodeId: Schema.String;
+}>;
+export type WorkflowPendingSleep = Schema.Schema.Type<typeof WorkflowPendingSleepSchema>;
+export declare const WorkflowPendingEffectsSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly effects: Schema.mutable<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.spawn">;
+        readonly childThreadId: 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>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.wait">;
+        readonly waitId: Schema.String;
+        readonly on: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+            readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly timerAt: Schema.Finite;
+        }>]>;
+        readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.emit">;
+        readonly event: Schema.Struct<{
+            readonly type: Schema.String;
+            readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"thread">;
+                readonly threadId: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"external">;
+                readonly actorId: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"system">;
+            }>]>>;
+            readonly ephemeral: Schema.optional<Schema.Boolean>;
+            readonly id: Schema.optional<Schema.String>;
+            readonly ts: Schema.optional<Schema.Finite>;
+            readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>;
+        readonly tag: Schema.optional<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.complete">;
+        readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.fail">;
+        readonly error: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"runtime.cancel">;
+        readonly threadId: 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>;
+    }>]>>>;
+}>;
+export type WorkflowPendingEffects = Schema.Schema.Type<typeof WorkflowPendingEffectsSchema>;
+export declare const WorkflowPendingEmitSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly event: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"thread">;
+            readonly threadId: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"external">;
+            readonly actorId: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"system">;
+        }>]>>;
+        readonly ephemeral: Schema.optional<Schema.Boolean>;
+        readonly id: Schema.optional<Schema.String>;
+        readonly ts: Schema.optional<Schema.Finite>;
+        readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+    }>;
+}>;
+export type WorkflowPendingEmit = Schema.Schema.Type<typeof WorkflowPendingEmitSchema>;
+export declare const WorkflowStateSchema: Schema.Struct<{
+    readonly definitionName: Schema.optional<Schema.String>;
+    readonly definitionVersion: Schema.optional<Schema.String>;
+    readonly nodes: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"running">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"skipped">]>;
+        readonly result: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly error: Schema.NullOr<Schema.String>;
+        readonly attempts: Schema.optional<Schema.Finite>;
+        readonly branch: Schema.optional<Schema.String>;
+        readonly skipCause: Schema.optional<Schema.Union<readonly [Schema.Literal<"inactive">, Schema.Literal<"policy">]>>;
+        readonly iteration: Schema.optional<Schema.Struct<{
+            readonly index: Schema.Finite;
+            readonly previous: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>;
+    }>>;
+    readonly concurrency: Schema.Finite;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly nodeIds: Schema.mutable<Schema.$Array<Schema.String>>;
+    readonly needsSchedule: Schema.Boolean;
+    readonly runningNodes: Schema.mutable<Schema.$Array<Schema.String>>;
+    readonly pendingSpawns: Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly childThreadId: Schema.String;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.String;
+        readonly nodeId: Schema.String;
+        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 pendingMaps: Schema.withDecodingDefaultKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.String;
+        readonly items: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly concurrency: Schema.Finite;
+        readonly limitBytes: Schema.Finite;
+        /** 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>>;
+    }>>>, never>;
+    readonly pendingSleeps: Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly waitId: Schema.String;
+        readonly wakeAt: Schema.Finite;
+        readonly nodeId: Schema.String;
+    }>>>;
+    readonly pendingEffects: Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly effects: Schema.mutable<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.spawn">;
+            readonly childThreadId: 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>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.wait">;
+            readonly waitId: Schema.String;
+            readonly on: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
+                readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly timerAt: Schema.Finite;
+            }>]>;
+            readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.emit">;
+            readonly event: Schema.Struct<{
+                readonly type: Schema.String;
+                readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"thread">;
+                    readonly threadId: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"external">;
+                    readonly actorId: Schema.optional<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"system">;
+                }>]>>;
+                readonly ephemeral: Schema.optional<Schema.Boolean>;
+                readonly id: Schema.optional<Schema.String>;
+                readonly ts: Schema.optional<Schema.Finite>;
+                readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+            }>;
+            readonly tag: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.complete">;
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.fail">;
+            readonly error: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.cancel">;
+            readonly threadId: 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 pendingEmits: Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly event: Schema.Struct<{
+            readonly type: Schema.String;
+            readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly threadId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly parentThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly causationId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly correlationId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly effectId: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly origin: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"thread">;
+                readonly threadId: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"external">;
+                readonly actorId: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"system">;
+            }>]>>;
+            readonly ephemeral: Schema.optional<Schema.Boolean>;
+            readonly id: Schema.optional<Schema.String>;
+            readonly ts: Schema.optional<Schema.Finite>;
+            readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>;
+    }>>>;
+    /** Children of stopped nodes that were still running; each is cancelled once. */
+    readonly pendingCancels: Schema.withDecodingDefaultKey<Schema.mutable<Schema.$Array<Schema.String>>, never>;
+    readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"completed">, Schema.Literal<"failed">]>;
+    readonly error: Schema.NullOr<Schema.String>;
+}>;
+export type WorkflowState = Schema.Schema.Type<typeof WorkflowStateSchema>;
 export declare const workflowThread: import("@swirls/looms/core").ThreadDefinition<{
-    definitionName?: string;
-    concurrency: number;
-    input: 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: Schema.Json;
             readonly error: string | null;
-        } | {
-            status: string;
-            result: string | number | boolean | Schema.JsonArray | 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: Schema.Json;
+            } | undefined;
         };
     };
-    runningNodes: string[];
-    pendingSpawns: WorkflowPendingSpawn[];
-    pendingSleeps: WorkflowPendingSleep[];
-    pendingEffects: WorkflowPendingEffects[];
-    pendingEmits: WorkflowPendingEmit[];
-    status: "completed" | "failed" | "running";
-    error: string | null;
-    needsSchedule: boolean;
-} | {
-    definitionName?: string;
-    nodes: {
-        [nodeId: string]: NodeState;
-    };
-    concurrency: number;
-    input: JsonValue;
-    nodeIds: string[];
-    needsSchedule: boolean;
-    runningNodes: string[];
-    pendingSpawns: WorkflowPendingSpawn[];
-    pendingSleeps: WorkflowPendingSleep[];
-    pendingEmits: WorkflowPendingEmit[];
-    status: 'running' | 'completed' | 'failed';
-    error: string | null;
-    pendingEffects: (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: 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: 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 Schema.Json[];
+        readonly concurrency: number;
+        readonly limitBytes: number;
+        readonly nextIndex: number;
+        readonly outputs: {
+            readonly [x: string]: 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: Schema.Json;
+        } | {
+            readonly type: "runtime.wait";
+            readonly waitId: string;
+            readonly on: {
+                readonly type: string | readonly string[];
+                readonly match?: Schema.Json | undefined;
+            } | {
+                readonly timerAt: number;
             };
+            readonly tag?: Schema.Json | undefined;
         } | {
-            type: 'runtime.cancel';
-            threadId: string;
-            tag: string;
+            readonly type: "runtime.emit";
+            readonly event: {
+                readonly type: string;
+                readonly payload: 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: JsonValue;
-            tag: string;
+            readonly type: "runtime.complete";
+            readonly output: Schema.Json;
         } | {
-            type: 'runtime.emit';
-            event: EventInput;
-            tag: string;
+            readonly type: "runtime.fail";
+            readonly error: string;
         } | {
-            type: 'runtime.fail';
-            error: string;
-            tag: string;
-        })[];
-    })[];
-} | {
-    definitionName?: string;
-    concurrency: number;
-    input: JsonValue;
-    nodeIds: string[];
-    needsSchedule: boolean;
-    status: 'running' | 'completed' | 'failed';
-    error: string | null;
-    nodes: {
-        [x: string]: {
-            readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
-            readonly result: 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: WorkflowPendingSpawn[];
-    pendingSleeps: WorkflowPendingSleep[];
-    pendingEffects: WorkflowPendingEffects[];
-    pendingEmits: (WorkflowPendingEmit | {
-        id: string;
-        event: {
-            type: string;
-            payload: {
-                nodeId: string;
-                result: null;
-                error: string;
-            };
-            threadId: string;
-        };
-    })[];
-} | {
-    definitionName?: string;
-    nodes: {
-        [nodeId: string]: NodeState;
-    };
-    concurrency: number;
-    input: JsonValue;
-    nodeIds: string[];
-    needsSchedule: boolean;
-    runningNodes: string[];
-    status: 'running' | 'completed' | 'failed';
-    error: string | null;
-    pendingSpawns: WorkflowPendingSpawn[];
-    pendingSleeps: WorkflowPendingSleep[];
-    pendingEffects: WorkflowPendingEffects[];
-    pendingEmits: (WorkflowPendingEmit | {
-        id: string;
-        event: {
-            type: string;
-            payload: {
-                nodeId: string;
-                result: string | number | boolean | import("@swirls/looms/core").JsonObject | readonly JsonValue[] | null;
-                error: string | null;
-            };
-            threadId: string;
+            readonly type: string;
+            readonly input: Schema.Json;
+            readonly tag?: string | undefined;
+        })[];
+    }[];
+    readonly pendingEmits: {
+        readonly id: string;
+        readonly event: {
+            readonly type: string;
+            readonly payload: 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;
 }>;