@pikku/inspector 0.12.43 → 0.12.45

package/dist/utils/workflow/dsl/deserialize-dsl-workflow.js

@@ -126,16 +126,157 @@ function inputToCode(input, indent, itemVar) {
     });
     return `{\n${lines.join('\n')}\n${indent}}`;
 }
+/**
+ * Convert a fanout's per-iteration body into code by walking the `next` chain
+ * from the body's entry node. Steps whose result is referenced later in the
+ * same iteration are re-emitted as `const` bindings.
+ */
+function fanoutBodyToCode(entryNodeId, nodes, indent, itemVar) {
+    const lines = [];
+    const seen = new Set();
+    let currentId = entryNodeId;
+    while (currentId && nodes[currentId] && !seen.has(currentId)) {
+        seen.add(currentId);
+        const node = nodes[currentId];
+        if ('rpcName' in node && node.rpcName) {
+            const stepName = node.stepName || `Call ${node.rpcName}`;
+            const input = (node.input || {});
+            const inputCode = inputToCode(input, indent, itemVar);
+            const options = node.options ? optionsToCode(node.options) : '';
+            const doCall = `await workflow.do('${escapeSingleQuotes(stepName)}', '${node.rpcName}', ${inputCode}${options ? `, ${options}` : ''})`;
+            lines.push(node.outputVar
+                ? `${indent}const ${node.outputVar} = ${doCall}`
+                : `${indent}${doCall}`);
+        }
+        else if ('flow' in node) {
+            // A body is not RPC-only — a sleep or suspend between calls is part of
+            // the iteration and would otherwise be dropped from the regenerated code.
+            lines.push(...nodeToCode(node, nodes, indent).filter((line) => line !== ''));
+        }
+        currentId = node.next;
+    }
+    return lines;
+}
+/**
+ * Collect every node id that belongs to a parent construct's body, following
+ * each body's `next` chain to the parent's exit.
+ */
+function collectChildNodeIds(nodes) {
+    const owned = new Set();
+    // An error handler belongs to the step that routes to it, not to the main
+    // flow — emitting it top-level would turn compensation into a step that
+    // always runs.
+    for (const node of Object.values(nodes)) {
+        const onError = node.onError;
+        if (typeof onError === 'string') {
+            owned.add(onError);
+        }
+        else if (Array.isArray(onError)) {
+            for (const handlerId of onError)
+                owned.add(handlerId);
+        }
+    }
+    const walk = (entry, exit) => {
+        const seen = new Set();
+        let currentId = entry;
+        while (currentId &&
+            nodes[currentId] &&
+            isWithinBody(currentId, exit, seen)) {
+            seen.add(currentId);
+            owned.add(currentId);
+            const next = nodes[currentId].next;
+            currentId = typeof next === 'string' ? next : undefined;
+        }
+    };
+    for (const node of Object.values(nodes)) {
+        if (!('flow' in node))
+            continue;
+        const flowNode = node;
+        const exit = flowNode.next;
+        switch (flowNode.flow) {
+            case 'branch':
+                for (const branch of flowNode.branches || [])
+                    walk(branch.entry, exit);
+                walk(flowNode.elseEntry, exit);
+                break;
+            case 'switch':
+                for (const caseItem of flowNode.cases || [])
+                    walk(caseItem.entry, exit);
+                walk(flowNode.defaultEntry, exit);
+                break;
+            case 'fanout':
+                walk(flowNode.childEntry, undefined);
+                break;
+            case 'parallel':
+                for (const childId of flowNode.children || [])
+                    walk(childId, exit);
+                break;
+        }
+    }
+    return owned;
+}
+/**
+ * Escape a value for embedding inside a single-quoted string literal.
+ */
+function escapeSingleQuotes(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+/**
+ * `outputVar` is optional — a graph-authored node may have no binding. Emitting
+ * `const undefined = ...` for those would not parse, so the expression is kept
+ * as a bare statement instead.
+ */
+function bindingPrefix(outputVar) {
+    return typeof outputVar === 'string' && outputVar
+        ? `const ${outputVar} = `
+        : '';
+}
+/**
+ * Resolve a node's `onError` node id back to the rpc name the DSL author wrote.
+ */
+function onErrorRpcNameOf(node, nodes) {
+    const onError = node.onError;
+    const handlerId = Array.isArray(onError) ? onError[0] : onError;
+    if (typeof handlerId !== 'string') {
+        return undefined;
+    }
+    const handler = nodes[handlerId];
+    return handler && 'rpcName' in handler
+        ? handler.rpcName
+        : undefined;
+}
+/**
+ * A duration is `string | number` ('5s' or 5000). Quoting a number would change
+ * the value the runtime parses, so only strings get quotes.
+ */
+function durationToCode(duration) {
+    return typeof duration === 'number'
+        ? String(duration)
+        : `'${escapeSingleQuotes(String(duration))}'`;
+}
+/**
+ * Render a switch case value. `switch` compares with ===, so quoting a number
+ * or boolean would stop the case ever matching.
+ */
+function caseValueToCode(value) {
+    if (typeof value === 'string') {
+        return `'${escapeSingleQuotes(value)}'`;
+    }
+    return String(value);
+}
 /**
  * Convert options to code
  */
-function optionsToCode(options) {
+function optionsToCode(options, onErrorRpcName) {
     const parts = [];
+    if (onErrorRpcName) {
+        parts.push(`onError: '${escapeSingleQuotes(onErrorRpcName)}'`);
+    }
     if (options.retries !== undefined) {
         parts.push(`retries: ${options.retries}`);
     }
     if (options.retryDelay !== undefined) {
-        parts.push(`retryDelay: '${options.retryDelay}'`);
+        parts.push(`retryDelay: ${durationToCode(options.retryDelay)}`);
     }
     return parts.length > 0 ? `{ ${parts.join(', ')} }` : '';
 }
@@ -193,20 +334,23 @@ function collectBranchConditionalVars(branchNode, nodes, conditionalVars) {
     if (branchNode.branches) {
         for (const branch of branchNode.branches) {
             if (branch.entry) {
-                collectVarsFromBranch(branch.entry, nodes, conditionalVars, vars);
+                collectVarsFromBranch(branch.entry, nodes, conditionalVars, vars, branchNode.next);
             }
         }
     }
     // Check else branch
     if (branchNode.elseEntry) {
-        collectVarsFromBranch(branchNode.elseEntry, nodes, conditionalVars, vars);
+        collectVarsFromBranch(branchNode.elseEntry, nodes, conditionalVars, vars, branchNode.next);
     }
     return vars;
 }
 /**
  * Recursively collect output variables from a branch that are in conditionalVars
  */
-function collectVarsFromBranch(nodeId, nodes, conditionalVars, result) {
+function collectVarsFromBranch(nodeId, nodes, conditionalVars, result, exitNodeId, seen = new Set()) {
+    if (seen.has(nodeId))
+        return;
+    seen.add(nodeId);
     const node = nodes[nodeId];
     if (!node)
         return;
@@ -220,37 +364,39 @@ function collectVarsFromBranch(nodeId, nodes, conditionalVars, result) {
     // Follow the chain of nodes within the branch
     if ('next' in node && node.next) {
         const nextId = node.next;
-        // Only follow if it's still within the branch
-        if (isWithinBranch(nextId)) {
-            collectVarsFromBranch(nextId, nodes, conditionalVars, result);
+        // Only follow if it's still within the branch body
+        if (isWithinBody(nextId, exitNodeId, seen)) {
+            collectVarsFromBranch(nextId, nodes, conditionalVars, result, exitNodeId, seen);
         }
     }
 }
 /**
- * Check if a node ID is still within a branch (not the main flow)
+ * A nested body (branch arm, switch case) ends where it rejoins the main flow.
+ * That rejoin point is the enclosing flow node's own `next`, so it is passed in
+ * explicitly rather than guessed from the node id — ids are step names, which
+ * carry no structural marker.
  */
-function isWithinBranch(nodeId) {
-    return (nodeId.includes('_then_') ||
-        nodeId.includes('_else_') ||
-        nodeId.includes('_branch'));
+function isWithinBody(nodeId, exitNodeId, seen) {
+    return nodeId !== exitNodeId && !seen.has(nodeId);
 }
 /**
  * Generate code for branch content (then/else blocks)
  */
-function generateBranchContent(entryNodeId, nodes, indent, conditionalVars) {
+function generateBranchContent(entryNodeId, nodes, indent, conditionalVars, exitNodeId) {
     const lines = [];
+    const seen = new Set();
     let currentId = entryNodeId;
     while (currentId) {
         const node = nodes[currentId];
         if (!node)
             break;
+        seen.add(currentId);
         const nodeLines = nodeToCode(node, nodes, indent, conditionalVars, true);
         lines.push(...nodeLines);
-        // Follow to next node within the branch
-        if ('next' in node && node.next) {
+        // Follow to next node within the body
+        if ('next' in node && node.next && typeof node.next === 'string') {
             const nextId = node.next;
-            // Only continue if it's still within the branch
-            if (isWithinBranch(nextId)) {
+            if (isWithinBody(nextId, exitNodeId, seen)) {
                 currentId = nextId;
             }
             else {
@@ -276,8 +422,9 @@ function nodeToCode(node, nodes, indent, conditionalVars = new Set(), isInsideBr
         const outputVar = node.outputVar;
         let doCall = `await workflow.do('${stepName}', '${node.rpcName}', ${inputCode}`;
         // Add options if present
-        if (node.options) {
-            const optCode = optionsToCode(node.options);
+        const onErrorRpc = onErrorRpcNameOf(node, nodes);
+        if (node.options || onErrorRpc) {
+            const optCode = optionsToCode(node.options ?? {}, onErrorRpc);
             if (optCode) {
                 doCall += `, ${optCode}`;
             }
@@ -303,9 +450,23 @@ function nodeToCode(node, nodes, indent, conditionalVars = new Set(), isInsideBr
         const flowNode = node;
         switch (flowNode.flow) {
             case 'sleep':
-                lines.push(`${indent}await workflow.sleep('${flowNode.stepName || 'Sleep'}', '${flowNode.duration}')`);
+                lines.push(`${indent}await workflow.sleep('${escapeSingleQuotes(flowNode.stepName || 'Sleep')}', ${typeof flowNode.expression === 'string'
+                    ? flowNode.expression
+                    : durationToCode(flowNode.duration)})`);
                 lines.push('');
                 break;
+            case 'suspend':
+                lines.push(`${indent}await workflow.suspend('${escapeSingleQuotes(String(flowNode.reason ?? ''))}')`);
+                lines.push('');
+                break;
+            case 'approval': {
+                const approvalCall = `await workflow.approval('${escapeSingleQuotes(String(flowNode.reason ?? ''))}')`;
+                lines.push(flowNode.outputVar
+                    ? `${indent}const ${flowNode.outputVar} = ${approvalCall}`
+                    : `${indent}${approvalCall}`);
+                lines.push('');
+                break;
+            }
             case 'cancel':
                 const cancelReason = flowNode.reason || flowNode.stepName || 'Workflow cancelled';
                 lines.push(`${indent}throw new WorkflowCancelledException('${cancelReason}')`);
@@ -325,7 +486,7 @@ function nodeToCode(node, nodes, indent, conditionalVars = new Set(), isInsideBr
                     const keyword = i === 0 ? 'if' : 'else if';
                     lines.push(`${indent}${keyword} (${condition}) {`);
                     if (branch.entry && nodes[branch.entry]) {
-                        const branchLines = generateBranchContent(branch.entry, nodes, indent + '  ', conditionalVars);
+                        const branchLines = generateBranchContent(branch.entry, nodes, indent + '  ', conditionalVars, flowNode.next);
                         lines.push(...branchLines);
                     }
                     lines.push(`${indent}}`);
@@ -333,75 +494,75 @@ function nodeToCode(node, nodes, indent, conditionalVars = new Set(), isInsideBr
                 // Generate else block if present
                 if (flowNode.elseEntry && nodes[flowNode.elseEntry]) {
                     lines.push(`${indent}else {`);
-                    const elseLines = generateBranchContent(flowNode.elseEntry, nodes, indent + '  ', conditionalVars);
+                    const elseLines = generateBranchContent(flowNode.elseEntry, nodes, indent + '  ', conditionalVars, flowNode.next);
                     lines.push(...elseLines);
                     lines.push(`${indent}}`);
                 }
                 lines.push('');
                 break;
-            case 'switch':
+            case 'switch': {
+                const caseExit = flowNode.next;
                 lines.push(`${indent}switch (${flowNode.expression}) {`);
                 for (const caseItem of flowNode.cases || []) {
-                    lines.push(`${indent}  case '${caseItem.value}':`);
+                    lines.push(`${indent}  case ${caseValueToCode(caseItem.value)}:`);
                     if (caseItem.entry && nodes[caseItem.entry]) {
-                        const caseLines = nodeToCode(nodes[caseItem.entry], nodes, indent + '    ');
-                        lines.push(...caseLines);
+                        lines.push(...generateBranchContent(caseItem.entry, nodes, indent + '    ', conditionalVars, caseExit));
                     }
                     lines.push(`${indent}    break`);
                 }
                 if (flowNode.defaultEntry && nodes[flowNode.defaultEntry]) {
                     lines.push(`${indent}  default:`);
-                    const defaultLines = nodeToCode(nodes[flowNode.defaultEntry], nodes, indent + '    ');
-                    lines.push(...defaultLines);
+                    lines.push(...generateBranchContent(flowNode.defaultEntry, nodes, indent + '    ', conditionalVars, caseExit));
                     lines.push(`${indent}    break`);
                 }
                 lines.push(`${indent}}`);
                 lines.push('');
                 break;
-            case 'parallel':
-                lines.push(`${indent}await Promise.all([`);
-                for (const childId of flowNode.children || []) {
-                    if (nodes[childId]) {
-                        const childNode = nodes[childId];
-                        if ('rpcName' in childNode && childNode.rpcName) {
-                            const stepName = childNode.stepName || `Call ${childNode.rpcName}`;
-                            const input = (childNode.input || {});
-                            const inputCode = inputToCode(input, indent + '  ');
-                            lines.push(`${indent}  workflow.do('${stepName}', '${childNode.rpcName}', ${inputCode}),`);
+            }
+            case 'parallel': {
+                const childNodes = (flowNode.children || [])
+                    .map((childId) => nodes[childId])
+                    .filter((child) => !!child && 'rpcName' in child && !!child.rpcName);
+                // Results the caller bound (const [a, b] = await Promise.all([...]))
+                // must be re-declared, or every later reference to them is unbound.
+                const bindings = childNodes.map((child) => child.outputVar);
+                const prefix = bindings.some(Boolean)
+                    ? `const [${bindings
+                        .map((name, i) => name ?? `_${i}`)
+                        .join(', ')}] = `
+                    : '';
+                lines.push(`${indent}${prefix}await Promise.all([`);
+                for (const childNode of childNodes) {
+                    const stepName = childNode.stepName || `Call ${childNode.rpcName}`;
+                    const input = (childNode.input || {});
+                    const inputCode = inputToCode(input, indent + '  ');
+                    let call = `workflow.do('${stepName}', '${childNode.rpcName}', ${inputCode}`;
+                    if (childNode.options) {
+                        const optCode = optionsToCode(childNode.options);
+                        if (optCode) {
+                            call += `, ${optCode}`;
                         }
                     }
+                    call += ')';
+                    lines.push(`${indent}  ${call},`);
                 }
                 lines.push(`${indent}])`);
                 lines.push('');
                 break;
-            case 'fanout':
+            }
+            case 'fanout': {
+                const bodyLines = fanoutBodyToCode(flowNode.childEntry, nodes, flowNode.mode === 'parallel' ? indent + '    ' : indent + '  ', flowNode.itemVar);
                 if (flowNode.mode === 'parallel') {
                     lines.push(`${indent}await Promise.all(`);
-                    lines.push(`${indent}  ${flowNode.sourceVar}.map(async (${flowNode.itemVar}) =>`);
-                    if (flowNode.childEntry && nodes[flowNode.childEntry]) {
-                        const childNode = nodes[flowNode.childEntry];
-                        if ('rpcName' in childNode && childNode.rpcName) {
-                            const stepName = childNode.stepName || `Call ${childNode.rpcName}`;
-                            const input = (childNode.input || {});
-                            const inputCode = inputToCode(input, indent + '    ', flowNode.itemVar);
-                            lines.push(`${indent}    await workflow.do('${stepName}', '${childNode.rpcName}', ${inputCode})`);
-                        }
-                    }
-                    lines.push(`${indent}  )`);
+                    lines.push(`${indent}  ${flowNode.sourceVar}.map(async (${flowNode.itemVar}) => {`);
+                    lines.push(...bodyLines);
+                    lines.push(`${indent}  })`);
                     lines.push(`${indent})`);
                 }
                 else {
                     // Sequential fanout
                     lines.push(`${indent}for (const ${flowNode.itemVar} of ${flowNode.sourceVar}) {`);
-                    if (flowNode.childEntry && nodes[flowNode.childEntry]) {
-                        const childNode = nodes[flowNode.childEntry];
-                        if ('rpcName' in childNode && childNode.rpcName) {
-                            const stepName = childNode.stepName || `Call ${childNode.rpcName}`;
-                            const input = (childNode.input || {});
-                            const inputCode = inputToCode(input, indent + '  ', flowNode.itemVar);
-                            lines.push(`${indent}  await workflow.do('${stepName}', '${childNode.rpcName}', ${inputCode})`);
-                        }
-                    }
+                    lines.push(...bodyLines);
                     if (flowNode.timeBetween) {
                         lines.push(`${indent}  await workflow.sleep('Wait between iterations', '${flowNode.timeBetween}')`);
                     }
@@ -409,19 +570,23 @@ function nodeToCode(node, nodes, indent, conditionalVars = new Set(), isInsideBr
                 }
                 lines.push('');
                 break;
+            }
             case 'filter':
-                lines.push(`${indent}const ${flowNode.outputVar} = ${flowNode.sourceVar}.filter((${flowNode.itemVar}) => ${conditionToCode(flowNode.condition)})`);
+                lines.push(`${indent}${bindingPrefix(flowNode.outputVar)}${flowNode.sourceVar}.filter((${flowNode.itemVar}) => ${conditionToCode(flowNode.condition)})`);
                 lines.push('');
                 break;
             case 'arrayPredicate':
                 const method = flowNode.mode === 'some' ? 'some' : 'every';
-                lines.push(`${indent}const ${flowNode.outputVar} = ${flowNode.sourceVar}.${method}((${flowNode.itemVar}) => ${conditionToCode(flowNode.condition)})`);
+                lines.push(`${indent}${bindingPrefix(flowNode.outputVar)}${flowNode.sourceVar}.${method}((${flowNode.itemVar}) => ${conditionToCode(flowNode.condition)})`);
                 lines.push('');
                 break;
             case 'return':
-                if (flowNode.outputs) {
+                if (flowNode.outputs || flowNode.spread) {
                     const returnObj = [];
-                    for (const [key, output] of Object.entries(flowNode.outputs)) {
+                    for (const spreadVar of flowNode.spread ?? []) {
+                        returnObj.push(`${indent}  ...${spreadVar},`);
+                    }
+                    for (const [key, output] of Object.entries((flowNode.outputs ?? {}))) {
                         let value;
                         if (output.from === 'outputVar') {
                             value = output.path
@@ -462,9 +627,11 @@ function nodeToCode(node, nodes, indent, conditionalVars = new Set(), isInsideBr
             case 'set':
                 // Generate variable assignment: varName = value
                 const setVar = flowNode.variable;
-                const setValue = typeof flowNode.value === 'string'
-                    ? `'${flowNode.value}'`
-                    : JSON.stringify(flowNode.value);
+                const setValue = typeof flowNode.expression === 'string'
+                    ? flowNode.expression
+                    : typeof flowNode.value === 'string'
+                        ? `'${escapeSingleQuotes(flowNode.value)}'`
+                        : JSON.stringify(flowNode.value);
                 lines.push(`${indent}${setVar} = ${setValue}`);
                 lines.push('');
                 break;
@@ -480,14 +647,44 @@ function findConditionalVars(nodes) {
     const conditionalVars = new Set();
     const varsInBranches = new Set();
     const varsUsedInReturn = new Set();
-    // Collect variables defined in branches (then/else/case/default nodes)
-    for (const [nodeId, node] of Object.entries(nodes)) {
-        if (nodeId.includes('_then_') ||
-            nodeId.includes('_else_') ||
-            nodeId.includes('_case') ||
-            nodeId.includes('_default_')) {
-            if ('outputVar' in node && node.outputVar) {
-                varsInBranches.add(node.outputVar);
+    // Collect variables defined inside a branch arm or switch case. Found by
+    // walking each body from its entry to the enclosing node's exit — node ids
+    // are step names and carry no structural marker to match on.
+    for (const node of Object.values(nodes)) {
+        if (!('flow' in node))
+            continue;
+        const flowNode = node;
+        const exit = flowNode.next;
+        const entries = [];
+        if (flowNode.flow === 'branch') {
+            for (const branch of flowNode.branches || []) {
+                if (branch.entry)
+                    entries.push(branch.entry);
+            }
+            if (flowNode.elseEntry)
+                entries.push(flowNode.elseEntry);
+        }
+        else if (flowNode.flow === 'switch') {
+            for (const caseItem of flowNode.cases || []) {
+                if (caseItem.entry)
+                    entries.push(caseItem.entry);
+            }
+            if (flowNode.defaultEntry)
+                entries.push(flowNode.defaultEntry);
+        }
+        for (const entry of entries) {
+            const seen = new Set();
+            let currentId = entry;
+            while (currentId &&
+                nodes[currentId] &&
+                isWithinBody(currentId, exit, seen)) {
+                seen.add(currentId);
+                const bodyNode = nodes[currentId];
+                if (bodyNode.outputVar) {
+                    varsInBranches.add(bodyNode.outputVar);
+                }
+                currentId =
+                    typeof bodyNode.next === 'string' ? bodyNode.next : undefined;
             }
         }
     }
@@ -571,14 +768,13 @@ export function deserializeDslWorkflow(workflow, options = {}) {
     }
     // Process nodes in order
     const orderedNodes = traverseNodes(workflow.nodes, workflow.entryNodeIds);
+    // Nodes emitted as part of a parent (branch arm, switch case, parallel group,
+    // fanout body) must not also be emitted at the top level. Ownership is read
+    // from the parents themselves — node ids are step names and a legitimate step
+    // may be called anything.
+    const ownedByParent = collectChildNodeIds(workflow.nodes);
     for (const node of orderedNodes) {
-        // Skip child nodes that are processed as part of their parent
-        if (node.nodeId.includes('_then_') ||
-            node.nodeId.includes('_else_') ||
-            node.nodeId.includes('_case') ||
-            node.nodeId.includes('_default_') ||
-            node.nodeId.includes('_child_') ||
-            node.nodeId.includes('_item_')) {
+        if (ownedByParent.has(node.nodeId)) {
             continue;
         }
         const nodeLines = nodeToCode(node, workflow.nodes, '  ', conditionalVars);
@@ -699,11 +895,79 @@ function findNextRpcNode(startNextId, nodes, flowNodeIds, visited = new Set()) {
     }
     // It's a flow node - follow its 'next' if it has one
     const flowNode = nodes[startNextId];
-    if (flowNode && 'next' in flowNode && flowNode.next) {
+    if (flowNode && 'next' in flowNode && typeof flowNode.next === 'string') {
         return findNextRpcNode(flowNode.next, nodes, flowNodeIds, visited);
     }
     return null;
 }
+/**
+ * Resolve a single next target through any intervening flow nodes.
+ */
+function resolveNextTarget(target, nodes, flowNodeIds) {
+    const resolved = flowNodeIds.has(target)
+        ? findNextRpcNode(target, nodes, flowNodeIds)
+        : target;
+    return resolved && !flowNodeIds.has(resolved) ? resolved : null;
+}
+/**
+ * Render a `next` in any of its shapes. A `next` is not always a single node
+ * id — it can fan out to an array, route by branch key, or carry conditions.
+ * Coercing those to a string produces node ids that match nothing ('a,b',
+ * '[object Object]'), silently severing the rest of the graph.
+ */
+function nextToCode(next, nodes, flowNodeIds) {
+    const renderTargets = (targets) => {
+        if (typeof targets === 'string') {
+            const resolved = resolveNextTarget(targets, nodes, flowNodeIds);
+            return resolved ? `'${resolved}'` : null;
+        }
+        const resolved = targets
+            .map((t) => resolveNextTarget(t, nodes, flowNodeIds))
+            .filter((t) => t !== null);
+        return resolved.length > 0
+            ? `[${resolved.map((t) => `'${t}'`).join(', ')}]`
+            : null;
+    };
+    if (typeof next === 'string' || Array.isArray(next)) {
+        return renderTargets(next);
+    }
+    if (typeof next === 'object' && next !== null) {
+        if ('conditions' in next && Array.isArray(next.conditions)) {
+            const conditions = next.conditions
+                .map((condition) => {
+                const target = renderTargets(condition.target);
+                return target
+                    ? `{ expression: '${escapeSingleQuotes(condition.expression)}', target: ${target} }`
+                    : null;
+            })
+                .filter((c) => c !== null);
+            if (conditions.length === 0) {
+                return null;
+            }
+            const parts = [`conditions: [${conditions.join(', ')}]`];
+            if (next.default !== undefined) {
+                const defaultTarget = renderTargets(next.default);
+                if (defaultTarget) {
+                    parts.push(`default: ${defaultTarget}`);
+                }
+            }
+            return `{ ${parts.join(', ')} }`;
+        }
+        const entries = Object.entries(next)
+            .map(([key, target]) => {
+            const isTarget = typeof target === 'string' ||
+                (Array.isArray(target) && target.every((t) => typeof t === 'string'));
+            const rendered = isTarget ? renderTargets(target) : null;
+            const safeKey = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+                ? key
+                : JSON.stringify(key);
+            return rendered ? `${safeKey}: ${rendered}` : null;
+        })
+            .filter((e) => e !== null);
+        return entries.length > 0 ? `{ ${entries.join(', ')} }` : null;
+    }
+    return null;
+}
 /**
  * Deserialize a graph workflow to pikkuWorkflowGraph code
  */
@@ -752,14 +1016,26 @@ export function deserializeGraphWorkflow(workflow, options = {}) {
         const configParts = [];
         // Add next if present - follow through flow nodes to find the actual next RPC node
         if ('next' in node && node.next) {
-            const nextId = node.next;
-            // If next points to a flow node, follow through to find the next RPC node
-            const actualNextId = flowNodeIds.has(nextId)
-                ? findNextRpcNode(nextId, workflow.nodes, flowNodeIds)
-                : nextId;
-            // Only add if we found a valid next RPC node
-            if (actualNextId && !flowNodeIds.has(actualNextId)) {
-                configParts.push(`next: '${actualNextId}'`);
+            const nextCode = nextToCode(node.next, workflow.nodes, flowNodeIds);
+            if (nextCode) {
+                configParts.push(`next: ${nextCode}`);
+            }
+        }
+        // onError, retries and retryDelay are all honoured by the graph runner,
+        // so dropping them here silently changes how the workflow behaves.
+        if ('onError' in node && node.onError) {
+            const onErrorCode = nextToCode(node.onError, workflow.nodes, flowNodeIds);
+            if (onErrorCode) {
+                configParts.push(`onError: ${onErrorCode}`);
+            }
+        }
+        if ('options' in node && node.options) {
+            const { retries, retryDelay } = node.options;
+            if (retries !== undefined) {
+                configParts.push(`retries: ${retries}`);
+            }
+            if (retryDelay !== undefined) {
+                configParts.push(`retryDelay: ${durationToCode(retryDelay)}`);
             }
         }
         // Add input if present
@@ -791,6 +1067,12 @@ export function deserializeGraphWorkflow(workflow, options = {}) {
     if (workflow.tags && workflow.tags.length > 0) {
         lines.push(`  tags: [${workflow.tags.map((t) => `'${t}'`).join(', ')}],`);
     }
+    if (workflow.notes && workflow.notes.length > 0) {
+        const notes = workflow.notes
+            .map((n) => `'${escapeSingleQuotes(n)}'`)
+            .join(', ');
+        lines.push(`  notes: [${notes}],`);
+    }
     // Generate nodes (RPC mapping)
     const rpcMapEntries = Object.entries(nodeRpcMap);
     if (rpcMapEntries.length > 0) {