@swirls/looms 0.0.1

package/dist/workflow/effects.d.ts

@@ -0,0 +1,305 @@
+import { Schema } from 'effect';
+import { type EventInputOf, type JsonValue } from '@swirls/looms/core';
+import { type WorkflowDefinition } from './definitions';
+import { WorkflowDefinitionsTag } from './definitions-store';
+import { type WorkflowEvent } from './scope';
+export declare const scheduleEffect: NoInfer<import("@swirls/looms/core").EffectDefinition<{
+    readonly definitionName?: string | undefined;
+    readonly nodes?: {
+        readonly [x: string]: {
+            readonly status: "completed" | "failed" | "pending" | "running" | "skipped";
+            readonly result: Schema.Json;
+            readonly error: string | null;
+        };
+    } | undefined;
+    readonly input?: Schema.Json | undefined;
+}, WorkflowDefinitionsTag, (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.run.completed";
+    readonly payload: {
+        readonly output: Schema.Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.started";
+    readonly payload: {
+        readonly rootThreadId?: string | undefined;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: Schema.Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.signal.received";
+    readonly payload: {
+        readonly signalType: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.snapshot.taken";
+    readonly payload: {
+        readonly seq: number;
+        readonly stateHash: string;
+        readonly state?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.cancelled";
+    readonly payload: {
+        readonly threadId: string;
+        readonly reason?: string | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.completed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly output: Schema.Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.failed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.started";
+    readonly payload: {
+        readonly threadId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: Schema.Json;
+        readonly parentThreadId: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.fired";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.set";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+        readonly wakeAt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.registered";
+    readonly payload: {
+        readonly waitId: string;
+        readonly threadId?: string | undefined;
+        readonly on: {
+            readonly type: string | readonly string[];
+            readonly match?: Schema.Json | undefined;
+        } | {
+            readonly timerAt: number;
+        };
+        readonly tag?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.satisfied";
+    readonly payload: {
+        readonly waitId: string;
+        readonly tag?: Schema.Json | undefined;
+        readonly event: {
+            readonly id: string;
+            readonly type: string;
+            readonly payload: Schema.Json;
+        };
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.effects.requested";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly effects: readonly import("@swirls/looms/core").RuntimeEffect[];
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.node.finished";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly result: Schema.Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.node.skipped";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly reason: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.node.started";
+    readonly payload: {
+        readonly nodeId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.sleep.requested";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly waitId: string;
+        readonly wakeAt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.spawn.requested";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly childThreadId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: Schema.Json;
+    };
+})>>;
+export declare function scheduleEvents(definition: WorkflowDefinition, binding: {
+    nodes: {
+        [id: string]: {
+            status: string;
+            result: JsonValue | null;
+        };
+    };
+    input: JsonValue;
+}, threadId: string): EventInputOf<WorkflowEvent>[];
+export declare const runNodeEffect: NoInfer<import("@swirls/looms/core").EffectDefinition<{
+    readonly definitionName?: string | undefined;
+    readonly nodeId: string;
+    readonly input?: Schema.Json | undefined;
+    readonly results?: {
+        readonly [x: string]: Schema.Json;
+    } | undefined;
+}, WorkflowDefinitionsTag, (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.run.completed";
+    readonly payload: {
+        readonly output: Schema.Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.started";
+    readonly payload: {
+        readonly rootThreadId?: string | undefined;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: Schema.Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.signal.received";
+    readonly payload: {
+        readonly signalType: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.snapshot.taken";
+    readonly payload: {
+        readonly seq: number;
+        readonly stateHash: string;
+        readonly state?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.cancelled";
+    readonly payload: {
+        readonly threadId: string;
+        readonly reason?: string | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.completed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly output: Schema.Json;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.failed";
+    readonly payload: {
+        readonly threadId: string;
+        readonly error: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.thread.started";
+    readonly payload: {
+        readonly threadId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: Schema.Json;
+        readonly parentThreadId: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.fired";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.timer.set";
+    readonly payload: {
+        readonly timerId: string;
+        readonly waitId: string;
+        readonly wakeAt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.registered";
+    readonly payload: {
+        readonly waitId: string;
+        readonly threadId?: string | undefined;
+        readonly on: {
+            readonly type: string | readonly string[];
+            readonly match?: Schema.Json | undefined;
+        } | {
+            readonly timerAt: number;
+        };
+        readonly tag?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.satisfied";
+    readonly payload: {
+        readonly waitId: string;
+        readonly tag?: Schema.Json | undefined;
+        readonly event: {
+            readonly id: string;
+            readonly type: string;
+            readonly payload: Schema.Json;
+        };
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.effects.requested";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly effects: readonly import("@swirls/looms/core").RuntimeEffect[];
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.node.finished";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly result: Schema.Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.node.skipped";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly reason: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.node.started";
+    readonly payload: {
+        readonly nodeId: string;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.sleep.requested";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly waitId: string;
+        readonly wakeAt: number;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "workflow.spawn.requested";
+    readonly payload: {
+        readonly nodeId: string;
+        readonly childThreadId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly input: Schema.Json;
+    };
+})>>;

package/dist/workflow/effects.js

@@ -0,0 +1,208 @@
+import { Effect, Predicate, Schema } from 'effect';
+import { createThreadId, createWaitId } from '@swirls/looms/core';
+import { NodeStateSchema, readyNodes, } from './definitions.js';
+import { WorkflowDefinitionsTag } from './definitions-store.js';
+import { workflowModule } from './scope.js';
+const ScheduleInput = Schema.Struct({
+    definitionName: Schema.optional(Schema.String),
+    nodes: Schema.optional(Schema.Record(Schema.String, NodeStateSchema)),
+    input: Schema.optional(Schema.Json),
+});
+const RunNodeInput = Schema.Struct({
+    definitionName: Schema.optional(Schema.String),
+    nodeId: Schema.String,
+    input: Schema.optional(Schema.Json),
+    results: Schema.optional(Schema.Record(Schema.String, Schema.NullOr(Schema.Json))),
+});
+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');
+}
+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;
+        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 };
+        }
+        for (const node of definition.nodes) {
+            if (!nodes[node.id]) {
+                nodes[node.id] = { status: 'pending', result: null };
+            }
+        }
+        // SAFETY: Workflow input is validated and serialized as JsonValue.
+        return scheduleEvents(definition, { nodes, input: input.input ?? null }, 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,
+        });
+    }
+    if (ready.length > 0) {
+        return events;
+    }
+    const pending = Object.values(binding.nodes).some((n) => n.status === 'pending' || n.status === 'running');
+    if (pending) {
+        return [];
+    }
+    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` },
+                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,
+        },
+    ];
+}
+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;
+        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 yield* runNode(definition, 
+        // SAFETY: Workflow input is validated and serialized as JsonValue.
+        { input: input.input ?? null, results }, input.nodeId, threadId);
+    }),
+});
+function runNode(definition, binding, nodeId, threadId) {
+    return Effect.gen(function* () {
+        const nodeDef = definition.nodes.find((node) => node.id === nodeId);
+        if (!nodeDef) {
+            return [
+                {
+                    type: 'workflow.node.finished',
+                    payload: { nodeId, result: null, error: `Unknown node: ${nodeId}` },
+                    threadId,
+                },
+            ];
+        }
+        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 }),
+            })),
+            catch: (cause) => (cause instanceof Error ? cause : new Error(String(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,
+                },
+            ];
+        }
+        const result = isNodeResult(raw.value)
+            ? raw.value
+            : { type: 'value', value: raw.value };
+        switch (result.type) {
+            case 'value':
+                return [
+                    {
+                        type: 'workflow.node.finished',
+                        payload: { nodeId, result: result.value ?? null, error: null },
+                        threadId,
+                    },
+                ];
+            case 'spawn': {
+                const childThreadId = createThreadId();
+                return [
+                    {
+                        type: 'workflow.spawn.requested',
+                        payload: {
+                            nodeId,
+                            childThreadId,
+                            kind: result.kind,
+                            definitionName: result.name,
+                            input: result.input ?? null,
+                        },
+                        threadId,
+                    },
+                ];
+            }
+            case 'sleep':
+                return [
+                    {
+                        type: 'workflow.sleep.requested',
+                        payload: {
+                            nodeId,
+                            waitId: createWaitId(threadId, `sleep_${nodeId}`),
+                            wakeAt: Date.now() + result.ms,
+                        },
+                        threadId,
+                    },
+                ];
+            case 'effects':
+                return [
+                    {
+                        type: 'workflow.effects.requested',
+                        payload: {
+                            nodeId,
+                            effects: result.effects ?? [],
+                        },
+                        threadId,
+                    },
+                ];
+            default: {
+                const exhaustiveCheck = result;
+                return exhaustiveCheck;
+            }
+        }
+    });
+}

package/dist/workflow/events.d.ts

@@ -0,0 +1,60 @@
+import { Schema } from 'effect';
+import { type RuntimeEffect } from '@swirls/looms/core';
+export declare const WorkflowNodeStartedPayloadSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+}>;
+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>;
+}>;
+export declare const WorkflowNodeSkippedPayloadSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly reason: Schema.String;
+}>;
+export declare const WorkflowSpawnRequestedPayloadSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly childThreadId: Schema.String;
+    readonly kind: Schema.String;
+    readonly definitionName: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export declare const WorkflowSleepRequestedPayloadSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly waitId: Schema.String;
+    readonly wakeAt: Schema.Number;
+}>;
+export declare const WorkflowEffectsRequestedPayloadSchema: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly effects: Schema.$Array<Schema.Schema<RuntimeEffect>>;
+}>;
+export declare const workflowCatalog: import("@swirls/looms/core").EventCatalog<"workflow", {
+    'node.started': Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>;
+    'node.finished': Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly result: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly error: Schema.NullOr<Schema.String>;
+    }>;
+    'node.skipped': Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly reason: Schema.String;
+    }>;
+    'spawn.requested': Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly childThreadId: Schema.String;
+        readonly kind: Schema.String;
+        readonly definitionName: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    'sleep.requested': Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly waitId: Schema.String;
+        readonly wakeAt: Schema.Number;
+    }>;
+    'effects.requested': Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly effects: Schema.$Array<Schema.Schema<RuntimeEffect>>;
+    }>;
+}>;

package/dist/workflow/events.js

@@ -0,0 +1,39 @@
+import { Schema } from 'effect';
+import { defineEventCatalog } from '@swirls/looms/core';
+export const WorkflowNodeStartedPayloadSchema = Schema.Struct({
+    nodeId: Schema.String,
+});
+export const WorkflowNodeFinishedPayloadSchema = Schema.Struct({
+    nodeId: Schema.String,
+    result: Schema.NullOr(Schema.Json),
+    error: Schema.NullOr(Schema.String),
+});
+export const WorkflowNodeSkippedPayloadSchema = Schema.Struct({
+    nodeId: Schema.String,
+    reason: Schema.String,
+});
+export const WorkflowSpawnRequestedPayloadSchema = Schema.Struct({
+    nodeId: Schema.String,
+    childThreadId: Schema.String,
+    kind: Schema.String,
+    definitionName: Schema.String,
+    input: Schema.Json,
+});
+export const WorkflowSleepRequestedPayloadSchema = Schema.Struct({
+    nodeId: Schema.String,
+    waitId: Schema.String,
+    wakeAt: Schema.Number,
+});
+export const WorkflowEffectsRequestedPayloadSchema = Schema.Struct({
+    nodeId: Schema.String,
+    // SAFETY: RuntimeEffect represents serializable requested effect instructions.
+    effects: Schema.Array(Schema.Unknown),
+});
+export const workflowCatalog = defineEventCatalog('workflow', {
+    'node.started': WorkflowNodeStartedPayloadSchema,
+    'node.finished': WorkflowNodeFinishedPayloadSchema,
+    'node.skipped': WorkflowNodeSkippedPayloadSchema,
+    'spawn.requested': WorkflowSpawnRequestedPayloadSchema,
+    'sleep.requested': WorkflowSleepRequestedPayloadSchema,
+    'effects.requested': WorkflowEffectsRequestedPayloadSchema,
+});

package/dist/workflow/index.d.ts

@@ -0,0 +1,8 @@
+export * from './definitions';
+export * from './definitions-store';
+export * from './events';
+export * from './scope';
+export * from './threads';
+export * from './effects';
+export * from './projections';
+export * from './module';

package/dist/workflow/index.js

@@ -0,0 +1,8 @@
+export * from './definitions.js';
+export * from './definitions-store.js';
+export * from './events.js';
+export * from './scope.js';
+export * from './threads.js';
+export * from './effects.js';
+export * from './projections.js';
+export * from './module.js';