@swirls/looms 0.0.2 → 0.1.0

package/dist/workflow/definitions.js

@@ -1,4 +1,6 @@
 import { Schema } from 'effect';
+import { DEFAULT_DEFINITION_VERSION } from '@swirls/looms/core';
+import { DEFAULT_GRAPH_CONCURRENCY, getReadyNodeIds, resolveGraphConcurrency, topologicalSort, workflowEdges, } from './graph.js';
 export const NodeStatusSchema = Schema.Union([
     Schema.Literal('pending'),
     Schema.Literal('running'),
@@ -10,23 +12,87 @@ export const NodeStateSchema = Schema.Struct({
     status: NodeStatusSchema,
     result: Schema.NullOr(Schema.Json),
     error: Schema.NullOr(Schema.String),
+    attempts: Schema.optional(Schema.Finite),
+    branch: Schema.optional(Schema.String),
+    /** Policy skips (skip/fallback) still satisfy dependents; inactive skips propagate. */
+    skipCause: Schema.optional(Schema.Union([Schema.Literal('inactive'), Schema.Literal('policy')])),
+    iteration: Schema.optional(Schema.Struct({ index: Schema.Finite, previous: Schema.Json })),
 });
+function compatibleNodeStatus(status) {
+    switch (status) {
+        case 'pending':
+        case 'running':
+        case 'completed':
+        case 'failed':
+        case 'skipped':
+            return status;
+        default:
+            return 'pending';
+    }
+}
 export function defineWorkflow(def) {
-    // SAFETY: factory fields match WorkflowDefinition.
-    return { kind: 'workflow', ...def, input: def.input };
+    const definition = {
+        kind: 'workflow',
+        ...def,
+        version: def.version ?? DEFAULT_DEFINITION_VERSION,
+        concurrency: resolveGraphConcurrency(def.concurrency),
+    };
+    topologicalSort(definition.nodes, workflowEdges(definition));
+    for (const node of definition.nodes) {
+        const failure = node.failure;
+        if (failure?.type === 'retry' &&
+            (!Number.isInteger(failure.maxAttempts) ||
+                failure.maxAttempts < 1 ||
+                failure.maxAttempts > 64)) {
+            throw new Error(`Node "${node.id}" retry maxAttempts must be between 1 and 64`);
+        }
+        if (failure?.type === 'fallback' &&
+            !definition.nodes.some((candidate) => candidate.id === failure.nodeId)) {
+            throw new Error(`Node "${node.id}" references unknown fallback "${failure.nodeId}"`);
+        }
+    }
+    return definition;
 }
 export function readyNodes(workflow, nodeStates) {
-    return workflow.nodes
-        .filter((node) => {
+    const states = {};
+    for (const node of workflow.nodes) {
         const state = nodeStates[node.id];
-        if (state && state.status !== 'pending') {
-            return false;
-        }
-        const deps = node.deps ?? [];
-        return deps.every((depId) => {
-            const dep = nodeStates[depId];
-            return dep?.status === 'completed' || dep?.status === 'skipped';
-        });
-    })
-        .map((node) => node.id);
+        states[node.id] = {
+            status: compatibleNodeStatus(state?.status),
+            result: null,
+            error: null,
+        };
+    }
+    return getReadyNodeIds(workflow, states);
+}
+function childRef(child) {
+    return {
+        kind: child.kind,
+        name: child.name,
+        version: child.version ?? DEFAULT_DEFINITION_VERSION,
+    };
+}
+function iterations(child, items, concurrency) {
+    return {
+        type: 'map',
+        ...childRef(child),
+        items,
+        concurrency: resolveGraphConcurrency(concurrency),
+    };
+}
+/** Builds the helpers a node's `run` uses to describe durable work. */
+export function nodeResultBuilders() {
+    return {
+        spawn: (child, input) => ({ type: 'spawn', ...childRef(child), input }),
+        sleep: (ms) => ({ type: 'sleep', ms }),
+        effects: (effects) => ({ type: 'effects', effects }),
+        map: (child, items) => iterations(child, items, 1),
+        fanout: (child, items, concurrency = DEFAULT_GRAPH_CONCURRENCY) => iterations(child, items, concurrency),
+        loop: (child, input, { maxIterations }) => {
+            if (!Number.isInteger(maxIterations) || maxIterations < 0) {
+                throw new Error('loop maxIterations must be a non-negative integer');
+            }
+            return { type: 'loop', ...childRef(child), input, maxIterations };
+        },
+    };
 }