@swirls/looms 0.0.2 → 0.2.0

package/dist/workflow/effects.js

@@ -1,204 +1,285 @@
-import { Effect, Predicate, Schema } from 'effect';
-import { createThreadId, createWaitId } from '@swirls/looms/core';
-import { NodeStateSchema, readyNodes, } from './definitions.js';
+import { Clock, Data, Effect, Predicate, Schema } from 'effect';
+import { createThreadId, createWaitId, DEFAULT_DEFINITION_VERSION, } from '@swirls/looms/core';
+import { NodeStateSchema, nodeResultBuilders, } from './definitions.js';
 import { WorkflowDefinitionsTag } from './definitions-store.js';
+import { assertJsonWithinLimit, DEFAULT_CHECKPOINT_SIZE_LIMIT_BYTES, DEFAULT_GRAPH_CONCURRENCY, getReadyNodeIds, getSkippableNodeIds, getUnusedFallbackIds, iterationChildWorkflowId, nodeChildWorkflowId, nodeResults, nodeRunKey, } from './graph.js';
 import { workflowModule } from './scope.js';
 const ScheduleInput = Schema.Struct({
     definitionName: Schema.optional(Schema.String),
+    definitionVersion: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION))),
     nodes: Schema.optional(Schema.Record(Schema.String, NodeStateSchema)),
     input: Schema.optional(Schema.Json),
 });
 const RunNodeInput = Schema.Struct({
     definitionName: Schema.optional(Schema.String),
+    definitionVersion: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION))),
     nodeId: Schema.String,
+    attempt: Schema.Finite.pipe(Schema.withDecodingDefaultKey(Effect.succeed(1))),
+    iteration: Schema.optional(Schema.Struct({ index: Schema.Finite, previous: Schema.Json })),
     input: Schema.optional(Schema.Json),
-    results: Schema.optional(Schema.Record(Schema.String, Schema.NullOr(Schema.Json))),
+    nodes: Schema.optional(Schema.Record(Schema.String, NodeStateSchema)),
 });
+class WorkflowNodeError extends Data.TaggedError('WorkflowNodeError') {
+    constructor(cause) {
+        super({
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'WorkflowNodeError';
+    }
+}
 function isNodeResult(raw) {
     if (!Predicate.isObject(raw) || !('type' in raw)) {
         return false;
     }
-    return (raw.type === 'value' || raw.type === 'spawn' || raw.type === 'sleep' || raw.type === 'effects');
+    return (raw.type === 'value' ||
+        raw.type === 'spawn' ||
+        raw.type === 'sleep' ||
+        raw.type === 'effects' ||
+        raw.type === 'switch' ||
+        raw.type === 'map' ||
+        raw.type === 'loop');
+}
+function threadFailed(threadId, error) {
+    return [{ type: 'runtime.thread.failed', payload: { threadId, error }, threadId }];
 }
 export const scheduleEffect = workflowModule.effect({
     type: 'workflow.schedule',
     input: ScheduleInput,
     execute: (input, ctx) => Effect.gen(function* () {
         const workflows = yield* WorkflowDefinitionsTag;
-        const threadId = ctx.threadId;
-        const definition = input.definitionName ? workflows.get(input.definitionName) : undefined;
+        const definition = input.definitionName
+            ? workflows.get(input.definitionName, input.definitionVersion)
+            : undefined;
         if (!definition) {
             return [];
         }
-        const rawNodes = input.nodes ?? {};
-        const nodes = {};
-        for (const [id, n] of Object.entries(rawNodes)) {
-            // SAFETY: NodeState results are valid JSON-serializable node execution outputs.
-            nodes[id] = { status: n.status, result: n.result ?? null };
-        }
+        const nodes = { ...input.nodes };
         for (const node of definition.nodes) {
-            if (!nodes[node.id]) {
-                nodes[node.id] = { status: 'pending', result: null };
-            }
+            nodes[node.id] ??= { status: 'pending', result: null, error: null, attempts: 0 };
         }
-        // SAFETY: Workflow input is validated and serialized as JsonValue.
-        return scheduleEvents(definition, { nodes, input: input.input ?? null }, threadId);
+        return yield* scheduleEvents(definition, { nodes, input: input.input ?? null }, ctx.threadId);
     }),
 });
-export function scheduleEvents(definition, binding, threadId) {
-    const running = Object.values(binding.nodes).filter((n) => n.status === 'running').length;
-    const slots = Math.max(0, (definition.concurrency ?? 8) - running);
-    const ready = readyNodes(definition, binding.nodes).slice(0, slots);
-    const events = [];
-    for (const nodeId of ready) {
-        events.push({
-            type: 'workflow.node.started',
-            payload: { nodeId },
-            threadId,
-        });
+function failurePolicyEvents(definition, nodes, threadId) {
+    const failed = definition.nodes.find((node) => nodes[node.id]?.status === 'failed');
+    if (!failed) {
+        return undefined;
     }
-    if (ready.length > 0) {
-        return events;
-    }
-    const pending = Object.values(binding.nodes).some((n) => n.status === 'pending' || n.status === 'running');
-    if (pending) {
-        return [];
+    const state = nodes[failed.id];
+    const policy = failed.failure ?? { type: 'fail' };
+    const error = state?.error ?? `Node ${failed.id} failed`;
+    switch (policy.type) {
+        case 'retry':
+            return (state?.attempts ?? 0) < policy.maxAttempts
+                ? [{ type: 'workflow.node.started', payload: { nodeId: failed.id }, threadId }]
+                : threadFailed(threadId, error);
+        case 'skip':
+            return [
+                {
+                    type: 'workflow.node.skipped',
+                    payload: { nodeId: failed.id, reason: error, cause: 'policy' },
+                    threadId,
+                },
+            ];
+        case 'fallback':
+            return [
+                {
+                    type: 'workflow.node.skipped',
+                    payload: { nodeId: failed.id, reason: `fallback:${policy.nodeId}`, cause: 'policy' },
+                    threadId,
+                },
+                { type: 'workflow.node.started', payload: { nodeId: policy.nodeId }, threadId },
+            ];
+        case 'fail':
+            return threadFailed(threadId, error);
+        default: {
+            const exhaustiveCheck = policy;
+            return exhaustiveCheck;
+        }
     }
-    const failed = Object.entries(binding.nodes).find(([, n]) => n.status === 'failed');
-    if (failed) {
-        return [
-            {
-                type: 'runtime.thread.failed',
-                payload: { threadId, error: `Node ${failed[0]} failed` },
+}
+export function scheduleEvents(definition, binding, threadId) {
+    return Effect.gen(function* () {
+        yield* assertJsonWithinLimit(binding.input, 'Workflow input', definition.inputLimitBytes);
+        const policyEvents = failurePolicyEvents(definition, binding.nodes, threadId);
+        if (policyEvents) {
+            return policyEvents;
+        }
+        const skipped = [
+            ...getSkippableNodeIds(definition, binding.nodes).map((nodeId) => ({
+                type: 'workflow.node.skipped',
+                payload: { nodeId, reason: 'inactive branch', cause: 'inactive' },
                 threadId,
-            },
+            })),
+            ...getUnusedFallbackIds(definition, binding.nodes).map((nodeId) => ({
+                type: 'workflow.node.skipped',
+                payload: { nodeId, reason: 'fallback not needed', cause: 'inactive' },
+                threadId,
+            })),
         ];
-    }
-    const results = {};
-    for (const [id, node] of Object.entries(binding.nodes)) {
-        results[id] = node.result;
-    }
-    const output = definition.output ? definition.output({ input: binding.input, results }) : results;
-    return [
-        {
-            type: 'runtime.thread.completed',
-            payload: { threadId, output },
-            threadId,
-        },
-    ];
+        if (skipped.length > 0) {
+            return skipped;
+        }
+        const statuses = Object.values(binding.nodes).map((node) => node.status);
+        const running = statuses.filter((status) => status === 'running').length;
+        const slots = Math.max(0, (definition.concurrency ?? DEFAULT_GRAPH_CONCURRENCY) - running);
+        const ready = getReadyNodeIds(definition, binding.nodes).slice(0, slots);
+        if (ready.length > 0) {
+            return ready.map((nodeId) => ({
+                type: 'workflow.node.started',
+                payload: { nodeId },
+                threadId,
+            }));
+        }
+        if (statuses.some((status) => status === 'pending' || status === 'running')) {
+            return [];
+        }
+        const results = nodeResults(definition, binding.nodes);
+        const output = definition.output
+            ? definition.output({ input: binding.input, results })
+            : results;
+        yield* assertJsonWithinLimit(output, 'Workflow output', definition.outputLimitBytes);
+        return [{ type: 'runtime.thread.completed', payload: { threadId, output }, threadId }];
+    }).pipe(Effect.catchTag('WorkflowValueTooLargeError', (error) => Effect.succeed(threadFailed(threadId, error.message))));
 }
 export const runNodeEffect = workflowModule.effect({
     type: 'workflow.runNode',
     input: RunNodeInput,
     execute: (input, ctx) => Effect.gen(function* () {
         const workflows = yield* WorkflowDefinitionsTag;
-        const threadId = ctx.threadId;
-        const definition = input.definitionName ? workflows.get(input.definitionName) : undefined;
+        const definition = input.definitionName
+            ? workflows.get(input.definitionName, input.definitionVersion)
+            : undefined;
+        const run = {
+            threadId: ctx.threadId,
+            nodeId: input.nodeId,
+            attempt: input.attempt,
+            iteration: input.iteration,
+            input: input.input ?? null,
+            nodes: input.nodes ?? {},
+        };
         if (!definition) {
-            return [
-                {
-                    type: 'workflow.node.finished',
-                    payload: { nodeId: input.nodeId, result: null, error: 'Unknown workflow definition' },
-                    threadId,
-                },
-            ];
-        }
-        const rawResults = input.results ?? {};
-        const results = {};
-        for (const [id, val] of Object.entries(rawResults)) {
-            // SAFETY: Node results dictionary maps node IDs to JSON values or null.
-            results[id] = val ?? null;
+            return finished(run, null, 'Unknown workflow definition');
         }
-        return yield* runNode(definition, 
-        // SAFETY: Workflow input is validated and serialized as JsonValue.
-        { input: input.input ?? null, results }, input.nodeId, threadId);
+        return yield* runNode(definition, run);
     }),
 });
-function runNode(definition, binding, nodeId, threadId) {
+function finished(run, result, error) {
+    return [
+        {
+            type: 'workflow.node.finished',
+            payload: { nodeId: run.nodeId, result, error },
+            threadId: run.threadId,
+        },
+    ];
+}
+function runNode(definition, run) {
     return Effect.gen(function* () {
-        const nodeDef = definition.nodes.find((node) => node.id === nodeId);
+        const nodeDef = definition.nodes.find((node) => node.id === run.nodeId);
         if (!nodeDef) {
-            return [
-                {
-                    type: 'workflow.node.finished',
-                    payload: { nodeId, result: null, error: `Unknown node: ${nodeId}` },
-                    threadId,
-                },
-            ];
+            return finished(run, null, `Unknown node: ${run.nodeId}`);
         }
-        const results = binding.results;
         const raw = yield* Effect.tryPromise({
             try: () => Promise.resolve(nodeDef.run({
-                threadId,
-                nodeId,
-                input: binding.input,
-                results,
-                spawn: (child, input) => ({ type: 'spawn', kind: child.kind, name: child.name, input }),
-                sleep: (ms) => ({ type: 'sleep', ms }),
-                effects: (effects) => ({ type: 'effects', effects }),
+                threadId: run.threadId,
+                nodeId: run.nodeId,
+                input: run.input,
+                results: nodeResults(definition, run.nodes),
+                iteration: run.iteration,
+                ...nodeResultBuilders(),
             })),
-            catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+            catch: (cause) => new WorkflowNodeError(cause),
         }).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch((err) => Effect.succeed({ ok: false, error: err.message })));
         if (!raw.ok) {
-            return [
-                {
-                    type: 'workflow.node.finished',
-                    payload: { nodeId, result: null, error: raw.error },
-                    threadId,
-                },
-            ];
+            return finished(run, null, raw.error);
         }
         const result = isNodeResult(raw.value)
             ? raw.value
             : { type: 'value', value: raw.value };
+        return yield* nodeResultEvents(definition, nodeDef.type, run, result);
+    }).pipe(Effect.catchTag('WorkflowValueTooLargeError', (error) => Effect.succeed(finished(run, null, error.message))));
+}
+function nodeResultEvents(definition, nodeType, run, result) {
+    return Effect.gen(function* () {
+        const { threadId, nodeId, attempt } = run;
+        const outputLabel = `Node ${nodeId} output`;
         switch (result.type) {
             case 'value':
+                yield* assertJsonWithinLimit(result.value, outputLabel, definition.outputLimitBytes);
+                return finished(run, result.value, null);
+            case 'switch': {
+                const value = result.value ?? result.branch;
+                yield* assertJsonWithinLimit(value, outputLabel, definition.outputLimitBytes);
                 return [
                     {
                         type: 'workflow.node.finished',
-                        payload: { nodeId, result: result.value ?? null, error: null },
+                        payload: { nodeId, result: value, error: null, branch: result.branch },
                         threadId,
                     },
                 ];
+            }
             case 'spawn': {
-                const childThreadId = createThreadId();
+                const childThreadId = result.childThreadId ??
+                    (nodeType === 'workflow'
+                        ? nodeChildWorkflowId(threadId, nodeId, attempt)
+                        : createThreadId());
+                return spawnRequested(run, childThreadId, result, result.input);
+            }
+            case 'sleep': {
+                const now = yield* Clock.currentTimeMillis;
+                const key = nodeRunKey(nodeId, attempt, run.iteration?.index);
                 return [
                     {
-                        type: 'workflow.spawn.requested',
+                        type: 'workflow.sleep.requested',
                         payload: {
                             nodeId,
-                            childThreadId,
-                            kind: result.kind,
-                            definitionName: result.name,
-                            input: result.input ?? null,
+                            waitId: createWaitId(threadId, `sleep_${key}`),
+                            wakeAt: now + result.ms,
                         },
                         threadId,
                     },
                 ];
             }
-            case 'sleep':
+            case 'effects':
                 return [
                     {
-                        type: 'workflow.sleep.requested',
-                        payload: {
-                            nodeId,
-                            waitId: createWaitId(threadId, `sleep_${nodeId}`),
-                            wakeAt: Date.now() + result.ms,
-                        },
+                        type: 'workflow.effects.requested',
+                        payload: { nodeId, effects: result.effects ?? [] },
                         threadId,
                     },
                 ];
-            case 'effects':
+            case 'map': {
+                if (result.items.length === 0) {
+                    return finished(run, [], null);
+                }
+                const limitBytes = definition.checkpointLimitBytes ?? DEFAULT_CHECKPOINT_SIZE_LIMIT_BYTES;
+                yield* assertJsonWithinLimit(result.items, `Node ${nodeId} items`, limitBytes);
                 return [
                     {
-                        type: 'workflow.effects.requested',
+                        type: 'workflow.map.requested',
                         payload: {
                             nodeId,
-                            effects: result.effects ?? [],
+                            attempt,
+                            kind: result.kind,
+                            definitionName: result.name,
+                            definitionVersion: result.version,
+                            items: result.items,
+                            concurrency: result.concurrency,
+                            limitBytes,
                         },
                         threadId,
                     },
                 ];
+            }
+            case 'loop': {
+                const index = run.iteration?.index ?? 0;
+                if (index >= result.maxIterations) {
+                    return finished(run, run.iteration?.previous ?? null, null);
+                }
+                const childThreadId = iterationChildWorkflowId(threadId, nodeId, 'loop', attempt, index);
+                return spawnRequested(run, childThreadId, result, result.input, index);
+            }
             default: {
                 const exhaustiveCheck = result;
                 return exhaustiveCheck;
@@ -206,3 +287,21 @@ function runNode(definition, binding, nodeId, threadId) {
         }
     });
 }
+function spawnRequested(run, childThreadId, child, input, loopIndex = null) {
+    return [
+        {
+            type: 'workflow.spawn.requested',
+            payload: {
+                nodeId: run.nodeId,
+                attempt: run.attempt,
+                childThreadId,
+                kind: child.kind,
+                definitionName: child.name,
+                definitionVersion: child.version,
+                input,
+                loopIndex,
+            },
+            threadId: run.threadId,
+        },
+    ];
+}

package/dist/workflow/events.d.ts

@@ -1,5 +1,4 @@
 import { Schema } from 'effect';
-import { type RuntimeEffect } from '@swirls/looms/core';
 export declare const WorkflowNodeStartedPayloadSchema: Schema.Struct<{
     readonly nodeId: Schema.String;
 }>;
@@ -7,26 +6,99 @@ export declare const WorkflowNodeFinishedPayloadSchema: Schema.Struct<{
     readonly nodeId: Schema.String;
     readonly result: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     readonly error: Schema.NullOr<Schema.String>;
+    readonly branch: Schema.optional<Schema.String>;
 }>;
+export declare const WorkflowSkipCauseSchema: Schema.Union<readonly [Schema.Literal<"inactive">, Schema.Literal<"policy">]>;
 export declare const WorkflowNodeSkippedPayloadSchema: Schema.Struct<{
     readonly nodeId: Schema.String;
     readonly reason: Schema.String;
+    readonly cause: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"inactive">, Schema.Literal<"policy">]>, never>;
 }>;
 export declare const WorkflowSpawnRequestedPayloadSchema: Schema.Struct<{
     readonly nodeId: Schema.String;
+    readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
     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>;
+    /** Set for `loop` iterations: the node re-runs after this child instead of finishing. */
+    readonly loopIndex: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+}>;
+export declare const WorkflowMapRequestedPayloadSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
+    readonly kind: Schema.String;
+    readonly definitionName: Schema.String;
+    readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
+    readonly items: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly concurrency: Schema.Finite;
+    readonly limitBytes: Schema.Finite;
 }>;
 export declare const WorkflowSleepRequestedPayloadSchema: Schema.Struct<{
     readonly nodeId: Schema.String;
     readonly waitId: Schema.String;
-    readonly wakeAt: Schema.Number;
+    readonly wakeAt: Schema.Finite;
 }>;
 export declare const WorkflowEffectsRequestedPayloadSchema: Schema.Struct<{
     readonly nodeId: Schema.String;
-    readonly effects: Schema.$Array<Schema.Schema<RuntimeEffect>>;
+    readonly effects: 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 declare const workflowCatalog: import("@swirls/looms/core").EventCatalog<"workflow", {
     'node.started': Schema.Struct<{
@@ -36,25 +108,97 @@ export declare const workflowCatalog: import("@swirls/looms/core").EventCatalog<
         readonly nodeId: Schema.String;
         readonly result: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly error: Schema.NullOr<Schema.String>;
+        readonly branch: Schema.optional<Schema.String>;
     }>;
     'node.skipped': Schema.Struct<{
         readonly nodeId: Schema.String;
         readonly reason: Schema.String;
+        readonly cause: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"inactive">, Schema.Literal<"policy">]>, never>;
     }>;
     'spawn.requested': Schema.Struct<{
         readonly nodeId: Schema.String;
+        readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
         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>;
+        /** Set for `loop` iterations: the node re-runs after this child instead of finishing. */
+        readonly loopIndex: Schema.withDecodingDefaultKey<Schema.NullOr<Schema.Finite>, never>;
+    }>;
+    'map.requested': Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly attempt: Schema.withDecodingDefaultKey<Schema.Finite, never>;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
+        readonly items: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly concurrency: Schema.Finite;
+        readonly limitBytes: Schema.Finite;
     }>;
     'sleep.requested': Schema.Struct<{
         readonly nodeId: Schema.String;
         readonly waitId: Schema.String;
-        readonly wakeAt: Schema.Number;
+        readonly wakeAt: Schema.Finite;
     }>;
     'effects.requested': Schema.Struct<{
         readonly nodeId: Schema.String;
-        readonly effects: Schema.$Array<Schema.Schema<RuntimeEffect>>;
+        readonly effects: 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>;
+        }>]>>;
     }>;
 }>;