@pikku/inspector 0.11.1 → 0.11.2

package/dist/{workflow/extract-simple-workflow.js → utils/workflow/dsl/extract-dsl-workflow.js}

@@ -1,11 +1,26 @@
 import * as ts from 'typescript';
-import { extractStringLiteral, extractNumberLiteral, } from '../utils/extract-node-value.js';
-import { isWorkflowDoCall, isWorkflowSleepCall, isParallelFanout, isParallelGroup, isSequentialFanout, extractForOfVariable, isArrayType, getSourceText, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowSleepCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, } from './patterns.js';
 import { validateNoDisallowedPatterns, validateAwaitedCalls, formatValidationErrors, } from './validation.js';
+import { extractStringLiteral, extractNumberLiteral, } from '../../extract-node-value.js';
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+function extractSourcePath(expr) {
+    if (ts.isIdentifier(expr)) {
+        return expr.text;
+    }
+    if (ts.isPropertyAccessExpression(expr)) {
+        const base = extractSourcePath(expr.expression);
+        if (base) {
+            return `${base}.${expr.name.text}`;
+        }
+    }
+    return null;
+}
 /**
  * Extract simple workflow metadata from a function declaration
  */
-export function extractSimpleWorkflow(funcNode, checker) {
+export function extractDSLWorkflow(funcNode, checker) {
     try {
         // Find the async arrow function
         const arrowFunc = findWorkflowFunction(funcNode);
@@ -33,6 +48,9 @@ export function extractSimpleWorkflow(funcNode, checker) {
             conditionalVars: new Set(),
             inputParamName,
             errors: [],
+            loopVars: new Set(),
+            contextVars: new Map(),
+            depth: 0,
         };
         // Validate no disallowed patterns
         const patternErrors = validateNoDisallowedPatterns(arrowFunc.body);
@@ -62,9 +80,18 @@ export function extractSimpleWorkflow(funcNode, checker) {
                 simple: false,
             };
         }
+        // Build workflow context from extracted context variables
+        const workflowContext = {};
+        for (const [name, info] of context.contextVars) {
+            workflowContext[name] = {
+                type: info.type,
+                default: info.default,
+            };
+        }
         return {
             status: 'ok',
             steps,
+            context: Object.keys(workflowContext).length > 0 ? workflowContext : undefined,
             simple: true,
         };
     }
@@ -80,7 +107,7 @@ export function extractSimpleWorkflow(funcNode, checker) {
  * Find the workflow function (async arrow function)
  */
 function findWorkflowFunction(node) {
-    // Handle pikkuSimpleWorkflowFunc(async () => {}) or pikkuWorkflowFunc(async () => {})
+    // Handle pikkuWorkflowFunc(async () => {}) or pikkuWorkflowComplexFunc(async () => {})
     if (ts.isCallExpression(node)) {
         const arg = node.arguments[0];
         if (arg && ts.isArrowFunction(arg)) {
@@ -99,7 +126,7 @@ function findWorkflowFunction(node) {
             }
         }
     }
-    // Handle pikkuSimpleWorkflowFunc({ func: async () => {} })
+    // Handle pikkuWorkflowFunc({ func: async () => {} })
     if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
             if (ts.isPropertyAssignment(prop) &&
@@ -129,17 +156,25 @@ function extractInputParamName(arrowFunc) {
 /**
  * Extract steps from the function body
  */
-function extractSteps(body, context) {
+function extractSteps(body, context, incrementDepth = false) {
     const steps = [];
     if (!ts.isBlock(body)) {
         return steps;
     }
+    // Increment depth when entering a nested block
+    if (incrementDepth) {
+        context.depth++;
+    }
     for (const statement of body.statements) {
         const extracted = extractStep(statement, context);
         if (extracted) {
             steps.push(extracted);
         }
     }
+    // Restore depth
+    if (incrementDepth) {
+        context.depth--;
+    }
     return steps;
 }
 /**
@@ -158,6 +193,10 @@ function extractStep(statement, context) {
     if (ts.isIfStatement(statement)) {
         return extractBranch(statement, context);
     }
+    // Switch statement
+    if (ts.isSwitchStatement(statement)) {
+        return extractSwitch(statement, context);
+    }
     // For-of statement (sequential fanout)
     if (ts.isForOfStatement(statement)) {
         return extractSequentialFanout(statement, context);
@@ -166,6 +205,10 @@ function extractStep(statement, context) {
     if (ts.isReturnStatement(statement)) {
         return extractReturn(statement, context);
     }
+    // Throw statement (for WorkflowCancelledException)
+    if (ts.isThrowStatement(statement)) {
+        return extractThrowCancel(statement, context);
+    }
     return null;
 }
 /**
@@ -182,9 +225,25 @@ function extractVariableDeclaration(statement, context) {
     }
     const varName = decl.name.text;
     const init = decl.initializer;
+    // Check for block-scoped variable declarations (not allowed)
+    if (context.depth > 0) {
+        context.errors.push({
+            message: `Variable declaration '${varName}' inside block is not supported in DSL workflows. Move all let/const declarations to the top level.`,
+            node: statement,
+        });
+        return null;
+    }
     if (!init) {
         return null;
     }
+    // Check for simple literal/expression context variable (let x = 'value')
+    const literalValue = extractLiteralValue(init);
+    if (literalValue !== undefined) {
+        const tsType = context.checker.getTypeAtLocation(decl);
+        const typeStr = inferSimpleType(tsType, context.checker);
+        context.contextVars.set(varName, { type: typeStr, default: literalValue });
+        return null; // No step emitted, just register the context var
+    }
     // Check for await workflow.do(...)
     if (ts.isAwaitExpression(init) && ts.isCallExpression(init.expression)) {
         const call = init.expression;
@@ -215,6 +274,28 @@ function extractVariableDeclaration(statement, context) {
             }
         }
     }
+    // Check for array.filter(...)
+    if (ts.isCallExpression(init)) {
+        if (isArrayFilter(init)) {
+            const filterStep = extractArrayFilter(init, context, varName);
+            if (filterStep) {
+                const type = context.checker.getTypeAtLocation(decl);
+                context.outputVars.set(varName, { type, node: decl });
+                if (isArrayType(type, context.checker)) {
+                    context.arrayVars.add(varName);
+                }
+                return filterStep;
+            }
+        }
+        if (isArraySome(init) || isArrayEvery(init)) {
+            const predicateStep = extractArrayPredicate(init, context, varName);
+            if (predicateStep) {
+                const type = context.checker.getTypeAtLocation(decl);
+                context.outputVars.set(varName, { type, node: decl });
+                return predicateStep;
+            }
+        }
+    }
     return null;
 }
 /**
@@ -222,13 +303,30 @@ function extractVariableDeclaration(statement, context) {
  */
 function extractExpressionStatement(statement, context) {
     let expr = statement.expression;
-    // Handle assignment: owner = await workflow.do(...)
+    // Handle assignment: x = value or x = await workflow.do(...)
     let outputVar;
     if (ts.isBinaryExpression(expr) &&
         expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
         // Extract variable name from left side
         if (ts.isIdentifier(expr.left)) {
             outputVar = expr.left.text;
+            // Check if this is an assignment to a context variable (set step)
+            if (context.contextVars.has(outputVar)) {
+                const literalValue = extractLiteralValue(expr.right);
+                if (literalValue !== undefined) {
+                    return {
+                        type: 'set',
+                        variable: outputVar,
+                        value: literalValue,
+                    };
+                }
+                // Non-literal assignment to context var - use expression as string
+                return {
+                    type: 'set',
+                    variable: outputVar,
+                    value: getSourceText(expr.right),
+                };
+            }
         }
         // Use right side as the expression to extract from
         expr = expr.right;
@@ -371,35 +469,242 @@ function extractSleepStep(call, context) {
     }
 }
 /**
- * Extract branch step from if statement
+ * Extract cancel step from throw WorkflowCancelledException statement
+ */
+function extractThrowCancel(statement, context) {
+    if (!isThrowCancelException(statement)) {
+        return null;
+    }
+    const reason = extractCancelReason(statement, context.checker);
+    return {
+        type: 'cancel',
+        reason,
+    };
+}
+/**
+ * Parse a condition expression into a Condition structure
+ */
+function parseCondition(expr) {
+    // Handle binary expressions (&&, ||)
+    if (ts.isBinaryExpression(expr)) {
+        const operator = expr.operatorToken.kind;
+        // AND operator (&&)
+        if (operator === ts.SyntaxKind.AmpersandAmpersandToken) {
+            return {
+                type: 'and',
+                conditions: [parseCondition(expr.left), parseCondition(expr.right)],
+            };
+        }
+        // OR operator (||)
+        if (operator === ts.SyntaxKind.BarBarToken) {
+            return {
+                type: 'or',
+                conditions: [parseCondition(expr.left), parseCondition(expr.right)],
+            };
+        }
+    }
+    // Handle parenthesized expressions - unwrap and parse inner
+    if (ts.isParenthesizedExpression(expr)) {
+        return parseCondition(expr.expression);
+    }
+    // Simple condition (comparison, function call, variable, etc.)
+    return {
+        type: 'simple',
+        expression: getSourceText(expr),
+    };
+}
+/**
+ * Extract branch step from if statement (supports if/else-if/else chains)
  */
 function extractBranch(statement, context) {
-    const condition = getSourceText(statement.expression);
-    // Handle both block statements and single statements
-    const thenSteps = ts.isBlock(statement.thenStatement)
-        ? extractSteps(statement.thenStatement, context)
-        : extractStepsFromStatement(statement.thenStatement, context);
-    const elseSteps = statement.elseStatement
-        ? ts.isBlock(statement.elseStatement)
-            ? extractSteps(statement.elseStatement, context)
-            : extractStepsFromStatement(statement.elseStatement, context)
-        : undefined;
+    const branches = [];
+    let elseSteps;
+    // Walk the if/else-if chain
+    let current = statement;
+    while (current) {
+        const condition = parseCondition(current.expression);
+        const steps = ts.isBlock(current.thenStatement)
+            ? extractSteps(current.thenStatement, context, true)
+            : extractStepsFromStatement(current.thenStatement, context);
+        branches.push({ condition, steps });
+        // Check for else-if or else
+        if (current.elseStatement) {
+            if (ts.isIfStatement(current.elseStatement)) {
+                // else-if: continue the chain
+                current = current.elseStatement;
+            }
+            else {
+                // else: extract the final else block and stop
+                elseSteps = ts.isBlock(current.elseStatement)
+                    ? extractSteps(current.elseStatement, context, true)
+                    : extractStepsFromStatement(current.elseStatement, context);
+                current = undefined;
+            }
+        }
+        else {
+            // No else clause
+            current = undefined;
+        }
+    }
     return {
         type: 'branch',
-        condition,
-        branches: {
-            then: thenSteps,
-            else: elseSteps,
-        },
+        branches,
+        elseSteps,
     };
 }
 /**
  * Extract steps from a single statement (non-block)
  */
 function extractStepsFromStatement(statement, context) {
+    // Increment depth for single-statement blocks (if without braces)
+    context.depth++;
     const step = extractStep(statement, context);
+    context.depth--;
     return step ? [step] : [];
 }
+/**
+ * Extract switch statement
+ */
+function extractSwitch(statement, context) {
+    const expression = getSourceText(statement.expression);
+    const cases = [];
+    let defaultSteps;
+    for (const clause of statement.caseBlock.clauses) {
+        if (ts.isCaseClause(clause)) {
+            const caseValue = extractCaseValue(clause.expression);
+            const steps = extractCaseSteps(clause.statements, context);
+            cases.push({
+                value: caseValue.value,
+                expression: caseValue.expression,
+                steps,
+            });
+        }
+        else if (ts.isDefaultClause(clause)) {
+            defaultSteps = extractCaseSteps(clause.statements, context);
+        }
+    }
+    return {
+        type: 'switch',
+        expression,
+        cases,
+        defaultSteps,
+    };
+}
+/**
+ * Extract case value from expression
+ */
+function extractCaseValue(expr) {
+    if (ts.isStringLiteral(expr)) {
+        return { value: expr.text };
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return { value: Number(expr.text) };
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+        return { value: true };
+    }
+    if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+        return { value: false };
+    }
+    if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        return { value: null };
+    }
+    return { expression: getSourceText(expr) };
+}
+/**
+ * Extract steps from case statements, stopping at break
+ */
+function extractCaseSteps(statements, context) {
+    const steps = [];
+    // Increment depth for case blocks
+    context.depth++;
+    for (const statement of statements) {
+        if (ts.isBreakStatement(statement)) {
+            break;
+        }
+        const step = extractStep(statement, context);
+        if (step) {
+            steps.push(step);
+        }
+    }
+    // Restore depth
+    context.depth--;
+    return steps;
+}
+/**
+ * Extract array filter operation
+ */
+function extractArrayFilter(call, context, outputVar) {
+    if (!ts.isPropertyAccessExpression(call.expression)) {
+        return null;
+    }
+    const sourceExpr = call.expression.expression;
+    const sourceVar = extractSourcePath(sourceExpr);
+    if (!sourceVar) {
+        return null;
+    }
+    const filterFn = call.arguments[0];
+    if (!filterFn || !ts.isArrowFunction(filterFn)) {
+        return null;
+    }
+    const itemParam = filterFn.parameters[0];
+    if (!itemParam || !ts.isIdentifier(itemParam.name)) {
+        return null;
+    }
+    const itemVar = itemParam.name.text;
+    let condition;
+    if (ts.isBlock(filterFn.body)) {
+        return null;
+    }
+    else {
+        condition = parseCondition(filterFn.body);
+    }
+    return {
+        type: 'filter',
+        sourceVar,
+        itemVar,
+        condition,
+        outputVar,
+    };
+}
+/**
+ * Extract array predicate operation (some/every)
+ */
+function extractArrayPredicate(call, context, outputVar) {
+    if (!ts.isPropertyAccessExpression(call.expression)) {
+        return null;
+    }
+    const mode = call.expression.name.text;
+    const sourceExpr = call.expression.expression;
+    const sourceVar = extractSourcePath(sourceExpr);
+    if (!sourceVar) {
+        return null;
+    }
+    const predicateFn = call.arguments[0];
+    if (!predicateFn || !ts.isArrowFunction(predicateFn)) {
+        return null;
+    }
+    const itemParam = predicateFn.parameters[0];
+    if (!itemParam || !ts.isIdentifier(itemParam.name)) {
+        return null;
+    }
+    const itemVar = itemParam.name.text;
+    let condition;
+    if (ts.isBlock(predicateFn.body)) {
+        return null;
+    }
+    else {
+        condition = parseCondition(predicateFn.body);
+    }
+    return {
+        type: 'arrayPredicate',
+        mode,
+        sourceVar,
+        itemVar,
+        condition,
+        outputVar,
+    };
+}
 /**
  * Extract parallel fanout from Promise.all(array.map(...))
  */
@@ -413,14 +718,7 @@ function extractParallelFanout(call, context) {
     }
     // Extract source array
     const sourceExpr = mapCall.expression.expression;
-    let sourceVar = null;
-    if (ts.isIdentifier(sourceExpr)) {
-        sourceVar = sourceExpr.text;
-    }
-    else if (ts.isPropertyAccessExpression(sourceExpr) &&
-        ts.isIdentifier(sourceExpr.expression)) {
-        sourceVar = sourceExpr.expression.text;
-    }
+    const sourceVar = extractSourcePath(sourceExpr);
     if (!sourceVar) {
         return null;
     }
@@ -449,7 +747,15 @@ function extractParallelFanout(call, context) {
     else if (ts.isBlock(mapFn.body)) {
         // Look for workflow.do in block
         for (const stmt of mapFn.body.statements) {
-            if (ts.isReturnStatement(stmt) && stmt.expression) {
+            if (ts.isExpressionStatement(stmt)) {
+                // Handle: await workflow.do(...)
+                if (ts.isAwaitExpression(stmt.expression) &&
+                    ts.isCallExpression(stmt.expression.expression)) {
+                    doCall = stmt.expression.expression;
+                    break;
+                }
+            }
+            else if (ts.isReturnStatement(stmt) && stmt.expression) {
                 if (ts.isCallExpression(stmt.expression)) {
                     doCall = stmt.expression;
                     break;
@@ -467,10 +773,11 @@ function extractParallelFanout(call, context) {
     if (!doCall || !isWorkflowDoCall(doCall, context.checker)) {
         return null;
     }
-    // Create a temporary context for the child step
+    // Create a temporary context for the child step with the loop variable
     const childContext = {
         ...context,
         outputVars: new Map(context.outputVars),
+        loopVars: new Set([...context.loopVars, itemVar]),
     };
     const childStep = extractRpcStep(doCall, childContext);
     if (!childStep) {
@@ -528,14 +835,45 @@ function extractSequentialFanout(statement, context) {
     }
     let childStep = null;
     let timeBetween = undefined;
+    // Create a child context with the loop variable added
+    const childContext = {
+        ...context,
+        outputVars: new Map(context.outputVars),
+        loopVars: new Set([...context.loopVars, itemVar]),
+    };
+    let workflowDoCount = 0;
     for (const stmt of statement.statement.statements) {
-        // Look for workflow.do
+        // Look for workflow.do in VariableStatement (const x = await workflow.do(...))
+        if (ts.isVariableStatement(stmt)) {
+            const declList = stmt.declarationList;
+            if (declList.declarations.length === 1) {
+                const decl = declList.declarations[0];
+                const init = decl.initializer;
+                if (init &&
+                    ts.isAwaitExpression(init) &&
+                    ts.isCallExpression(init.expression)) {
+                    const call = init.expression;
+                    if (isWorkflowDoCall(call, context.checker)) {
+                        workflowDoCount++;
+                        const varName = ts.isIdentifier(decl.name)
+                            ? decl.name.text
+                            : undefined;
+                        const step = extractRpcStep(call, childContext, varName);
+                        if (step) {
+                            childStep = step;
+                        }
+                    }
+                }
+            }
+        }
+        // Look for workflow.do in ExpressionStatement (await workflow.do(...))
         if (ts.isExpressionStatement(stmt)) {
             const expr = stmt.expression;
             if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
                 const call = expr.expression;
                 if (isWorkflowDoCall(call, context.checker)) {
-                    const step = extractRpcStep(call, context);
+                    workflowDoCount++;
+                    const step = extractRpcStep(call, childContext);
                     if (step) {
                         childStep = step;
                     }
@@ -595,6 +933,14 @@ function extractSequentialFanout(statement, context) {
     if (!childStep) {
         return null;
     }
+    // If there are multiple workflow.do calls, the loop is too complex for DSL
+    if (workflowDoCount > 1) {
+        context.errors.push({
+            message: `For-of loop has ${workflowDoCount} workflow.do calls but DSL only supports 1. Use pikkuWorkflowComplexFunc for complex loops.`,
+            node: statement,
+        });
+        return null;
+    }
     return {
         type: 'fanout',
         stepName: childStep.stepName,
@@ -605,6 +951,58 @@ function extractSequentialFanout(statement, context) {
         timeBetween,
     };
 }
+/**
+ * Extract a single output binding from an expression
+ */
+function extractOutputBinding(expr, context) {
+    // Check for property access (e.g., org.id, payment.status)
+    if (ts.isPropertyAccessExpression(expr)) {
+        const objName = ts.isIdentifier(expr.expression)
+            ? expr.expression.text
+            : null;
+        const propPath = expr.name.text;
+        if (objName && context.outputVars.has(objName)) {
+            return { from: 'outputVar', name: objName, path: propPath };
+        }
+        if (objName && context.contextVars.has(objName)) {
+            return { from: 'stateVar', name: objName, path: propPath };
+        }
+        if (objName === context.inputParamName) {
+            return { from: 'input', path: propPath };
+        }
+    }
+    // Check for identifier (simple variable reference)
+    if (ts.isIdentifier(expr)) {
+        const varName = expr.text;
+        if (context.outputVars.has(varName)) {
+            return { from: 'outputVar', name: varName };
+        }
+        if (context.contextVars.has(varName)) {
+            return { from: 'stateVar', name: varName };
+        }
+        if (varName === context.inputParamName) {
+            return { from: 'input', path: varName };
+        }
+    }
+    // Check for literals
+    if (ts.isStringLiteral(expr)) {
+        return { from: 'literal', value: expr.text };
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return { from: 'literal', value: Number(expr.text) };
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+        return { from: 'literal', value: true };
+    }
+    if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+        return { from: 'literal', value: false };
+    }
+    if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        return { from: 'literal', value: null };
+    }
+    // For any other expression (comparisons, method calls, etc.), capture as expression
+    return { from: 'expression', expression: getSourceText(expr) };
+}
 /**
  * Extract return step
  */
@@ -625,44 +1023,21 @@ function extractReturn(statement, context) {
             }
             let binding = null;
             if (ts.isShorthandPropertyAssignment(prop)) {
-                // { orgId } - must be an output variable
+                // { orgId } - must be an output variable, context variable, or input
                 const varName = prop.name.text;
                 if (context.outputVars.has(varName)) {
                     binding = { from: 'outputVar', name: varName };
                 }
-            }
-            else if (ts.isPropertyAssignment(prop)) {
-                const init = prop.initializer;
-                // Check for property access (e.g., org.id, owner?.id)
-                if (ts.isPropertyAccessExpression(init)) {
-                    const objName = ts.isIdentifier(init.expression)
-                        ? init.expression.text
-                        : null;
-                    const propPath = init.name.text;
-                    if (objName && context.outputVars.has(objName)) {
-                        binding = { from: 'outputVar', name: objName, path: propPath };
-                    }
-                }
-                // Check for optional chaining (e.g., owner?.id)
-                if (init.kind === ts.SyntaxKind.PropertyAccessExpression ||
-                    init.kind === ts.SyntaxKind.NonNullExpression) {
-                    const text = init.getText();
-                    const match = text.match(/^(\w+)\??\.(\w+)$/);
-                    if (match) {
-                        const [, objName, propPath] = match;
-                        if (context.outputVars.has(objName)) {
-                            binding = { from: 'outputVar', name: objName, path: propPath };
-                        }
-                    }
+                else if (context.contextVars.has(varName)) {
+                    binding = { from: 'stateVar', name: varName };
                 }
-                // Check for identifier (simple variable reference)
-                if (ts.isIdentifier(init)) {
-                    const varName = init.text;
-                    if (context.outputVars.has(varName)) {
-                        binding = { from: 'outputVar', name: varName };
-                    }
+                else {
+                    binding = { from: 'input', path: varName };
                 }
             }
+            else if (ts.isPropertyAssignment(prop)) {
+                binding = extractOutputBinding(prop.initializer, context);
+            }
             if (binding) {
                 outputs[propName] = binding;
             }
@@ -680,6 +1055,17 @@ function extractReturn(statement, context) {
  * Extract input sources from an argument node
  */
 function extractInputSources(node, context) {
+    // Handle when data is passed directly (e.g., workflow.do('step', 'rpc', data))
+    if (ts.isIdentifier(node)) {
+        if (node.text === context.inputParamName) {
+            // The entire input data is being passed through
+            return 'passthrough';
+        }
+        // Check if it's an output variable being passed directly
+        if (context.outputVars.has(node.text)) {
+            return 'passthrough';
+        }
+    }
     if (!ts.isObjectLiteralExpression(node)) {
         return undefined;
     }
@@ -693,9 +1079,12 @@ function extractInputSources(node, context) {
             }
             let source = null;
             if (ts.isShorthandPropertyAssignment(prop)) {
-                // { email } - could be from input or output var
+                // { email } - could be from loop var, output var, or input
                 const varName = prop.name.text;
-                if (context.outputVars.has(varName)) {
+                if (context.loopVars.has(varName)) {
+                    source = { from: 'item', path: varName };
+                }
+                else if (context.outputVars.has(varName)) {
                     source = { from: 'outputVar', name: varName };
                 }
                 else {
@@ -744,6 +1133,10 @@ function extractInputSource(node, context) {
     // Identifier: email, orgId
     if (ts.isIdentifier(node)) {
         const varName = node.text;
+        // Check if it's a loop variable (from fanout)
+        if (context.loopVars.has(varName)) {
+            return { from: 'item', path: varName };
+        }
         if (context.outputVars.has(varName)) {
             return { from: 'outputVar', name: varName };
         }
@@ -799,5 +1192,93 @@ function extractInputSource(node, context) {
         }
         return { from: 'literal', value: arr };
     }
+    // No substitution template literal: `hello`
+    if (ts.isNoSubstitutionTemplateLiteral(node)) {
+        return { from: 'literal', value: node.text };
+    }
+    // Template expression with substitutions: `hello ${name}`
+    if (ts.isTemplateExpression(node)) {
+        const parts = [node.head.text];
+        const expressions = [];
+        for (const span of node.templateSpans) {
+            // Extract each expression
+            const exprSource = extractInputSource(span.expression, context);
+            if (exprSource) {
+                expressions.push(exprSource);
+            }
+            else {
+                // Fallback: use source text as literal
+                expressions.push({
+                    from: 'literal',
+                    value: getSourceText(span.expression),
+                });
+            }
+            parts.push(span.literal.text);
+        }
+        return { from: 'template', parts, expressions };
+    }
     return null;
 }
+/**
+ * Extract a literal value from an expression
+ */
+function extractLiteralValue(expr) {
+    if (ts.isStringLiteral(expr)) {
+        return expr.text;
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return Number(expr.text);
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+        return true;
+    }
+    if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+        return false;
+    }
+    if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        return null;
+    }
+    // Array literal
+    if (ts.isArrayLiteralExpression(expr)) {
+        const values = [];
+        for (const el of expr.elements) {
+            const v = extractLiteralValue(el);
+            if (v === undefined)
+                return undefined;
+            values.push(v);
+        }
+        return values;
+    }
+    // Object literal (simple keys with literal values)
+    if (ts.isObjectLiteralExpression(expr)) {
+        const obj = {};
+        for (const prop of expr.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const v = extractLiteralValue(prop.initializer);
+                if (v === undefined)
+                    return undefined;
+                obj[prop.name.text] = v;
+            }
+            else {
+                return undefined;
+            }
+        }
+        return obj;
+    }
+    return undefined;
+}
+/**
+ * Infer a simple type string from a TypeScript type
+ */
+function inferSimpleType(type, checker) {
+    const typeStr = checker.typeToString(type);
+    if (typeStr === 'string')
+        return 'string';
+    if (typeStr === 'number')
+        return 'number';
+    if (typeStr === 'boolean')
+        return 'boolean';
+    if (typeStr.endsWith('[]') || typeStr.startsWith('Array<'))
+        return 'array';
+    return 'object';
+}