@swirls/looms 0.0.1

package/dist/workflow/module.js

@@ -0,0 +1,19 @@
+import { defineModule } from '@swirls/looms/core';
+import { WorkflowDefinitionsLive } from './definitions-store.js';
+import { runNodeEffect, scheduleEffect } from './effects.js';
+import { nodes } from './projections.js';
+import { workflowModule } from './scope.js';
+import { workflowThread } from './threads.js';
+export function workflow(options = {}) {
+    const definitions = options.definitions ?? [];
+    return defineModule(workflowModule, () => ({
+        definitions,
+        threads: { workflow: workflowThread },
+        effects: {
+            schedule: scheduleEffect,
+            runNode: runNodeEffect,
+        },
+        projections: { nodes },
+        services: () => WorkflowDefinitionsLive(definitions),
+    }));
+}

package/dist/workflow/projections.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from 'effect';
+export declare const NodesProjectionSchema: Schema.Struct<{
+    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>;
+    }>>;
+}>;
+export type NodesProjectionState = Schema.Schema.Type<typeof NodesProjectionSchema>;
+export declare const nodes: import("@swirls/looms/core").ProjectionDefinition<{
+    readonly nodes: {
+        readonly [x: string]: {
+            readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
+            readonly result: Schema.Json;
+            readonly error: string | null;
+        };
+    };
+} | {
+    nodes: {
+        [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;
+        };
+    };
+}>;

package/dist/workflow/projections.js

@@ -0,0 +1,43 @@
+import { Predicate, Schema } from 'effect';
+import { NodeStateSchema } from './definitions.js';
+import { workflowModule } from './scope.js';
+export const NodesProjectionSchema = Schema.Struct({
+    nodes: Schema.Record(Schema.String, NodeStateSchema),
+});
+export const nodes = workflowModule.projection({
+    name: 'nodes',
+    shape: NodesProjectionSchema,
+    initialState: { nodes: {} },
+    reduce(state, event) {
+        switch (event.type) {
+            case 'workflow.node.started': {
+                const { nodeId } = event.payload;
+                return {
+                    nodes: { ...state.nodes, [nodeId]: { status: 'running', result: null, error: null } },
+                };
+            }
+            case 'workflow.node.finished': {
+                const { nodeId, result, error } = event.payload;
+                const failed = Predicate.isString(error) && error.length > 0;
+                return {
+                    nodes: {
+                        ...state.nodes,
+                        [nodeId]: {
+                            status: failed ? 'failed' : 'completed',
+                            result: result ?? null,
+                            error: failed ? error : null,
+                        },
+                    },
+                };
+            }
+            case 'workflow.node.skipped': {
+                const { nodeId } = event.payload;
+                return {
+                    nodes: { ...state.nodes, [nodeId]: { status: 'skipped', result: null, error: null } },
+                };
+            }
+            default:
+                return state;
+        }
+    },
+});

package/dist/workflow/scope.d.ts

@@ -0,0 +1,61 @@
+import { type EventOf } from '@swirls/looms/core';
+export declare const workflowModule: import("@swirls/looms/core").ModuleScope<"workflow", import("@swirls/looms/core").ScopeUniverse<import("@swirls/looms/core").EventCatalog<"workflow", {
+    'node.started': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+    }>;
+    'node.finished': import("effect/Schema").Struct<{
+        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>;
+    }>;
+    'node.skipped': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly reason: import("effect/Schema").String;
+    }>;
+    'spawn.requested': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly childThreadId: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").String;
+        readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+    }>;
+    'sleep.requested': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly waitId: import("effect/Schema").String;
+        readonly wakeAt: import("effect/Schema").Number;
+    }>;
+    '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>>;
+    }>;
+}>, undefined>, import("@swirls/looms/core").EventCatalog<"workflow", {
+    'node.started': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+    }>;
+    'node.finished': import("effect/Schema").Struct<{
+        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>;
+    }>;
+    'node.skipped': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly reason: import("effect/Schema").String;
+    }>;
+    'spawn.requested': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly childThreadId: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").String;
+        readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+    }>;
+    'sleep.requested': import("effect/Schema").Struct<{
+        readonly nodeId: import("effect/Schema").String;
+        readonly waitId: import("effect/Schema").String;
+        readonly wakeAt: import("effect/Schema").Number;
+    }>;
+    '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>>;
+    }>;
+}>, undefined>;
+export type WorkflowEvent = EventOf<typeof workflowModule>;

package/dist/workflow/scope.js

@@ -0,0 +1,7 @@
+import { createModuleScope } from '@swirls/looms/core';
+import { workflowCatalog } from './events.js';
+export const workflowModule = createModuleScope({
+    namespace: 'workflow',
+    protocolVersion: '1.0.0',
+    events: workflowCatalog,
+});

package/dist/workflow/threads.d.ts

@@ -0,0 +1,171 @@
+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 workflowThread: import("@swirls/looms/core").ThreadDefinition<{
+    definitionName?: string;
+    concurrency: number;
+    input: JsonValue;
+    nodeIds: string[];
+    nodes: {
+        [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;
+        };
+    };
+    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;
+            };
+        } | {
+            type: 'runtime.cancel';
+            threadId: string;
+            tag: string;
+        } | {
+            type: 'runtime.complete';
+            output: JsonValue;
+            tag: string;
+        } | {
+            type: 'runtime.emit';
+            event: EventInput;
+            tag: 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;
+        } | {
+            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;
+        };
+    })[];
+}>;

package/dist/workflow/threads.js

@@ -0,0 +1,287 @@
+import { Predicate, Schema } from 'effect';
+import { asJson, createWaitId, emit, fail, invoke, isWithdrawnError, spawn, wait, } from '@swirls/looms/core';
+import {} from './definitions.js';
+import { runNodeEffect, scheduleEffect } from './effects.js';
+import { workflowModule } from './scope.js';
+export { NodeStateSchema, NodeStatusSchema } from './definitions.js';
+// SAFETY: WorkflowState is folded by reducers; Schema.Unknown is a typed placeholder, not a decoder.
+export const WorkflowStateSchema = Schema.Unknown;
+function scheduleInvocation(state) {
+    return invoke(scheduleEffect, {
+        definitionName: state.definitionName,
+        nodes: state.nodes,
+        input: state.input,
+    });
+}
+function runNodeInvocation(state, nodeId) {
+    const results = {};
+    for (const [id, node] of Object.entries(state.nodes)) {
+        results[id] = node.result;
+    }
+    return invoke(runNodeEffect, {
+        definitionName: state.definitionName,
+        nodeId,
+        input: state.input,
+        results,
+    }, `runNode_${nodeId}`);
+}
+export const workflowThread = workflowModule.thread({
+    kind: 'workflow',
+    shape: WorkflowStateSchema,
+    initialState: (ctx) => ({
+        definitionName: ctx.definitionName,
+        nodes: {},
+        concurrency: 8,
+        input: ctx.input,
+        nodeIds: [],
+        needsSchedule: false,
+        runningNodes: [],
+        pendingSpawns: [],
+        pendingSleeps: [],
+        pendingEffects: [],
+        pendingEmits: [],
+        status: 'running',
+        error: null,
+    }),
+    step(state, event, ctx) {
+        switch (event.type) {
+            case 'runtime.thread.started': {
+                const payload = event.payload;
+                const defName = payload.definitionName || state.definitionName;
+                const inputObj = Predicate.isObject(payload.input) ? payload.input : {};
+                const nodeIds = Array.isArray(inputObj.nodeIds)
+                    ? inputObj.nodeIds.filter(Predicate.isString)
+                    : state.nodeIds;
+                const nodes = {};
+                for (const nodeId of nodeIds) {
+                    nodes[nodeId] = { status: 'pending', result: null, error: null };
+                }
+                return {
+                    ...state,
+                    definitionName: defName,
+                    nodes,
+                    nodeIds,
+                    input: payload.input ?? state.input,
+                    needsSchedule: true,
+                };
+            }
+            case 'workflow.node.started': {
+                const nodeId = event.payload.nodeId;
+                if (!nodeId) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    nodes: {
+                        ...state.nodes,
+                        [nodeId]: { status: 'running', result: null, error: null },
+                    },
+                    runningNodes: state.runningNodes.includes(nodeId)
+                        ? state.runningNodes
+                        : [...state.runningNodes, nodeId],
+                    needsSchedule: false,
+                };
+            }
+            case 'workflow.node.finished': {
+                const { nodeId, result, error } = event.payload;
+                if (!nodeId) {
+                    return state;
+                }
+                const failed = Predicate.isString(error) && error.length > 0;
+                return {
+                    ...state,
+                    nodes: {
+                        ...state.nodes,
+                        [nodeId]: {
+                            status: failed ? 'failed' : 'completed',
+                            result: result ?? null,
+                            error: failed ? error : null,
+                        },
+                    },
+                    runningNodes: state.runningNodes.filter((id) => id !== nodeId),
+                    pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+                    pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
+                    pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
+                    pendingEmits: state.pendingEmits.filter((item) => item.id !== `finished_${nodeId}`),
+                    status: failed ? 'failed' : state.status,
+                    error: failed ? error : state.error,
+                    needsSchedule: !failed,
+                };
+            }
+            case 'workflow.spawn.requested': {
+                const { childThreadId, kind, definitionName, nodeId, input } = event.payload;
+                if (!childThreadId || !kind || !definitionName || !nodeId) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    pendingSpawns: [
+                        ...state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+                        {
+                            childThreadId,
+                            kind,
+                            definitionName,
+                            nodeId,
+                            input: input ?? null,
+                        },
+                    ],
+                };
+            }
+            case 'workflow.sleep.requested': {
+                const { waitId, wakeAt, nodeId } = event.payload;
+                if (!waitId || !Predicate.isNumber(wakeAt) || !nodeId) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    pendingSleeps: [
+                        ...state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
+                        { waitId, wakeAt, nodeId },
+                    ],
+                };
+            }
+            case 'workflow.effects.requested': {
+                const { nodeId, effects: rawEffects } = event.payload;
+                const effects = Array.isArray(rawEffects) ? rawEffects : [];
+                if (!nodeId) {
+                    return state;
+                }
+                const taggedEffects = effects.map((effect, idx) => {
+                    if (effect.type === 'runtime.wait' && 'on' in effect) {
+                        const tag = Predicate.isObject(effect.tag) ? { ...effect.tag, nodeId } : { nodeId };
+                        return { ...effect, tag };
+                    }
+                    if (!('tag' in effect && Predicate.isString(effect.tag))) {
+                        return { ...effect, tag: `${nodeId}_${effect.type}_${idx}` };
+                    }
+                    return effect;
+                });
+                return {
+                    ...state,
+                    pendingEffects: [
+                        ...state.pendingEffects.filter((item) => item.nodeId !== nodeId),
+                        { nodeId, effects: taggedEffects },
+                    ],
+                };
+            }
+            case 'runtime.effect.failed': {
+                const error = event.payload.error || 'effect failed';
+                if (isWithdrawnError(error)) {
+                    return state;
+                }
+                const running = Object.entries(state.nodes).find(([, node]) => node.status === 'running');
+                if (!running) {
+                    return state;
+                }
+                const nodeId = running[0];
+                const message = `Node ${nodeId} failed: ${error}`;
+                return {
+                    ...state,
+                    nodes: {
+                        ...state.nodes,
+                        [nodeId]: { status: 'failed', result: null, error: message },
+                    },
+                    runningNodes: state.runningNodes.filter((id) => id !== nodeId),
+                    pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+                    pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
+                    pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
+                    pendingEmits: [
+                        ...state.pendingEmits.filter((item) => item.id !== `finished_${nodeId}`),
+                        {
+                            id: `finished_${nodeId}`,
+                            event: {
+                                type: 'workflow.node.finished',
+                                payload: { nodeId, result: null, error: message },
+                                threadId: ctx.threadId,
+                            },
+                        },
+                    ],
+                };
+            }
+            case 'runtime.wait.satisfied': {
+                const tag = event.payload.tag;
+                if (!Predicate.isObject(tag)) {
+                    return state;
+                }
+                const nodeId = Predicate.isString(tag.nodeId) ? tag.nodeId : undefined;
+                if (!nodeId) {
+                    return state;
+                }
+                const embedded = event.payload.event;
+                const embeddedObj = Predicate.isObject(embedded) && Predicate.isObject(embedded.payload)
+                    ? embedded.payload
+                    : {};
+                const error = Predicate.isString(embeddedObj.error) ? embeddedObj.error : null;
+                const result = embeddedObj.output ?? (Predicate.isObject(embedded) ? embedded.payload : { waited: true });
+                return {
+                    ...state,
+                    pendingSpawns: state.pendingSpawns.filter((item) => item.nodeId !== nodeId),
+                    pendingSleeps: state.pendingSleeps.filter((item) => item.nodeId !== nodeId),
+                    pendingEffects: state.pendingEffects.filter((item) => item.nodeId !== nodeId),
+                    pendingEmits: [
+                        ...state.pendingEmits.filter((item) => item.id !== `finished_${nodeId}`),
+                        {
+                            id: `finished_${nodeId}`,
+                            event: {
+                                type: 'workflow.node.finished',
+                                payload: {
+                                    nodeId,
+                                    // SAFETY: result is serialized to a JSON-compatible node execution result.
+                                    result: asJson(result) ?? null,
+                                    error,
+                                },
+                                threadId: ctx.threadId,
+                            },
+                        },
+                    ],
+                };
+            }
+            default:
+                return state;
+        }
+    },
+    effects(state, ctx) {
+        const effects = [];
+        if (state.needsSchedule) {
+            effects.push(scheduleInvocation(state));
+        }
+        for (const nodeId of state.runningNodes) {
+            effects.push(runNodeInvocation(state, nodeId));
+        }
+        for (const spawnReq of state.pendingSpawns) {
+            const waitId = createWaitId(ctx.threadId, `spawn_${spawnReq.childThreadId}`);
+            effects.push(spawn({
+                childThreadId: spawnReq.childThreadId,
+                kind: spawnReq.kind,
+                definitionName: spawnReq.definitionName,
+                input: spawnReq.input,
+            }), wait({
+                waitId,
+                on: {
+                    type: ['runtime.thread.completed', 'runtime.thread.failed'],
+                    match: { threadId: spawnReq.childThreadId },
+                },
+                tag: { nodeId: spawnReq.nodeId },
+            }));
+        }
+        for (const sleepReq of state.pendingSleeps) {
+            effects.push(wait({
+                waitId: sleepReq.waitId,
+                on: { timerAt: sleepReq.wakeAt },
+                tag: { nodeId: sleepReq.nodeId },
+            }));
+        }
+        for (const effectReq of state.pendingEffects) {
+            for (const eff of effectReq.effects) {
+                effects.push(eff);
+            }
+        }
+        for (const emitReq of state.pendingEmits) {
+            effects.push(emit(emitReq.event));
+        }
+        if (state.status === 'failed') {
+            effects.push(fail(state.error ?? 'Workflow execution failed'));
+        }
+        return effects;
+    },
+});