@pikku/core 0.11.2 → 0.12.1

package/dist/wirings/workflow/graph/graph-runner.js

@@ -1,112 +1,112 @@
-import { createRef, isRef } from './workflow-graph.types.js';
 import { pikkuState } from '../../../pikku-state.js';
-/**
- * Add a workflow graph to the system
- * This is called by the generated workflow wirings
- */
-export const addWorkflowGraph = (workflowName, graphResult) => {
-    // Get workflow metadata from inspector
-    const meta = pikkuState(null, 'workflows', 'meta');
-    const workflowMeta = meta[workflowName];
-    if (!workflowMeta) {
-        throw new Error(`Workflow metadata not found for '${workflowName}'. Make sure to run the CLI to generate metadata.`);
-    }
-    // Store workflow graph definition in state
-    const registrations = pikkuState(null, 'workflows', 'graphRegistrations');
-    registrations.set(workflowName, {
-        name: workflowName,
-        wires: graphResult.wires || {},
-        graph: graphResult.graph,
+import { RPCNotFoundError } from '../../rpc/rpc-runner.js';
+function buildTemplateRegex(nodeId) {
+    if (!nodeId.includes('${'))
+        return null;
+    const escaped = nodeId
+        .split(/\$\{[^}]+\}/)
+        .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('.+');
+    return new RegExp(`^${escaped}$`);
+}
+function remapStepNamesToNodeIds(stepNames, nodes, graphName) {
+    const templatePatterns = new Map();
+    for (const nodeId of Object.keys(nodes)) {
+        const regex = buildTemplateRegex(nodeId);
+        if (regex)
+            templatePatterns.set(nodeId, regex);
+    }
+    if (templatePatterns.size === 0)
+        return stepNames;
+    return stepNames.map((name) => {
+        if (nodes[name])
+            return name;
+        const matches = [];
+        for (const [nodeId, regex] of templatePatterns) {
+            if (regex.test(name))
+                matches.push(nodeId);
+        }
+        if (matches.length > 1) {
+            throw new Error(`Workflow graph '${graphName}': ambiguous template node match for '${name}' (${matches.join(', ')})`);
+        }
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        return name;
     });
-};
-/**
- * Get a registered workflow graph by name
- */
-export function getWorkflowGraph(name) {
-    const registrations = pikkuState(null, 'workflows', 'graphRegistrations');
-    return registrations.get(name);
 }
-/**
- * Resolve next config to array of node IDs
- * For branching (Record), uses the branch key from step
- */
-function resolveNextFromConfig(next, branchKey) {
-    if (!next)
-        return [];
-    if (typeof next === 'string')
-        return [next];
-    if (Array.isArray(next))
-        return next;
-    // Record (branching) - use branch key set by graph.branch()
-    if (!branchKey || !(branchKey in next))
-        return [];
-    const branchNext = next[branchKey];
-    return Array.isArray(branchNext) ? branchNext : [branchNext];
+function remapBranchKeys(branchKeys, nodes, graphName) {
+    const templatePatterns = new Map();
+    for (const nodeId of Object.keys(nodes)) {
+        const regex = buildTemplateRegex(nodeId);
+        if (regex)
+            templatePatterns.set(nodeId, regex);
+    }
+    if (templatePatterns.size === 0)
+        return branchKeys;
+    const remapped = {};
+    for (const [key, value] of Object.entries(branchKeys)) {
+        let mappedKey = key;
+        if (!nodes[key]) {
+            const matches = [];
+            for (const [nodeId, regex] of templatePatterns) {
+                if (regex.test(key))
+                    matches.push(nodeId);
+            }
+            if (matches.length > 1) {
+                throw new Error(`Workflow graph '${graphName}': ambiguous template branch key match for '${key}' (${matches.join(', ')})`);
+            }
+            if (matches.length === 1) {
+                mappedKey = matches[0];
+            }
+        }
+        remapped[mappedKey] = value;
+    }
+    return remapped;
+}
+function isDataRef(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$ref' in value &&
+        typeof value.$ref === 'string');
 }
-/**
- * Check if a value is a template
- */
 function isTemplate(value) {
     return (typeof value === 'object' &&
         value !== null &&
         '$template' in value &&
         typeof value.$template === 'object');
 }
-/**
- * Create a template function for use in input callbacks
- */
-function createTemplate(templateStr, refs) {
-    const parts = [];
-    const expressions = [];
-    const regex = /\$(\d+)/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = regex.exec(templateStr)) !== null) {
-        parts.push(templateStr.slice(lastIndex, match.index));
-        const refIndex = parseInt(match[1], 10);
-        const refValue = refs[refIndex];
-        if (refValue) {
-            expressions.push({ $ref: refValue.nodeId, path: refValue.path });
-        }
-        else {
-            expressions.push({ $ref: 'unknown' });
-        }
-        lastIndex = regex.lastIndex;
-    }
-    parts.push(templateStr.slice(lastIndex));
-    return { $template: { parts, expressions } };
+function getWorkflowMeta(name) {
+    const meta = pikkuState(null, 'workflows', 'meta');
+    return meta[name];
 }
-/**
- * Evaluate a node's input callback to get the input mapping
- */
-function evaluateInputCallback(node) {
-    if (!node.input)
-        return {};
-    const ref = (targetNodeId, path) => createRef(targetNodeId, path);
-    const template = (templateStr, refs) => createTemplate(templateStr, refs);
-    // Call with both ref and template - input callback may accept 1 or 2 params
-    return node.input(ref, template);
+function resolveNextFromConfig(next, branchKey) {
+    if (!next)
+        return [];
+    if (typeof next === 'string')
+        return [next];
+    if (Array.isArray(next))
+        return next;
+    if (typeof next === 'object' && next !== null) {
+        if (!branchKey || !(branchKey in next))
+            return [];
+        const branchNext = next[branchKey];
+        return Array.isArray(branchNext) ? branchNext : [branchNext];
+    }
+    return [];
 }
-/**
- * Extract node IDs referenced in an input mapping (including from templates)
- */
-function extractReferencedNodeIds(inputMapping) {
-    const nodeIds = [];
-    for (const value of Object.values(inputMapping)) {
-        if (isRef(value)) {
-            nodeIds.push(value.nodeId);
-        }
-        else if (isTemplate(value)) {
-            for (const expr of value.$template.expressions) {
-                nodeIds.push(expr.$ref);
-            }
-        }
+function getValueAtPath(obj, path) {
+    if (!path)
+        return obj;
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null)
+            return undefined;
+        current = current[part];
     }
-    return [...new Set(nodeIds)];
+    return current;
 }
-/**
- * Resolve a template value using node results
- */
 function resolveTemplate(template, nodeResults) {
     const { parts, expressions } = template.$template;
     let result = '';
@@ -123,113 +123,192 @@ function resolveTemplate(template, nodeResults) {
     }
     return result;
 }
-/**
- * Resolve input mapping using node results
- */
-function resolveInputMapping(inputMapping, nodeResults) {
+function resolveValue(value, nodeResults) {
+    if (isDataRef(value)) {
+        const source = nodeResults[value.$ref];
+        return value.path ? getValueAtPath(source, value.path) : source;
+    }
+    if (isTemplate(value)) {
+        return resolveTemplate(value, nodeResults);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveValue(item, nodeResults));
+    }
+    if (typeof value === 'object' && value !== null) {
+        const resolved = {};
+        for (const [k, v] of Object.entries(value)) {
+            resolved[k] = resolveValue(v, nodeResults);
+        }
+        return resolved;
+    }
+    return value;
+}
+function resolveSerializedInput(input, nodeResults) {
+    if (!input || Object.keys(input).length === 0)
+        return {};
     const resolved = {};
-    for (const [key, value] of Object.entries(inputMapping)) {
-        if (isRef(value)) {
-            const nodeResult = nodeResults[value.nodeId];
-            resolved[key] = value.path
-                ? getValueAtPath(nodeResult, value.path)
-                : nodeResult;
+    for (const [key, value] of Object.entries(input)) {
+        resolved[key] = resolveValue(value, nodeResults);
+    }
+    return resolved;
+}
+function collectReferencedNodeIds(value, nodeIds) {
+    if (isDataRef(value)) {
+        nodeIds.push(value.$ref);
+    }
+    else if (isTemplate(value)) {
+        for (const expr of value.$template.expressions) {
+            nodeIds.push(expr.$ref);
         }
-        else if (isTemplate(value)) {
-            resolved[key] = resolveTemplate(value, nodeResults);
+    }
+    else if (Array.isArray(value)) {
+        for (const item of value) {
+            collectReferencedNodeIds(item, nodeIds);
         }
-        else {
-            resolved[key] = value;
+    }
+    else if (typeof value === 'object' && value !== null) {
+        for (const v of Object.values(value)) {
+            collectReferencedNodeIds(v, nodeIds);
         }
     }
-    return resolved;
 }
-/**
- * Get value at a dot-notation path from an object
- */
-function getValueAtPath(obj, path) {
-    if (!path)
-        return obj;
-    const parts = path.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current == null)
-            return undefined;
-        current = current[part];
+function extractReferencedNodeIds(input) {
+    if (!input)
+        return [];
+    const nodeIds = [];
+    for (const value of Object.values(input)) {
+        collectReferencedNodeIds(value, nodeIds);
+    }
+    return [...new Set(nodeIds)];
+}
+const IGNORED_REFS = new Set(['trigger', '$item', 'unknown']);
+function normalizeNodeTargets(value) {
+    if (!value)
+        return [];
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === 'string');
+    if (typeof value === 'object') {
+        const targets = [];
+        for (const branchTarget of Object.values(value)) {
+            targets.push(...normalizeNodeTargets(branchTarget));
+        }
+        return targets;
+    }
+    return [];
+}
+function validateGraphReferences(graphName, nodes, entryNodes) {
+    const nodeIds = new Set(Object.keys(nodes));
+    for (const entryId of entryNodes) {
+        if (!nodeIds.has(entryId)) {
+            throw new Error(`Workflow graph '${graphName}': entry node '${entryId}' is not defined`);
+        }
+    }
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        const inputRefs = extractReferencedNodeIds(node.input).filter((id) => !IGNORED_REFS.has(id));
+        for (const refId of inputRefs) {
+            if (!nodeIds.has(refId)) {
+                throw new Error(`Workflow graph '${graphName}': node '${nodeId}' references unknown node '${refId}' in input`);
+            }
+        }
+        const nextTargets = normalizeNodeTargets(node.next);
+        for (const nextId of nextTargets) {
+            if (!nodeIds.has(nextId)) {
+                throw new Error(`Workflow graph '${graphName}': node '${nodeId}' routes to unknown node '${nextId}'`);
+            }
+        }
+        const errorTargets = normalizeNodeTargets(node.onError);
+        for (const errorId of errorTargets) {
+            if (!nodeIds.has(errorId)) {
+                throw new Error(`Workflow graph '${graphName}': node '${nodeId}' onError targets unknown node '${errorId}'`);
+            }
+        }
     }
-    return current;
 }
-/**
- * Get the RPC name from a graph node's func
- * Supports both function references (func.name) and string RPC names
- */
-function getRpcName(node) {
-    const func = node.func;
-    // If func is a string, use it directly as the RPC name
-    if (typeof func === 'string') {
-        return func;
-    }
-    // Otherwise, it's a function reference - use its name
-    return func?.name || 'unknown';
+function areDependenciesSatisfied(node, completedNodeIds) {
+    const deps = extractReferencedNodeIds(node.input).filter((id) => !IGNORED_REFS.has(id));
+    return deps.every((dep) => completedNodeIds.has(dep));
 }
-/**
- * Queue a graph node for execution
- */
 async function queueGraphNode(workflowService, runId, _graphName, nodeId, rpcName, input) {
-    // Step name convention: node:<nodeId>
-    // Graph name is stored as the workflow name on the run
-    await workflowService.insertStepState(runId, `node:${nodeId}`, rpcName, input, { retries: 3 });
-    await workflowService.resumeWorkflow(runId);
+    await workflowService.insertStepState(runId, nodeId, rpcName, input, {
+        retries: 0,
+    });
+    await workflowService.queueStepWorker(runId, nodeId, rpcName, input);
 }
-/**
- * Continue graph execution
- * Non-blocking - finds pending nodes, resolves inputs, queues them for execution
- */
-export async function continueGraph(workflowService, runId, graphName) {
-    const definition = getWorkflowGraph(graphName);
-    if (!definition) {
-        throw new Error(`Workflow graph '${graphName}' not found`);
+export async function continueGraph(workflowService, runId, graphName, overrideMeta) {
+    const meta = overrideMeta ?? getWorkflowMeta(graphName);
+    if (!meta?.nodes) {
+        throw new Error(`Workflow graph meta '${graphName}' not found`);
+    }
+    const nodes = meta.nodes;
+    validateGraphReferences(graphName, nodes, meta.entryNodeIds ?? []);
+    const { completedNodeIds: rawCompleted, failedNodeIds: rawFailed, branchKeys: rawBranch, } = await workflowService.getCompletedGraphState(runId);
+    const completedNodeIds = remapStepNamesToNodeIds(rawCompleted, nodes, graphName);
+    const completedNodeIdSet = new Set(completedNodeIds);
+    const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName);
+    const branchKeys = remapBranchKeys(rawBranch, nodes, graphName);
+    if (failedNodeIds.length > 0) {
+        const failedNode = failedNodeIds[0];
+        await workflowService.updateRunStatus(runId, 'failed', undefined, {
+            message: `Graph node '${failedNode}' failed after exhausting retries`,
+            stack: '',
+            code: 'GRAPH_NODE_FAILED',
+        });
+        return;
+    }
+    const currentRun = await workflowService.getRun(runId);
+    if (currentRun?.status === 'suspended') {
+        return;
     }
-    const graph = definition.graph;
-    // Get completed node IDs + branch keys (lightweight, no results)
-    const { completedNodeIds, branchKeys } = await workflowService.getCompletedGraphState(runId);
-    // Find candidate next nodes from completed nodes
-    const candidateNodes = [];
+    const candidateNodes = new Set();
     for (const nodeId of completedNodeIds) {
-        const node = graph[nodeId];
+        const node = nodes[nodeId];
         if (!node?.next)
             continue;
         const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId]);
-        candidateNodes.push(...nextNodes);
+        for (const nextNode of nextNodes) {
+            candidateNodes.add(nextNode);
+        }
     }
-    if (candidateNodes.length === 0 && completedNodeIds.length > 0) {
-        // No more nodes to run - graph complete
+    for (const entryId of meta.entryNodeIds ?? []) {
+        candidateNodes.add(entryId);
+    }
+    if (candidateNodes.size === 0 && completedNodeIds.length > 0) {
         await workflowService.updateRunStatus(runId, 'completed');
         return;
     }
-    // Filter to only nodes that don't have a step yet
-    const nodesToQueue = await workflowService.getNodesWithoutSteps(runId, candidateNodes);
-    // Queue each node for execution
+    const unstartedNodes = await workflowService.getNodesWithoutSteps(runId, [
+        ...candidateNodes,
+    ]);
+    const nodesToQueue = unstartedNodes.filter((nodeId) => {
+        const node = nodes[nodeId];
+        return node && areDependenciesSatisfied(node, completedNodeIdSet);
+    });
+    if (nodesToQueue.length === 0) {
+        const allRpcNodes = Object.entries(nodes)
+            .filter(([_, n]) => n.rpcName)
+            .map(([id]) => id);
+        const allRpcCompleted = allRpcNodes.every((id) => completedNodeIdSet.has(id));
+        if (allRpcCompleted) {
+            await workflowService.updateRunStatus(runId, 'completed');
+        }
+        return;
+    }
+    const run = await workflowService.getRun(runId);
+    const triggerInput = run?.input;
     for (const nodeId of nodesToQueue) {
-        const node = graph[nodeId];
-        if (!node)
+        const node = nodes[nodeId];
+        if (!node?.rpcName)
             continue;
-        // Evaluate input callback to get the mapping
-        const inputMapping = evaluateInputCallback(node);
-        // Only fetch results for nodes referenced in this node's input
-        const referencedNodeIds = extractReferencedNodeIds(inputMapping);
-        const nodeResults = await workflowService.getNodeResults(runId, referencedNodeIds);
-        const resolvedInput = resolveInputMapping(inputMapping, nodeResults);
-        const rpcName = getRpcName(node);
-        await queueGraphNode(workflowService, runId, graphName, nodeId, rpcName, resolvedInput);
+        const referencedNodeIds = extractReferencedNodeIds(node.input).filter((id) => !IGNORED_REFS.has(id));
+        const fetchedResults = await workflowService.getNodeResults(runId, referencedNodeIds);
+        const nodeResults = { trigger: triggerInput, ...fetchedResults };
+        const resolvedInput = resolveSerializedInput(node.input, nodeResults);
+        await queueGraphNode(workflowService, runId, graphName, nodeId, node.rpcName, resolvedInput);
     }
 }
-/**
- * Execute a graph step with wire context.
- * Called by the step worker when executing graph nodes.
- */
-export async function executeGraphStep(workflowService, rpcService, runId, stepId, stepName, rpcName, data, graphName) {
-    const nodeId = stepName.replace(/^node:/, '');
+export async function executeGraphStep(workflowService, rpcService, runId, stepId, nodeId, rpcName, data, graphName) {
     const wireState = {};
     const graphWire = {
         runId,
@@ -242,61 +321,54 @@ export async function executeGraphStep(workflowService, rpcService, runId, stepI
         getState: () => workflowService.getRunState(runId),
     };
     try {
-        // Execute the RPC with graph wire context
         const result = await rpcService.rpcWithWire(rpcName, data, {
             graph: graphWire,
         });
-        // If branch was called, store the branch key
         if (wireState.branchKey) {
             await workflowService.setBranchTaken(stepId, wireState.branchKey);
         }
         return result;
     }
     catch (error) {
-        // Check if this node has an onError handler
-        const definition = getWorkflowGraph(graphName);
-        if (definition) {
-            const node = definition.graph[nodeId];
+        if (error instanceof RPCNotFoundError) {
+            await workflowService.updateRunStatus(runId, 'suspended', undefined, {
+                message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
+                code: 'RPC_NOT_FOUND',
+            });
+            throw error;
+        }
+        const meta = getWorkflowMeta(graphName);
+        if (meta?.nodes) {
+            const node = meta.nodes[nodeId];
             if (node?.onError) {
-                // Route to error handler nodes
                 const errorNodes = Array.isArray(node.onError)
                     ? node.onError
                     : [node.onError];
                 for (const errorNodeId of errorNodes) {
-                    const errorNode = definition.graph[errorNodeId];
+                    const errorNode = meta.nodes[errorNodeId];
                     if (errorNode) {
-                        const errorRpcName = getRpcName(errorNode);
-                        // Queue error node with the error as input
-                        await queueGraphNode(workflowService, runId, graphName, errorNodeId, errorRpcName, { error: { message: error.message } });
+                        await queueGraphNode(workflowService, runId, graphName, errorNodeId, errorNode.rpcName, { error: { message: error.message } });
                     }
                 }
-                // Don't rethrow - error was handled by routing to error nodes
-                return;
+                throw error;
             }
         }
-        // No error handler - rethrow
         throw error;
     }
 }
-/**
- * Handle node completion - re-triggers graph continuation
- */
 export async function onGraphNodeComplete(workflowService, runId, graphName) {
     await continueGraph(workflowService, runId, graphName);
 }
-/**
- * Execute a graph node inline (without queue)
- */
-async function executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, input, graph) {
-    const node = graph[nodeId];
+export async function runFromMeta(workflowService, runId, meta, _rpcService) {
+    await continueGraph(workflowService, runId, meta.name, meta);
+}
+async function executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, input, nodes) {
+    const node = nodes[nodeId];
     if (!node)
         return;
-    const rpcName = getRpcName(node);
-    const stepName = `node:${nodeId}`;
-    // Insert step state
-    const stepState = await workflowService.insertStepState(runId, stepName, rpcName, input, { retries: 3 });
+    const rpcName = node.rpcName;
+    const stepState = await workflowService.insertStepState(runId, nodeId, rpcName, input, { retries: 3 });
     await workflowService.setStepRunning(stepState.stepId);
-    // Execute with graph wire context
     const wireState = {};
     const graphWire = {
         runId,
@@ -312,141 +384,157 @@ async function executeGraphNodeInline(workflowService, rpcService, runId, graphN
         const result = await rpcService.rpcWithWire(rpcName, input, {
             graph: graphWire,
         });
-        // If branch was called, store the branch key
         if (wireState.branchKey) {
             await workflowService.setBranchTaken(stepState.stepId, wireState.branchKey);
         }
         await workflowService.setStepResult(stepState.stepId, result);
     }
     catch (error) {
+        if (error instanceof RPCNotFoundError) {
+            await workflowService.setStepError(stepState.stepId, error);
+            await workflowService.updateRunStatus(runId, 'suspended', undefined, {
+                message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
+                code: 'RPC_NOT_FOUND',
+            });
+            return;
+        }
         await workflowService.setStepError(stepState.stepId, error);
-        // Check if this node has an onError handler
-        const definition = getWorkflowGraph(graphName);
-        if (definition) {
-            const node = definition.graph[nodeId];
-            if (node?.onError) {
-                // Route to error handler nodes (inline)
-                const errorNodes = Array.isArray(node.onError)
-                    ? node.onError
-                    : [node.onError];
-                await Promise.all(errorNodes.map((errorNodeId) => executeGraphNodeInline(workflowService, rpcService, runId, graphName, errorNodeId, { error: { message: error.message } }, graph)));
-                return;
-            }
+        if (node?.onError) {
+            const errorNodes = Array.isArray(node.onError)
+                ? node.onError
+                : [node.onError];
+            await Promise.all(errorNodes.map((errorNodeId) => executeGraphNodeInline(workflowService, rpcService, runId, graphName, errorNodeId, { error: { message: error.message } }, nodes)));
+            return;
         }
-        // No error handler - rethrow
         throw error;
     }
 }
-/**
- * Continue graph execution inline (without queue)
- * Executes nodes in parallel where possible using Promise.all
- */
-async function continueGraphInline(workflowService, rpcService, runId, graphName, graph, triggerInput) {
+async function continueGraphInline(workflowService, rpcService, runId, graphName, nodes, triggerInput, entryNodeIds) {
     while (true) {
-        // Get completed node IDs + branch keys (lightweight, no results)
-        const { completedNodeIds, branchKeys } = await workflowService.getCompletedGraphState(runId);
-        // Find candidate next nodes from completed nodes
-        const candidateNodes = [];
+        const { completedNodeIds: rawCompleted, failedNodeIds: rawFailed, branchKeys: rawBranch, } = await workflowService.getCompletedGraphState(runId);
+        const completedNodeIds = remapStepNamesToNodeIds(rawCompleted, nodes, graphName);
+        const completedNodeIdSet = new Set(completedNodeIds);
+        const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName);
+        const branchKeys = remapBranchKeys(rawBranch, nodes, graphName);
+        if (failedNodeIds.length > 0) {
+            const failedNode = failedNodeIds[0];
+            await workflowService.updateRunStatus(runId, 'failed', undefined, {
+                message: `Graph node '${failedNode}' failed after exhausting retries`,
+                stack: '',
+                code: 'GRAPH_NODE_FAILED',
+            });
+            return;
+        }
+        const candidateNodes = new Set();
         for (const nodeId of completedNodeIds) {
-            const node = graph[nodeId];
+            const node = nodes[nodeId];
             if (!node?.next)
                 continue;
             const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId]);
-            candidateNodes.push(...nextNodes);
+            for (const nextNode of nextNodes) {
+                candidateNodes.add(nextNode);
+            }
         }
-        if (candidateNodes.length === 0 && completedNodeIds.length > 0) {
-            // No more nodes to run - graph complete
+        for (const entryId of entryNodeIds) {
+            candidateNodes.add(entryId);
+        }
+        if (candidateNodes.size === 0 && completedNodeIds.length > 0) {
             await workflowService.updateRunStatus(runId, 'completed');
             return;
         }
-        // Filter to only nodes that don't have a step yet
-        const nodesToExecute = await workflowService.getNodesWithoutSteps(runId, candidateNodes);
+        const unstartedNodes = await workflowService.getNodesWithoutSteps(runId, [
+            ...candidateNodes,
+        ]);
+        const nodesToExecute = unstartedNodes.filter((nodeId) => {
+            const node = nodes[nodeId];
+            return node && areDependenciesSatisfied(node, completedNodeIdSet);
+        });
         if (nodesToExecute.length === 0) {
-            // No more nodes to execute - if we've completed at least one node, we're done
-            // This handles branching where only some paths are taken
-            if (completedNodeIds.length > 0) {
+            if (completedNodeIds.length > 0 && unstartedNodes.length === 0) {
                 await workflowService.updateRunStatus(runId, 'completed');
             }
             return;
         }
-        // Execute all nodes in parallel
         await Promise.all(nodesToExecute.map(async (nodeId) => {
-            const node = graph[nodeId];
-            if (!node)
+            const node = nodes[nodeId];
+            if (!node?.rpcName)
                 return;
-            // Evaluate input callback to get the mapping
-            const inputMapping = evaluateInputCallback(node);
-            // Only fetch results for nodes referenced in this node's input (excluding trigger)
-            const referencedNodeIds = extractReferencedNodeIds(inputMapping).filter((id) => id !== 'trigger');
+            const referencedNodeIds = extractReferencedNodeIds(node.input).filter((id) => !IGNORED_REFS.has(id));
             const fetchedResults = await workflowService.getNodeResults(runId, referencedNodeIds);
-            // Merge fetched results with trigger input
             const nodeResults = { trigger: triggerInput, ...fetchedResults };
-            const resolvedInput = resolveInputMapping(inputMapping, nodeResults);
-            await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, graph);
+            const resolvedInput = resolveSerializedInput(node.input, nodeResults);
+            await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, nodes);
         }));
     }
 }
-/**
- * Start a workflow graph execution
- * @param startNode - Optional starting node ID (from wire config). If not provided, uses wires.api from graph definition.
- */
-export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode) {
-    const definition = getWorkflowGraph(graphName);
-    if (!definition) {
+export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode, wire) {
+    const meta = getWorkflowMeta(graphName);
+    if (!meta?.nodes) {
         throw new Error(`Workflow graph '${graphName}' not found`);
     }
-    // Use startNode from caller if provided, otherwise use wires.api from graph definition
-    const apiStartNode = startNode ?? definition.wires?.api;
-    const entryNodes = apiStartNode ? [apiStartNode] : [];
+    const nodes = meta.nodes;
+    const entryNodes = startNode
+        ? [startNode]
+        : (meta.entryNodeIds ?? []);
+    validateGraphReferences(graphName, nodes, entryNodes);
     if (entryNodes.length === 0) {
-        throw new Error(`Workflow graph '${graphName}' has no wires.api defined and no startNode was provided`);
+        throw new Error(`Workflow graph '${graphName}': no entry nodes found in meta or startNode`);
+    }
+    const readyEntryNodes = entryNodes.filter((nodeId) => {
+        const node = nodes[nodeId];
+        return node && areDependenciesSatisfied(node, new Set());
+    });
+    if (readyEntryNodes.length === 0) {
+        throw new Error(`Workflow graph '${graphName}': no entry nodes have satisfied dependencies`);
     }
-    const graph = definition.graph;
-    const runId = await workflowService.createRun(graphName, triggerInput, inline);
-    // Register as inline for fast lookup
+    if (!meta.graphHash) {
+        throw new Error(`Workflow graph '${graphName}': missing graphHash in meta`);
+    }
+    const runId = await workflowService.createRun(graphName, triggerInput, inline ?? false, meta.graphHash, wire ?? { type: 'unknown' });
     if (inline) {
         workflowService.registerInlineRun(runId);
     }
-    // Create nodeResults with trigger for resolving entry node inputs
     const triggerNodeResults = { trigger: triggerInput };
-    try {
-        if (inline && rpcService) {
-            // Inline mode - execute entry nodes in parallel
-            await Promise.all(entryNodes.map(async (nodeId) => {
-                const node = graph[nodeId];
-                if (!node)
-                    return;
-                // Evaluate and resolve entry node input
-                const inputMapping = evaluateInputCallback(node);
-                const resolvedInput = Object.keys(inputMapping).length > 0
-                    ? resolveInputMapping(inputMapping, triggerNodeResults)
-                    : triggerInput;
-                await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, graph);
-            }));
-            // Continue executing remaining nodes inline
-            await continueGraphInline(workflowService, rpcService, runId, graphName, graph, triggerInput);
-        }
-        else {
-            // Queue-based mode
-            for (const nodeId of entryNodes) {
-                const node = graph[nodeId];
-                if (!node)
-                    continue;
-                // Evaluate and resolve entry node input
-                const inputMapping = evaluateInputCallback(node);
-                const resolvedInput = Object.keys(inputMapping).length > 0
-                    ? resolveInputMapping(inputMapping, triggerNodeResults)
-                    : triggerInput;
-                const rpcName = getRpcName(node);
-                await queueGraphNode(workflowService, runId, graphName, nodeId, rpcName, resolvedInput);
+    if (inline && rpcService) {
+        const executeInline = async () => {
+            try {
+                await Promise.all(readyEntryNodes.map(async (nodeId) => {
+                    const node = nodes[nodeId];
+                    if (!node?.rpcName)
+                        return;
+                    const resolvedInput = node.input && Object.keys(node.input).length > 0
+                        ? resolveSerializedInput(node.input, triggerNodeResults)
+                        : triggerInput;
+                    await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, nodes);
+                }));
+                await continueGraphInline(workflowService, rpcService, runId, graphName, nodes, triggerInput, entryNodes);
             }
-        }
-        return { runId };
+            catch (error) {
+                await workflowService.updateRunStatus(runId, 'failed', undefined, {
+                    message: error.message,
+                    stack: error.stack || '',
+                    code: 'GRAPH_NODE_FAILED',
+                });
+            }
+            finally {
+                workflowService.unregisterInlineRun(runId);
+            }
+        };
+        await executeInline();
     }
-    finally {
-        // Clean up inline tracking
+    else {
+        for (const nodeId of readyEntryNodes) {
+            const node = nodes[nodeId];
+            if (!node?.rpcName)
+                continue;
+            const resolvedInput = node.input && Object.keys(node.input).length > 0
+                ? resolveSerializedInput(node.input, triggerNodeResults)
+                : triggerInput;
+            await queueGraphNode(workflowService, runId, graphName, nodeId, node.rpcName, resolvedInput);
+        }
         if (inline) {
             workflowService.unregisterInlineRun(runId);
         }
     }
+    return { runId };
 }