@scenario-labs/sdk 1.1.0 → 2.0.0

package/lib/workflow_converter.js

@@ -0,0 +1,995 @@
+"use strict";
+// Converts a workflow editor state (nodes + edges) to a flow array suitable for the Scenario API.
+// Ported from fawkes useConvertWorkflowToApp — pure function, no React dependencies.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertWorkflowEditorToFlow = convertWorkflowEditorToFlow;
+// ---- Utility functions ----
+function nodeIdToFlowId(nodeId) {
+    return nodeId.replace(/\s/g, '');
+}
+function escapeCELString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n');
+}
+function formatTextAsCELString(text) {
+    return `'${text.replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`;
+}
+function buildConcatArrayTransform(variables) {
+    if (variables.length === 0)
+        return '[]';
+    return variables
+        .map((v) => {
+        const expr = v.isArray ? v.name : `[${v.name}]`;
+        return v.isRequired ? expr : `(exists('${v.name}') ? ${expr} : [])`;
+    })
+        .join(' + ');
+}
+function convertValueToList(value) {
+    return value
+        .replace(/\[|\]/g, '')
+        .split('+')
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+function getConditionalInputHandleId(nodeId) {
+    return `${nodeId}-source-conditional`;
+}
+function getForEachFlowListInputDescriptor(args) {
+    const { listProvider, outputHandle, inputIndex } = args;
+    const isText = listProvider?.type === 'splitText' ||
+        listProvider?.type === 'text' ||
+        listProvider?.type === 'llm' ||
+        listProvider?.type === 'transformText' ||
+        (outputHandle?.type === 'text' && !!outputHandle.isArray);
+    return isText ?
+        { name: `text${inputIndex}`, type: 'string_array' }
+        : { name: `image${inputIndex}`, type: 'file_array' };
+}
+function getForEachIterationRefName(outputHandle, outputIndex) {
+    return outputHandle?.type === 'text' ? `text${outputIndex}` : `image${outputIndex}`;
+}
+function getHasComposeLayerSourceInput(layerInputs) {
+    return layerInputs.some((inp) => inp.name === 'source');
+}
+function conditionToCelExpression(condition) {
+    if (!condition.field)
+        return 'false';
+    const { field, operator, value } = condition;
+    function escStr(s) {
+        return `'${s.replace(/'/g, "''")}'`;
+    }
+    function escRx(s) {
+        return s.replace(/[.+*?[\]()^$|\\]/g, '\\$&');
+    }
+    function fmtVal(v) {
+        if (v === undefined)
+            return "''";
+        if (Array.isArray(v))
+            return `[${v.map((x) => escStr(String(x))).join(', ')}]`;
+        const n = Number(v);
+        if (!isNaN(n) && v !== '' && String(n) === String(v).trim())
+            return String(n);
+        return escStr(String(v));
+    }
+    switch (operator) {
+        case 'isEmpty':
+            return `${field} == null || size(${field}) == 0 || (type(${field}) != list && trim(${field}) == "")`;
+        case 'isNotEmpty':
+            return `${field} != null && size(${field}) > 0 && (type(${field}) == list || trim(${field}) != "")`;
+        case 'equals':
+            return `trim(${field}) == ${fmtVal(value)}`;
+        case 'notEquals':
+            return `trim(${field}) != ${fmtVal(value)}`;
+        case 'contains':
+            return `${field}.matches('.*${escRx(String(value || '')).replace(/'/g, "''")}.*')`;
+        case 'notContains':
+            return `!${field}.matches('.*${escRx(String(value || '')).replace(/'/g, "''")}.*')`;
+        case 'greaterThan':
+            return `${field} > ${fmtVal(value)}`;
+        case 'greaterThanOrEqual':
+            return `${field} >= ${fmtVal(value)}`;
+        case 'lessThan':
+            return `${field} < ${fmtVal(value)}`;
+        case 'lessThanOrEqual':
+            return `${field} <= ${fmtVal(value)}`;
+        case 'between':
+            if (Array.isArray(value) && value.length === 2) {
+                const n1 = Number(value[0]);
+                const n2 = Number(value[1]);
+                if (!isNaN(n1) && !isNaN(n2))
+                    return `${field} >= ${n1} && ${field} <= ${n2}`;
+            }
+            return 'false';
+        default:
+            return 'false';
+    }
+}
+function conditionBlockToCEL(block, nodeIdToInputName) {
+    const exprs = block.conditions
+        .map((c) => {
+        const mappedField = c.field ? nodeIdToInputName.get(c.field) ?? c.field : undefined;
+        return conditionToCelExpression({ ...c, field: mappedField });
+    })
+        .filter((e) => e !== 'false');
+    if (exprs.length === 0)
+        return '';
+    if (exprs.length === 1)
+        return exprs[0];
+    return exprs.join(block.logic === 'or' ? ' || ' : ' && ');
+}
+function getSourceRef(edge, ctx) {
+    const { nodes, inputNodeIds, nodeIdToInputNameMap, nodeIdToFlowIdMap, nodeHandleTransformMap } = ctx;
+    const targetNodeId = edge.target;
+    const targetNode = nodes.find((n) => n.id === targetNodeId);
+    if (!targetNode)
+        return undefined;
+    if (inputNodeIds.includes(targetNodeId) && nodeHandleTransformMap) {
+        const handle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+        const handleName = handle?.name ?? 'output';
+        if (handleName !== 'output') {
+            const transformId = nodeHandleTransformMap.get(`${targetNodeId}_${handleName}`);
+            if (transformId)
+                return { node: transformId, name: 'all' };
+        }
+    }
+    if (inputNodeIds.includes(targetNodeId)) {
+        const inputName = nodeIdToInputNameMap.get(targetNodeId);
+        if (inputName)
+            return { node: 'workflow', name: inputName };
+    }
+    if (targetNode.type === 'forEach' && edge.targetHandle) {
+        const m = edge.targetHandle.match(/-output-(\d+)$/);
+        if (m) {
+            const targetFlowId = nodeIdToFlowIdMap.get(targetNodeId);
+            if (targetFlowId) {
+                const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+                return { node: targetFlowId, name: getForEachIterationRefName(outHandle, m[1]) };
+            }
+        }
+    }
+    if (targetNode.type === 'forEachEnd') {
+        const parentId = targetNode.data.parentNodeId;
+        if (parentId) {
+            const forEachFlowId = nodeIdToFlowIdMap.get(parentId);
+            if (forEachFlowId)
+                return { node: forEachFlowId };
+        }
+    }
+    if (targetNode.type === 'ifElse') {
+        const handles = targetNode.data.outputHandles ?? [];
+        const handleIndex = handles.findIndex((h) => h.id === edge.targetHandle);
+        if (handleIndex !== -1) {
+            const targetFlowId = nodeIdToFlowIdMap.get(targetNodeId);
+            const blocks = targetNode.data.conditionBlocks ?? [];
+            const isElse = handleIndex >= blocks.length;
+            return { node: targetFlowId, equal: isElse ? '1' : String(handleIndex + 2) };
+        }
+    }
+    if ((targetNode.type === 'model' || targetNode.type === 'asset') &&
+        edge.targetHandle &&
+        nodeHandleTransformMap) {
+        const handle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+        const handleName = handle?.name ?? 'output';
+        if (handleName !== 'output') {
+            const transformId = nodeHandleTransformMap.get(`${targetNodeId}_${handleName}`);
+            if (transformId)
+                return { node: transformId, name: 'all' };
+        }
+    }
+    if (targetNode.type === 'llm' && edge.targetHandle && nodeHandleTransformMap) {
+        const handle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+        if (handle?.name === 'outputs') {
+            const transformId = nodeHandleTransformMap.get(`${targetNodeId}_outputs`);
+            if (transformId)
+                return { node: transformId, name: 'all' };
+        }
+    }
+    const targetFlowId = nodeIdToFlowIdMap.get(targetNodeId);
+    if (targetFlowId)
+        return { node: targetFlowId, name: 'all' };
+    return undefined;
+}
+function getInputHandle(edge, inputHandles) {
+    return inputHandles?.flatMap((h) => {
+        if (h.id === edge.sourceHandle)
+            return [h];
+        for (const sub of h.subHandles ?? []) {
+            if (sub.id === edge.sourceHandle)
+                return [sub];
+        }
+        return [];
+    })[0];
+}
+function hasHandleConnection(node, handleName, edges, nodeId) {
+    return edges
+        .filter((e) => e.target === nodeId)
+        .some((e) => (node.data.outputHandles?.find((h) => h.id === e.targetHandle)?.name ?? 'output') === handleName);
+}
+function getOutputHandleVarName(targetNodeId, handleName) {
+    return ['output', 'allOutputs'].includes(handleName) ? targetNodeId : `${targetNodeId}_${handleName}`;
+}
+function setOrPushFlowInput(flowInputs, existingIndex, input) {
+    if (existingIndex !== -1) {
+        flowInputs[existingIndex] = input;
+    }
+    else {
+        flowInputs.push(input);
+    }
+}
+function addVideoFirstLastFrameTransforms(nodeId, flowId, node, edges, flow, nodeHandleTransformMap, options) {
+    const handles = options?.onlyHandle ? [options.onlyHandle] : ['firstFrame', 'lastFrame'];
+    for (const handleName of handles) {
+        if (!hasHandleConnection(node, handleName, edges, nodeId))
+            continue;
+        const transformId = options?.inputName ? flowId : `${flowId}_${handleName}`;
+        const ref = options?.inputName ?
+            { node: 'workflow', name: options.inputName }
+            : { node: flowId, name: 'all' };
+        flow.push({
+            id: transformId,
+            type: 'transform',
+            logic: { transform: `exists('videoOutput') ? assetJson(videoOutput).${handleName}.assetId : []` },
+            inputs: [{ name: 'videoOutput', type: 'file', ref }],
+        });
+        nodeHandleTransformMap.set(`${nodeId}_${handleName}`, transformId);
+    }
+}
+function collectConditionalConnectionInputs(incomingEdges, nodeId, ctx) {
+    const conditionalHandleId = getConditionalInputHandleId(nodeId);
+    return incomingEdges
+        .filter((e) => e.sourceHandle === conditionalHandleId)
+        .flatMap((edge) => {
+        const targetNode = ctx.nodes.find((n) => n.id === edge.target);
+        if (targetNode?.type !== 'ifElse')
+            return [];
+        const ref = getSourceRef(edge, ctx);
+        if (!ref)
+            return [];
+        return [{ name: 'connection', type: 'connection', ref }];
+    });
+}
+function toStaticInput(name, type, value) {
+    if (value === undefined || value === '')
+        return undefined;
+    const isNum = typeof value === 'number';
+    const isStr = typeof value === 'string';
+    const isBool = typeof value === 'boolean';
+    const isStrArr = Array.isArray(value) && value.every((v) => typeof v === 'string');
+    if (!isNum && !isStr && !isBool && !isStrArr)
+        return undefined;
+    if (isStrArr && value.length === 0)
+        return undefined;
+    return { name, type, value: value };
+}
+function isFormArray(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item)));
+}
+function isModelCompose(model) {
+    return !!model?.id && (model.tags ?? []).includes('compose');
+}
+function getIsConditionallyExecuted(targetNodeId, nodes, edges) {
+    const conditionalHandleId = getConditionalInputHandleId(targetNodeId);
+    return edges.some((e) => {
+        const sourceNode = nodes.find((n) => n.id === e.target);
+        return (e.source === targetNodeId && e.sourceHandle === conditionalHandleId && sourceNode?.type === 'ifElse');
+    });
+}
+function getForEachBodyEditorNodeIds(forEachId, forEachEndId, edges) {
+    const bodyNodeIds = new Set();
+    const queue = [];
+    const escaped = forEachId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const edge of edges) {
+        if (edge.target === forEachId && edge.targetHandle?.match(new RegExp(`^${escaped}-output-\\d+$`))) {
+            queue.push(edge.source);
+        }
+    }
+    while (queue.length > 0) {
+        const nodeId = queue.pop();
+        if (nodeId === forEachEndId || bodyNodeIds.has(nodeId))
+            continue;
+        bodyNodeIds.add(nodeId);
+        for (const edge of edges) {
+            if (edge.target === nodeId && !bodyNodeIds.has(edge.source) && edge.source !== forEachEndId) {
+                queue.push(edge.source);
+            }
+        }
+    }
+    return bodyNodeIds;
+}
+function sortNodesByInputKeys(nodes, inputKeys) {
+    return [...nodes].sort((a, b) => {
+        const ai = inputKeys.indexOf(a.id);
+        const bi = inputKeys.indexOf(b.id);
+        if (ai === -1 && bi === -1)
+            return 0;
+        if (ai === -1)
+            return 1;
+        if (bi === -1)
+            return -1;
+        return ai - bi;
+    });
+}
+function getNodeOutputValue(node, targetHandleId) {
+    if (node.type === 'text')
+        return node.data.value || '';
+    if (node.type === 'asset') {
+        const d = node.data;
+        if (targetHandleId) {
+            const handleName = d.outputHandles?.find((h) => h.id === targetHandleId)?.name ?? 'output';
+            if (handleName === 'firstFrame')
+                return d.valueFirstFrame;
+            if (handleName === 'lastFrame')
+                return d.valueLastFrame;
+        }
+        return (Array.isArray(d.value) ? d.value : d.value) || undefined;
+    }
+    return undefined;
+}
+const RUNNABLE_TYPES = new Set(['model', 'llm', 'forEach', 'forEachEnd']);
+function internalGetConnectedNodes(nodes, edges, startNodeId, direction, isStoppingAtRunnableNodes) {
+    const nodesById = new Map(nodes.map((n) => {
+        const meta = { id: n.id, type: n.type };
+        if (n.type === 'forEachEnd') {
+            const parentId = n.data.parentNodeId;
+            if (parentId !== undefined) {
+                meta.parentNodeId = parentId;
+            }
+        }
+        return [n.id, meta];
+    }));
+    const edgesSimple = edges.map((e) => ({ source: e.source, target: e.target }));
+    function isInternalForEachEdge(e) {
+        const src = nodesById.get(e.source);
+        const tgt = nodesById.get(e.target);
+        return src?.type === 'forEach' && tgt?.type === 'forEachEnd' && tgt.parentNodeId === src.id;
+    }
+    function findIds(nodeId, visited) {
+        if (visited.has(nodeId))
+            return [];
+        visited.add(nodeId);
+        const result = [];
+        const relevant = edgesSimple.filter((e) => (direction === 'output' ? e.target === nodeId : e.source === nodeId) && !isInternalForEachEdge(e));
+        for (const edge of relevant) {
+            const connectedId = direction === 'output' ? edge.source : edge.target;
+            const connectedNode = nodesById.get(connectedId);
+            if (!connectedNode)
+                continue;
+            result.push(connectedId);
+            if (isStoppingAtRunnableNodes && RUNNABLE_TYPES.has(connectedNode.type))
+                continue;
+            result.push(...findIds(connectedId, visited));
+        }
+        return result;
+    }
+    const ids = findIds(startNodeId, new Set());
+    const idSet = new Set(ids);
+    return nodes.filter((n) => idSet.has(n.id));
+}
+function normalizeNodes(nodes) {
+    return nodes.map((node) => {
+        if (node.type !== 'model' && node.type !== 'llm')
+            return node;
+        const hasType = (t, v) => Array.isArray(t) ? t.includes(v) : t === v;
+        const inputHandles = (node.data.inputHandles ?? [])
+            .flatMap((h) => (h.subHandles ? h.subHandles : [h]))
+            .filter((h) => hasType(h.type, 'conditional') ||
+            hasType(h.type, 'prompt') ||
+            hasType(h.type, 'image') ||
+            hasType(h.type, 'video') ||
+            hasType(h.type, '3d') ||
+            hasType(h.type, 'audio') ||
+            (node.type === 'llm' && h.name === 'textInputs'));
+        return { ...node, data: { ...node.data, inputHandles } };
+    });
+}
+// ---- Main function ----
+/**
+ * Converts a workflow editor state (nodes, edges, inputKeys) into a flow array
+ * ready to be passed to `client.workflows.update({ flow: ... })`.
+ *
+ * @example
+ * ```ts
+ * const flow = convertWorkflowEditorToFlow({ nodes, edges, inputKeys, getModel });
+ * await client.workflows.update(workflowId, { flow: flow as WorkflowUpdateParams.Flow[] });
+ * ```
+ */
+function convertWorkflowEditorToFlow(params) {
+    const { edges, inputKeys } = params;
+    const nodes = normalizeNodes(params.nodes);
+    const inputNodeIds = nodes.filter((n) => !!n.data.isInput).map((n) => n.id);
+    const selectedOutputNodes = nodes.filter((n) => (n.type === 'model' || n.type === 'forEachEnd') && !!n.data.isOutput);
+    const selectedOutputNodeIds = selectedOutputNodes.map((n) => n.id);
+    const selectedOutputModelNodeIds = new Set(selectedOutputNodes
+        .filter((n) => n.type === 'model')
+        .map((n) => n.id));
+    // Collect all nodes in branches that lead to selected outputs
+    const nodesInSelectedBranches = new Set();
+    for (const outputNode of selectedOutputNodes) {
+        const branchNodes = internalGetConnectedNodes(nodes, edges, outputNode.id, 'input', false);
+        for (const n of branchNodes) {
+            nodesInSelectedBranches.add(n.id);
+            if (outputNode.type === 'forEachEnd' && n.type === 'model' && !!n.data.isOutput) {
+                selectedOutputModelNodeIds.add(n.id);
+            }
+        }
+    }
+    // Models fed from a forEachEnd "results" handle also inherit output inclusion
+    for (const outputNode of selectedOutputNodes) {
+        if (outputNode.type !== 'forEachEnd')
+            continue;
+        const inputHandleIds = new Set((outputNode.data.inputHandles ?? []).map((h) => h.id));
+        for (const edge of edges) {
+            if (!edge.sourceHandle || edge.source !== outputNode.id || !inputHandleIds.has(edge.sourceHandle))
+                continue;
+            const tgt = nodes.find((n) => n.id === edge.target);
+            if (tgt?.type === 'model')
+                selectedOutputModelNodeIds.add(tgt.id);
+        }
+    }
+    const filteredNodes = nodes.filter((n) => nodesInSelectedBranches.has(n.id) ||
+        inputNodeIds.includes(n.id) ||
+        selectedOutputNodeIds.includes(n.id));
+    const sortedNodes = sortNodesByInputKeys(filteredNodes, inputKeys);
+    const nodeIdToFlowIdMap = new Map(sortedNodes
+        .filter((n) => !inputNodeIds.includes(n.id) && n.type !== 'forEachEnd')
+        .map((n) => [n.id, nodeIdToFlowId(n.id)]));
+    const nodeIdToInputNameMap = new Map(inputNodeIds.map((id) => [id, nodeIdToFlowId(id)]));
+    const nodeHandleTransformMap = new Map();
+    const ctx = {
+        nodes,
+        inputNodeIds,
+        nodeIdToInputNameMap,
+        nodeIdToFlowIdMap,
+        nodeHandleTransformMap,
+    };
+    const flow = [];
+    const forEachBodyEditorNodeIds = new Map();
+    const forEachLoopFlowIds = new Map();
+    const forEachFlowItemRefs = new Map();
+    for (const node of sortedNodes) {
+        if (node.type !== 'forEach')
+            continue;
+        const endNode = nodes.find((n) => n.type === 'forEachEnd' && n.data.parentNodeId === node.id);
+        if (!endNode)
+            continue;
+        forEachBodyEditorNodeIds.set(node.id, getForEachBodyEditorNodeIds(node.id, endNode.id, edges));
+        forEachLoopFlowIds.set(node.id, []);
+    }
+    // Pre-populate video firstFrame/lastFrame transform IDs for input nodes
+    const addedInputVideoTransforms = new Set();
+    for (const inputNodeId of inputNodeIds) {
+        const inputNode = nodes.find((n) => n.id === inputNodeId);
+        if (!inputNode || inputNode.type !== 'asset' || inputNode.data.type !== 'video')
+            continue;
+        for (const handleName of ['firstFrame', 'lastFrame']) {
+            if (hasHandleConnection(inputNode, handleName, edges, inputNodeId)) {
+                nodeHandleTransformMap.set(`${inputNodeId}_${handleName}`, `${inputNodeId}_${handleName}`);
+            }
+        }
+    }
+    function ensureInputVideoTransformsAdded() {
+        for (const inputNodeId of inputNodeIds) {
+            const inputNode = nodes.find((n) => n.id === inputNodeId);
+            if (!inputNode || inputNode.type !== 'asset' || inputNode.data.type !== 'video')
+                continue;
+            const inputName = nodeIdToInputNameMap.get(inputNodeId);
+            if (!inputName)
+                continue;
+            for (const handleName of ['firstFrame', 'lastFrame']) {
+                const key = `${inputNodeId}_${handleName}`;
+                if (addedInputVideoTransforms.has(key))
+                    continue;
+                if (!hasHandleConnection(inputNode, handleName, edges, inputNodeId))
+                    continue;
+                addVideoFirstLastFrameTransforms(inputNodeId, key, inputNode, edges, flow, nodeHandleTransformMap, {
+                    inputName,
+                    onlyHandle: handleName,
+                });
+                addedInputVideoTransforms.add(key);
+            }
+        }
+    }
+    for (const node of sortedNodes) {
+        if (inputNodeIds.includes(node.id))
+            continue;
+        const flowId = nodeIdToFlowIdMap.get(node.id);
+        if (!flowId)
+            continue;
+        const flowLengthBefore = flow.length;
+        const incomingEdges = edges.filter((e) => e.source === node.id);
+        // ------------------------------------
+        // Model / LLM -> custom-model
+        // ------------------------------------
+        if (node.type === 'model' || node.type === 'llm') {
+            const nodeData = node.data;
+            const flowInputs = [];
+            const remoteModel = nodeData.modelId ? params.getModel?.(nodeData.modelId) : undefined;
+            const model = remoteModel === 'unknown' ? undefined : remoteModel;
+            const modelInputs = model?.inputs;
+            const conditionalHandleId = getConditionalInputHandleId(node.id);
+            const edgesByInput = new Map();
+            for (const edge of incomingEdges) {
+                if (edge.sourceHandle === conditionalHandleId)
+                    continue;
+                const handle = getInputHandle(edge, node.data.inputHandles);
+                if (!handle?.name)
+                    continue;
+                const existing = edgesByInput.get(handle.name);
+                if (existing)
+                    existing.push(edge);
+                else
+                    edgesByInput.set(handle.name, [edge]);
+            }
+            if (nodeData.form) {
+                for (const [key, value] of Object.entries(nodeData.form)) {
+                    if (value === undefined || value === '')
+                        continue;
+                    const modelInput = modelInputs?.find((inp) => inp.name === key);
+                    if (modelInput?.type === 'inputs_array') {
+                        if (!isFormArray(value))
+                            continue;
+                        const nestedInputs = modelInput.inputs ?? [];
+                        const items = [];
+                        for (const [index, form] of value.entries()) {
+                            const itemInputs = [];
+                            for (const nestedInput of nestedInputs) {
+                                const edgeKey = `${key}[${index}].${nestedInput.name}`;
+                                const edgeGroup = edgesByInput.get(edgeKey);
+                                if (edgeGroup && edgeGroup.length > 0) {
+                                    const ref = getSourceRef(edgeGroup[0], ctx);
+                                    if (ref)
+                                        itemInputs.push({ name: nestedInput.name, type: nestedInput.type, ref });
+                                    edgesByInput.delete(edgeKey);
+                                }
+                                else {
+                                    const inp = toStaticInput(nestedInput.name, nestedInput.type, form[nestedInput.name]);
+                                    if (inp)
+                                        itemInputs.push(inp);
+                                }
+                            }
+                            const isValid = isModelCompose(model) ? getHasComposeLayerSourceInput(itemInputs) : itemInputs.length > 0;
+                            if (isValid)
+                                items.push(itemInputs);
+                        }
+                        if (items.length > 0)
+                            flowInputs.push({ name: key, type: 'inputs_array', items });
+                    }
+                    else {
+                        const type = modelInput?.type ??
+                            (typeof value === 'number' ? 'number'
+                                : typeof value === 'boolean' ? 'boolean'
+                                    : 'string');
+                        const inp = toStaticInput(key, type, value);
+                        if (inp)
+                            flowInputs.push(inp);
+                    }
+                }
+            }
+            for (const [inputName, inputEdges] of edgesByInput) {
+                const existingIndex = flowInputs.findIndex((inp) => inp.name === inputName);
+                const modelInput = modelInputs?.find((inp) => inp.name === inputName);
+                if (!modelInput)
+                    continue;
+                const inputType = modelInput.type;
+                if (inputEdges.length === 1) {
+                    const ref = getSourceRef(inputEdges[0], ctx);
+                    if (!ref)
+                        continue;
+                    setOrPushFlowInput(flowInputs, existingIndex, { name: inputName, type: inputType, ref });
+                }
+                else {
+                    const allConditional = inputEdges.every((e) => getIsConditionallyExecuted(e.target, nodes, edges));
+                    if (allConditional) {
+                        const conditionalNodeIds = inputEdges
+                            .map((e) => inputNodeIds.includes(e.target) ?
+                            nodeIdToInputNameMap.get(e.target)
+                            : nodeIdToFlowIdMap.get(e.target))
+                            .filter((id) => id != null);
+                        if (conditionalNodeIds.length > 0) {
+                            setOrPushFlowInput(flowInputs, existingIndex, {
+                                name: inputName,
+                                type: inputType,
+                                ref: { conditional: conditionalNodeIds },
+                            });
+                        }
+                    }
+                    else if (inputType === 'file_array' || inputType === 'string_array') {
+                        const transformVariables = [];
+                        const transformInputs = [];
+                        for (const edge of inputEdges) {
+                            const targetNode = filteredNodes.find((n) => n.id === edge.target);
+                            const targetOutputHandle = targetNode?.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+                            const targetOutputHandleName = targetOutputHandle?.name ?? 'output';
+                            let targetNodeKey;
+                            let targetInputType;
+                            if (targetNode?.type === 'forEach' && edge.targetHandle) {
+                                const m = edge.targetHandle.match(/-output-(\d+)$/);
+                                const outputIdx = m ? m[1] ?? '0' : '0';
+                                const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+                                targetNodeKey = getForEachIterationRefName(outHandle, outputIdx);
+                                targetInputType = outHandle?.type === 'text' ? 'string' : 'file';
+                            }
+                            else {
+                                targetNodeKey = getOutputHandleVarName(edge.target, targetOutputHandleName);
+                                targetInputType =
+                                    ((targetNode?.type === 'asset' &&
+                                        !!targetNode.data.isMultiple) ||
+                                        targetNode?.type === 'groupItems' ||
+                                        targetNode?.type === 'sliceAssets' ||
+                                        targetOutputHandleName === 'allOutputs') ?
+                                        'file_array'
+                                        : targetNode?.type === 'llm' && targetOutputHandleName === 'outputs' ? 'string_array'
+                                            : targetNode?.type === 'asset' || targetNode?.type === 'model' ? 'file'
+                                                : 'string';
+                            }
+                            const isArr = targetInputType === 'file_array';
+                            const isRequired = (targetNode?.type === 'asset' &&
+                                !!targetNode.data.isRequired) ||
+                                isModelCompose(model);
+                            transformVariables.push({ name: targetNodeKey, isArray: isArr, isRequired });
+                            if (!targetNode?.data.isInput &&
+                                (targetNode?.type === 'asset' || targetNode?.type === 'text')) {
+                                transformInputs.push({
+                                    name: targetNodeKey,
+                                    type: targetInputType,
+                                    value: getNodeOutputValue(targetNode, edge.targetHandle ?? undefined),
+                                });
+                            }
+                            else {
+                                const ref = getSourceRef(edge, ctx);
+                                if (!ref)
+                                    continue;
+                                transformInputs.push({ name: targetNodeKey, type: targetInputType, ref });
+                            }
+                        }
+                        const hasLoopIterationInputs = transformInputs.some((inp) => /^(image|text)\d+$/.test(inp.name));
+                        if (hasLoopIterationInputs) {
+                            const sortByIdx = (a, b) => parseInt(a.name.replace(/^(image|text)/, ''), 10) -
+                                parseInt(b.name.replace(/^(image|text)/, ''), 10);
+                            transformVariables.sort(sortByIdx);
+                            transformInputs.sort(sortByIdx);
+                        }
+                        const concatItem = {
+                            id: `${flowId}_transform_${inputName}`,
+                            type: 'transform',
+                            logic: { transform: buildConcatArrayTransform(transformVariables) },
+                            inputs: transformInputs,
+                        };
+                        flow.push(concatItem);
+                        setOrPushFlowInput(flowInputs, existingIndex, {
+                            name: inputName,
+                            type: inputType,
+                            ref: { node: concatItem.id, name: 'all' },
+                        });
+                    }
+                    else {
+                        const ref = getSourceRef(inputEdges[0], ctx);
+                        if (!ref)
+                            continue;
+                        setOrPushFlowInput(flowInputs, existingIndex, { name: inputName, type: inputType, ref });
+                    }
+                }
+            }
+            // Conditional control flow connections
+            const conditionalEdges = incomingEdges.filter((e) => e.sourceHandle === conditionalHandleId);
+            if (conditionalEdges.length > 0) {
+                const conditionalRefs = [];
+                for (const edge of conditionalEdges) {
+                    const targetNode = nodes.find((n) => n.id === edge.target);
+                    if (targetNode?.type === 'ifElse') {
+                        const ref = getSourceRef(edge, ctx);
+                        if (ref?.equal)
+                            flowInputs.push({ name: 'connection', type: 'connection', ref });
+                    }
+                    else {
+                        const targetFlowId = nodeIdToFlowIdMap.get(edge.target);
+                        if (targetFlowId)
+                            conditionalRefs.push(targetFlowId);
+                    }
+                }
+                if (conditionalRefs.length > 0) {
+                    flowInputs.push({ name: 'connection', type: 'connection', ref: { conditional: conditionalRefs } });
+                }
+            }
+            flow.push({
+                id: flowId,
+                type: 'custom-model',
+                modelId: nodeData.modelId,
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+                includeOutputsInWorkflowJob: node.type === 'model' && selectedOutputModelNodeIds.has(node.id) ? true : undefined,
+            });
+            ensureInputVideoTransformsAdded();
+            if (node.type === 'model' && node.data.type === 'video') {
+                addVideoFirstLastFrameTransforms(node.id, flowId, node, edges, flow, nodeHandleTransformMap);
+            }
+            else if (node.type === 'model' && node.data.outputHandles?.some((h) => h.name === 'firstOutput')) {
+                if (hasHandleConnection(node, 'firstOutput', edges, node.id)) {
+                    const transformId = `${flowId}_firstOutput`;
+                    flow.push({
+                        id: transformId,
+                        type: 'transform',
+                        logic: { transform: "exists('output') && output.size() > 0 ? output[0] : []" },
+                        inputs: [{ name: 'output', type: 'file_array', ref: { node: flowId, name: 'all' } }],
+                    });
+                    nodeHandleTransformMap.set(`${node.id}_firstOutput`, transformId);
+                }
+            }
+            if (node.type === 'llm' && hasHandleConnection(node, 'outputs', edges, node.id)) {
+                const transformId = `${flowId}_outputs`;
+                flow.push({
+                    id: transformId,
+                    type: 'transform',
+                    logic: { transform: '[output]' },
+                    inputs: [{ name: 'output', type: 'string', ref: { node: flowId, name: 'all' } }],
+                });
+                nodeHandleTransformMap.set(`${node.id}_outputs`, transformId);
+            }
+            // ------------------------------------
+            // Text -> transform with string literal
+            // ------------------------------------
+        }
+        else if (node.type === 'text') {
+            const flowInputs = collectConditionalConnectionInputs(incomingEdges, node.id, ctx);
+            const value = node.data.value || '';
+            flow.push({
+                id: flowId,
+                type: 'transform',
+                logic: { transform: `'${escapeCELString(value)}'` },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+            // ------------------------------------
+            // Asset -> transform with file reference
+            // ------------------------------------
+        }
+        else if (node.type === 'asset') {
+            const flowInputs = collectConditionalConnectionInputs(incomingEdges, node.id, ctx);
+            const d = node.data;
+            const value = d.value;
+            if (!value || (Array.isArray(value) && value.length === 0))
+                continue;
+            flow.push({
+                id: flowId,
+                type: 'transform',
+                logic: {
+                    transform: Array.isArray(value) ? `['${value.join("'] + ['")}']` : `'${value}'`,
+                },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+            if (d.type === 'video') {
+                addVideoFirstLastFrameTransforms(node.id, flowId, node, edges, flow, nodeHandleTransformMap);
+            }
+            // ------------------------------------
+            // TransformText -> transform (CEL)
+            // ------------------------------------
+        }
+        else if (node.type === 'transformText') {
+            const flowInputs = [];
+            const conditionalHandleId = getConditionalInputHandleId(node.id);
+            const value = node.data.value || "''";
+            for (const edge of incomingEdges) {
+                if (edge.sourceHandle === conditionalHandleId)
+                    continue;
+                const targetNode = nodes.find((n) => n.id === edge.target);
+                if (!targetNode)
+                    continue;
+                const ref = getSourceRef(edge, ctx);
+                if (!ref)
+                    continue;
+                const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+                const outHandleName = outHandle?.name ?? 'output';
+                const targetFlowId = nodeIdToFlowIdMap.get(targetNode.id) ?? targetNode.id;
+                flowInputs.push({ name: `${targetFlowId}_${outHandleName}`, type: 'string', ref });
+            }
+            flowInputs.push(...collectConditionalConnectionInputs(incomingEdges, node.id, ctx));
+            flow.push({
+                id: flowId,
+                type: 'transform',
+                logic: { transform: value },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+            // ------------------------------------
+            // SplitText -> split string into list
+            // ------------------------------------
+        }
+        else if (node.type === 'splitText') {
+            const flowInputs = [];
+            const conditionalHandleId = getConditionalInputHandleId(node.id);
+            let textSourceVarName;
+            for (const edge of incomingEdges) {
+                if (edge.sourceHandle === conditionalHandleId)
+                    continue;
+                const targetNode = nodes.find((n) => n.id === edge.target);
+                if (!targetNode)
+                    continue;
+                const ref = getSourceRef(edge, ctx);
+                if (!ref)
+                    continue;
+                flowInputs.push({ name: targetNode.id, type: 'string', ref });
+                textSourceVarName = targetNode.id;
+            }
+            flowInputs.push(...collectConditionalConnectionInputs(incomingEdges, node.id, ctx));
+            const delimRaw = node.data.splitDelimiter ?? ',';
+            const delim = delimRaw.length > 0 ? delimRaw : ',';
+            flow.push({
+                id: flowId,
+                type: 'transform',
+                logic: {
+                    transform: textSourceVarName ? `trim(${textSourceVarName}).split(${formatTextAsCELString(delim)})` : '[]',
+                },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+            // ------------------------------------
+            // GroupItems -> array concatenation
+            // ------------------------------------
+        }
+        else if (node.type === 'groupItems') {
+            const flowInputs = [];
+            const variables = [];
+            const conditionalHandleId = getConditionalInputHandleId(node.id);
+            for (const edge of incomingEdges) {
+                if (edge.sourceHandle === conditionalHandleId)
+                    continue;
+                const targetNode = nodes.find((n) => n.id === edge.target);
+                if (!targetNode)
+                    continue;
+                const ref = getSourceRef(edge, ctx);
+                if (!ref)
+                    continue;
+                const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+                const outHandleName = outHandle?.name ?? 'output';
+                const varName = getOutputHandleVarName(targetNode.id, outHandleName);
+                const isArr = (targetNode.type === 'asset' && !!targetNode.data.isMultiple) ||
+                    targetNode.type === 'groupItems' ||
+                    targetNode.type === 'sliceAssets' ||
+                    outHandleName === 'allOutputs';
+                const isRequired = inputNodeIds.includes(targetNode.id) ?
+                    (targetNode.type === 'asset' && !!targetNode.data.isRequired) ||
+                        ['firstFrame', 'lastFrame'].includes(outHandleName)
+                    : true;
+                variables.push({ name: varName, isArray: isArr, isRequired });
+                flowInputs.push({ name: varName, type: isArr ? 'file_array' : 'file', ref });
+            }
+            const orderedValues = convertValueToList(node.data.value ?? '');
+            variables.sort((a, b) => orderedValues.indexOf(a.name) - orderedValues.indexOf(b.name));
+            flowInputs.sort((a, b) => orderedValues.indexOf(a.name) - orderedValues.indexOf(b.name));
+            flowInputs.push(...collectConditionalConnectionInputs(incomingEdges, node.id, ctx));
+            flow.push({
+                id: flowId,
+                type: 'transform',
+                logic: { transform: buildConcatArrayTransform(variables) },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+            // ------------------------------------
+            // SliceAssets -> slice(list, from, from+count)
+            // ------------------------------------
+        }
+        else if (node.type === 'sliceAssets') {
+            const assetsEdge = incomingEdges.find((e) => e.sourceHandle === `${node.id}-source-assets`);
+            if (!assetsEdge) {
+                flow.push({ id: flowId, type: 'transform', logic: { transform: '[]' } });
+            }
+            else {
+                const targetNode = nodes.find((n) => n.id === assetsEdge.target);
+                if (targetNode) {
+                    const ref = getSourceRef(assetsEdge, ctx);
+                    if (ref) {
+                        const outHandle = targetNode.data.outputHandles?.find((h) => h.id === assetsEdge.targetHandle);
+                        const varName = getOutputHandleVarName(targetNode.id, outHandle?.name ?? 'output');
+                        const sliceData = node.data;
+                        const from = parseInt(String(sliceData.from ?? ''), 10) || 0;
+                        const count = parseInt(String(sliceData.count ?? ''), 10) || 0;
+                        const transform = from < 0 ?
+                            `slice(${varName}, (${varName}).size() + ${from}, (${varName}).size() + ${from + count})`
+                            : `slice(${varName}, ${from}, ${from + count})`;
+                        const flowInputs = [
+                            { name: varName, type: 'file_array', ref },
+                            ...collectConditionalConnectionInputs(incomingEdges, node.id, ctx),
+                        ];
+                        flow.push({
+                            id: flowId,
+                            type: 'transform',
+                            logic: { transform },
+                            inputs: flowInputs.length > 0 ? flowInputs : undefined,
+                        });
+                    }
+                }
+            }
+            // ------------------------------------
+            // ForEach -> for-each loop
+            // ------------------------------------
+        }
+        else if (node.type === 'forEach') {
+            const flowInputs = [];
+            const conditionalHandleId = getConditionalInputHandleId(node.id);
+            for (const edge of incomingEdges) {
+                if (edge.sourceHandle === conditionalHandleId)
+                    continue;
+                const inputMatch = edge.sourceHandle?.match(/-input-(\d+)$/);
+                if (!inputMatch)
+                    continue;
+                const inputIndex = parseInt(inputMatch[1], 10);
+                const listProvider = nodes.find((n) => n.id === edge.target);
+                const listOutputHandle = listProvider?.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+                const { name: inputName, type: inputApiType } = getForEachFlowListInputDescriptor({
+                    listProvider,
+                    outputHandle: listOutputHandle,
+                    inputIndex,
+                });
+                if (flowInputs.find((inp) => inp.name === inputName))
+                    continue;
+                const ref = getSourceRef(edge, ctx);
+                if (!ref)
+                    continue;
+                flowInputs.push({ name: inputName, type: inputApiType, ref });
+            }
+            flowInputs.sort((a, b) => parseInt(a.name.replace(/^(image|text)/, ''), 10) -
+                parseInt(b.name.replace(/^(image|text)/, ''), 10));
+            const forEachFlowItem = {
+                id: flowId,
+                type: 'for-each',
+                loopBodyNodeIds: [],
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            };
+            flow.push(forEachFlowItem);
+            forEachFlowItemRefs.set(node.id, forEachFlowItem);
+            // ------------------------------------
+            // IfElse -> logic if-else
+            // ------------------------------------
+        }
+        else if (node.type === 'ifElse') {
+            const flowInputs = [];
+            const conditionBlocks = node.data.conditionBlocks ?? [];
+            const fieldsUsed = new Set();
+            for (const block of conditionBlocks) {
+                for (const condition of block.conditions) {
+                    if (condition.field)
+                        fieldsUsed.add(condition.field);
+                }
+            }
+            for (const fieldNodeId of fieldsUsed) {
+                if (inputNodeIds.includes(fieldNodeId)) {
+                    const inputName = nodeIdToInputNameMap.get(fieldNodeId);
+                    if (inputName)
+                        flowInputs.push({ name: inputName, type: 'string', ref: { node: 'workflow', name: inputName } });
+                }
+                else {
+                    const targetFlowId = nodeIdToFlowIdMap.get(fieldNodeId);
+                    if (targetFlowId) {
+                        flowInputs.push({ name: targetFlowId, type: 'string', ref: { node: targetFlowId, name: 'all' } });
+                        nodeIdToInputNameMap.set(fieldNodeId, targetFlowId);
+                    }
+                }
+            }
+            const cases = [];
+            for (let i = 0; i < conditionBlocks.length; i++) {
+                const condition = conditionBlockToCEL(conditionBlocks[i], nodeIdToInputNameMap);
+                if (condition)
+                    cases.push({ condition, value: String(i + 2) });
+            }
+            flow.push({
+                id: flowId,
+                type: 'logic',
+                logicType: 'if-else',
+                logic: { cases: cases.length > 0 ? cases : undefined, default: '1' },
+                inputs: flowInputs.length > 0 ? flowInputs : undefined,
+            });
+        }
+        // Track which flow items belong to each forEach body
+        for (const [forEachId, bodyNodeIds] of forEachBodyEditorNodeIds) {
+            if (bodyNodeIds.has(node.id)) {
+                const loopFlowIds = forEachLoopFlowIds.get(forEachId);
+                if (loopFlowIds) {
+                    for (let i = flowLengthBefore; i < flow.length; i++) {
+                        loopFlowIds.push(flow[i].id);
+                    }
+                }
+            }
+        }
+    }
+    // Populate loopBodyNodeIds on each forEach flow item
+    for (const [forEachId, forEachFlowItem] of forEachFlowItemRefs) {
+        forEachFlowItem.loopBodyNodeIds = forEachLoopFlowIds.get(forEachId) ?? [];
+    }
+    return flow;
+}
+//# sourceMappingURL=workflow_converter.js.map