@scenario-labs/sdk 1.2.0 → 2.1.0

package/src/lib/workflow_converter.ts

@@ -0,0 +1,1402 @@
+// 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.
+
+// ---- Public types ----
+
+export type WorkflowEditorHandleInput = {
+  id: string;
+  label?: string;
+  name?: string;
+  type?: string | string[];
+  subHandles?: WorkflowEditorHandleInput[];
+};
+
+export type WorkflowEditorHandleOutput = {
+  id: string;
+  name?: string;
+  type?: string;
+  isArray?: boolean;
+};
+
+type NodeCommonData = {
+  isInput?: boolean;
+  isOutput?: boolean;
+  inputHandles?: WorkflowEditorHandleInput[];
+  outputHandles?: WorkflowEditorHandleOutput[];
+};
+
+export type WorkflowEditorNode =
+  | {
+      id: string;
+      type: 'model';
+      data: NodeCommonData & { modelId?: string; type?: string; form?: Record<string, unknown> };
+    }
+  | { id: string; type: 'llm'; data: NodeCommonData & { modelId?: string; form?: Record<string, unknown> } }
+  | { id: string; type: 'text'; data: NodeCommonData & { value?: string } }
+  | {
+      id: string;
+      type: 'asset';
+      data: NodeCommonData & {
+        type?: string;
+        value?: string | string[];
+        isMultiple?: boolean;
+        isRequired?: boolean;
+        valueFirstFrame?: string;
+        valueLastFrame?: string;
+      };
+    }
+  | { id: string; type: 'transformText'; data: NodeCommonData & { value?: string } }
+  | { id: string; type: 'splitText'; data: NodeCommonData & { splitDelimiter?: string } }
+  | { id: string; type: 'groupItems'; data: NodeCommonData & { value?: string } }
+  | {
+      id: string;
+      type: 'sliceAssets';
+      data: NodeCommonData & { from?: number | string; count?: number | string };
+    }
+  | { id: string; type: 'forEach'; data: NodeCommonData }
+  | { id: string; type: 'forEachEnd'; data: NodeCommonData & { parentNodeId?: string } }
+  | {
+      id: string;
+      type: 'ifElse';
+      data: NodeCommonData & { conditionBlocks?: WorkflowEditorConditionBlock[] };
+    }
+  | { id: string; type: 'approval'; data: NodeCommonData & { message?: string } }
+  | { id: string; type: string; data: NodeCommonData };
+
+export type WorkflowEditorEdge = {
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+  data?: { isForEachEndEdge?: boolean } | undefined;
+};
+
+export type WorkflowEditorCondition = {
+  field: string | undefined;
+  operator: string;
+  value?: string | string[];
+};
+
+export type WorkflowEditorConditionBlock = {
+  conditions: WorkflowEditorCondition[];
+  logic: 'and' | 'or';
+};
+
+export type WorkflowEditorModelInput = {
+  name: string;
+  type: string;
+  inputs?: Array<{ name: string; type: string }>;
+};
+
+export type WorkflowEditorModel = {
+  id?: string;
+  inputs?: WorkflowEditorModelInput[];
+  tags?: string[];
+};
+
+export type WorkflowEditorFlowInputRef = {
+  equal?: string | undefined;
+  node?: string | undefined;
+  conditional?: string[] | undefined;
+  name?: string | undefined;
+};
+
+export type WorkflowEditorFlowInput = {
+  name: string;
+  type: string;
+  ref?: WorkflowEditorFlowInputRef | undefined;
+  value?: string | number | string[] | boolean | undefined;
+  items?: WorkflowEditorFlowInput[][] | undefined;
+};
+
+export type WorkflowEditorFlowItem = {
+  id: string;
+  type: string;
+  modelId?: string | undefined;
+  inputs?: WorkflowEditorFlowInput[] | undefined;
+  logic?:
+    | {
+        transform?: string | undefined;
+        cases?: { condition: string; value: string }[] | undefined;
+        default?: string | undefined;
+      }
+    | undefined;
+  logicType?: 'if-else' | undefined;
+  loopBodyNodeIds?: string[] | undefined;
+  includeOutputsInWorkflowJob?: true | undefined;
+  dependsOn?: string[] | undefined;
+  label?: string | undefined;
+};
+
+// ---- Internal types ----
+
+type ConcatVariable = { name: string; isArray: boolean; isRequired: boolean };
+
+type SourceRefContext = {
+  nodes: WorkflowEditorNode[];
+  inputNodeIds: string[];
+  nodeIdToInputNameMap: Map<string, string>;
+  nodeIdToFlowIdMap: Map<string, string>;
+  nodeHandleTransformMap?: Map<string, string>;
+};
+
+// ---- Utility functions ----
+
+function nodeIdToFlowId(nodeId: string): string {
+  return nodeId.replace(/\s/g, '');
+}
+
+function escapeCELString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n');
+}
+
+function formatTextAsCELString(text: string): string {
+  return `'${text.replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`;
+}
+
+function buildConcatArrayTransform(variables: ConcatVariable[]): string {
+  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: string): string[] {
+  return value
+    .replace(/\[|\]/g, '')
+    .split('+')
+    .map((v) => v.trim())
+    .filter(Boolean);
+}
+
+function getConditionalInputHandleId(nodeId: string): string {
+  return `${nodeId}-source-conditional`;
+}
+
+function getForEachFlowListInputDescriptor(args: {
+  listProvider: WorkflowEditorNode | undefined;
+  outputHandle: WorkflowEditorHandleOutput | undefined;
+  inputIndex: number;
+}): { name: string; type: 'file_array' | 'string_array' } {
+  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: WorkflowEditorHandleOutput | undefined,
+  outputIndex: string,
+): string {
+  return outputHandle?.type === 'text' ? `text${outputIndex}` : `image${outputIndex}`;
+}
+
+function getHasComposeLayerSourceInput(layerInputs: { name: string }[]): boolean {
+  return layerInputs.some((inp) => inp.name === 'source');
+}
+
+function conditionToCelExpression(condition: WorkflowEditorCondition): string {
+  if (!condition.field) return 'false';
+  const { field, operator, value } = condition;
+
+  function escStr(s: string) {
+    return `'${s.replace(/'/g, "''")}'`;
+  }
+  function escRx(s: string) {
+    return s.replace(/[.+*?[\]()^$|\\]/g, '\\$&');
+  }
+  function fmtVal(v: string | string[] | undefined): string {
+    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: WorkflowEditorConditionBlock,
+  nodeIdToInputName: Map<string, string>,
+): string {
+  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: WorkflowEditorEdge,
+  ctx: SourceRefContext,
+): WorkflowEditorFlowInputRef | undefined {
+  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 as { parentNodeId?: string }).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 as { conditionBlocks?: WorkflowEditorConditionBlock[] }).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: WorkflowEditorEdge,
+  inputHandles: WorkflowEditorHandleInput[] | undefined,
+): WorkflowEditorHandleInput | undefined {
+  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: WorkflowEditorNode,
+  handleName: string,
+  edges: WorkflowEditorEdge[],
+  nodeId: string,
+): boolean {
+  return edges
+    .filter((e) => e.target === nodeId)
+    .some(
+      (e) => (node.data.outputHandles?.find((h) => h.id === e.targetHandle)?.name ?? 'output') === handleName,
+    );
+}
+
+function getOutputHandleVarName(targetNodeId: string, handleName: string): string {
+  return ['output', 'allOutputs'].includes(handleName) ? targetNodeId : `${targetNodeId}_${handleName}`;
+}
+
+function setOrPushFlowInput(
+  flowInputs: WorkflowEditorFlowInput[],
+  existingIndex: number,
+  input: WorkflowEditorFlowInput,
+): void {
+  if (existingIndex !== -1) {
+    flowInputs[existingIndex] = input;
+  } else {
+    flowInputs.push(input);
+  }
+}
+
+function addVideoFirstLastFrameTransforms(
+  nodeId: string,
+  flowId: string,
+  node: WorkflowEditorNode,
+  edges: WorkflowEditorEdge[],
+  flow: WorkflowEditorFlowItem[],
+  nodeHandleTransformMap: Map<string, string>,
+  options?: { inputName?: string; onlyHandle?: 'firstFrame' | 'lastFrame' },
+): void {
+  const handles: ('firstFrame' | 'lastFrame')[] =
+    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' as const, name: options.inputName }
+      : { node: flowId, name: 'all' as const };
+    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: WorkflowEditorEdge[],
+  nodeId: string,
+  ctx: SourceRefContext,
+): WorkflowEditorFlowInput[] {
+  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: string, type: string, value: unknown): WorkflowEditorFlowInput | undefined {
+  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 as unknown[]).every((v) => typeof v === 'string');
+  if (!isNum && !isStr && !isBool && !isStrArr) return undefined;
+  if (isStrArr && (value as string[]).length === 0) return undefined;
+  return { name, type, value: value as string | number | string[] | boolean };
+}
+
+function isFormArray(value: unknown): value is Record<string, unknown>[] {
+  return (
+    Array.isArray(value) &&
+    (value as unknown[]).every((item) => typeof item === 'object' && item !== null && !Array.isArray(item))
+  );
+}
+
+function isModelCompose(model: WorkflowEditorModel | undefined): boolean {
+  return !!model?.id && (model.tags ?? []).includes('compose');
+}
+
+function getIsConditionallyExecuted(
+  targetNodeId: string,
+  nodes: WorkflowEditorNode[],
+  edges: WorkflowEditorEdge[],
+): boolean {
+  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: string,
+  forEachEndId: string,
+  edges: WorkflowEditorEdge[],
+): Set<string> {
+  const bodyNodeIds = new Set<string>();
+  const queue: string[] = [];
+  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: WorkflowEditorNode[], inputKeys: string[]): WorkflowEditorNode[] {
+  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: WorkflowEditorNode,
+  targetHandleId?: string,
+): string | string[] | undefined {
+  if (node.type === 'text') return (node.data as { value?: string }).value || '';
+  if (node.type === 'asset') {
+    const d = node.data as {
+      value?: string | string[];
+      valueFirstFrame?: string;
+      valueLastFrame?: string;
+      outputHandles?: WorkflowEditorHandleOutput[];
+    };
+    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: WorkflowEditorNode[],
+  edges: WorkflowEditorEdge[],
+  startNodeId: string,
+  direction: 'input' | 'output',
+  isStoppingAtRunnableNodes: boolean,
+): WorkflowEditorNode[] {
+  type NodeMeta = { id: string; type: string; parentNodeId?: string };
+  const nodesById = new Map<string, NodeMeta>(
+    nodes.map((n) => {
+      const meta: NodeMeta = { id: n.id, type: n.type };
+      if (n.type === 'forEachEnd') {
+        const parentId = (n.data as { parentNodeId?: string }).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: { source: string; target: string }): boolean {
+    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: string, visited: Set<string>): string[] {
+    if (visited.has(nodeId)) return [];
+    visited.add(nodeId);
+    const result: string[] = [];
+    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 resolveIfElseConditionField(
+  field: string,
+  candidateNodes: WorkflowEditorNode[],
+): { nodeId: string; targetHandleId?: string } | undefined {
+  const byExactId = candidateNodes.find((n) => n.id === field);
+  if (byExactId) return { nodeId: field };
+  for (const node of candidateNodes) {
+    for (const handle of node.data.outputHandles ?? []) {
+      if (`${node.id}_${handle.name}` === field) {
+        return { nodeId: node.id, targetHandleId: handle.id };
+      }
+    }
+  }
+  return undefined;
+}
+
+function normalizeNodes(nodes: WorkflowEditorNode[]): WorkflowEditorNode[] {
+  return nodes.map((node) => {
+    if (node.type !== 'model' && node.type !== 'llm') return node;
+    const hasType = (t: string | string[] | undefined, v: string) =>
+      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 } } as WorkflowEditorNode;
+  });
+}
+
+// ---- 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[] });
+ * ```
+ */
+export function convertWorkflowEditorToFlow(params: {
+  nodes: WorkflowEditorNode[];
+  edges: WorkflowEditorEdge[];
+  inputKeys: string[];
+  /** Optional model resolver — return the model object, 'unknown', or undefined. */
+  getModel?: (modelId: string) => WorkflowEditorModel | 'unknown' | undefined;
+}): WorkflowEditorFlowItem[] {
+  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 is WorkflowEditorNode & { type: 'model' } => n.type === 'model')
+      .map((n) => n.id),
+  );
+
+  // Collect all nodes in branches that lead to selected outputs
+  const nodesInSelectedBranches = new Set<string>();
+  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<string, string>(
+    sortedNodes
+      .filter((n) => !inputNodeIds.includes(n.id) && n.type !== 'forEachEnd')
+      .map((n) => [n.id, nodeIdToFlowId(n.id)]),
+  );
+  const nodeIdToInputNameMap = new Map<string, string>(inputNodeIds.map((id) => [id, nodeIdToFlowId(id)]));
+  const approvalByApprovedNodeId = buildApprovalByApprovedNodeIdMap({
+    nodes,
+    edges,
+    nodesInSelectedBranches,
+    selectedOutputNodeIds,
+  });
+  const nodeHandleTransformMap = new Map<string, string>();
+
+  const ctx: SourceRefContext = {
+    nodes,
+    inputNodeIds,
+    nodeIdToInputNameMap,
+    nodeIdToFlowIdMap,
+    nodeHandleTransformMap,
+  };
+
+  const flow: WorkflowEditorFlowItem[] = [];
+  const forEachBodyEditorNodeIds = new Map<string, Set<string>>();
+  const forEachLoopFlowIds = new Map<string, string[]>();
+  const forEachFlowItemRefs = new Map<string, WorkflowEditorFlowItem>();
+
+  for (const node of sortedNodes) {
+    if (node.type !== 'forEach') continue;
+    const endNode = nodes.find(
+      (n) => n.type === 'forEachEnd' && (n.data as { parentNodeId?: string }).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<string>();
+  for (const inputNodeId of inputNodeIds) {
+    const inputNode = nodes.find((n) => n.id === inputNodeId);
+    if (!inputNode || inputNode.type !== 'asset' || (inputNode.data as { type?: string }).type !== 'video')
+      continue;
+    for (const handleName of ['firstFrame', 'lastFrame'] as const) {
+      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 as { type?: string }).type !== 'video')
+        continue;
+      const inputName = nodeIdToInputNameMap.get(inputNodeId);
+      if (!inputName) continue;
+      for (const handleName of ['firstFrame', 'lastFrame'] as const) {
+        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 as NodeCommonData & { modelId?: string; form?: Record<string, unknown> };
+      const flowInputs: WorkflowEditorFlowInput[] = [];
+      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<string, WorkflowEditorEdge[]>();
+      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: WorkflowEditorFlowInput[][] = [];
+
+            for (const [index, form] of (value as Record<string, unknown>[]).entries()) {
+              const itemInputs: WorkflowEditorFlowInput[] = [];
+              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 is string => 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: ConcatVariable[] = [];
+            const transformInputs: WorkflowEditorFlowInput[] = [];
+
+            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: string;
+              let targetInputType: string;
+
+              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 as { isMultiple?: boolean }).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 as { isRequired?: boolean }).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) as
+                    | string
+                    | string[]
+                    | 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: { name: string }, b: { name: string }) =>
+                parseInt(a.name.replace(/^(image|text)/, ''), 10) -
+                parseInt(b.name.replace(/^(image|text)/, ''), 10);
+              transformVariables.sort(sortByIdx);
+              transformInputs.sort(sortByIdx);
+            }
+
+            const concatItem: WorkflowEditorFlowItem = {
+              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: string[] = [];
+        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 as { type?: string }).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 as { value?: string }).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 as { value?: string | string[]; type?: string };
+      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 as string[]).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: WorkflowEditorFlowInput[] = [];
+      const conditionalHandleId = getConditionalInputHandleId(node.id);
+      const value = (node.data as { value?: string }).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: WorkflowEditorFlowInput[] = [];
+      const conditionalHandleId = getConditionalInputHandleId(node.id);
+      let textSourceVarName: string | undefined;
+
+      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 as { splitDelimiter?: string }).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: WorkflowEditorFlowInput[] = [];
+      const variables: ConcatVariable[] = [];
+      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 = `${targetNode.id}_${outHandleName}`;
+        const isArr =
+          (targetNode.type === 'asset' && !!(targetNode.data as { isMultiple?: boolean }).isMultiple) ||
+          targetNode.type === 'groupItems' ||
+          targetNode.type === 'sliceAssets' ||
+          outHandleName === 'allOutputs';
+        const isRequired =
+          inputNodeIds.includes(targetNode.id) ?
+            (targetNode.type === 'asset' && !!(targetNode.data as { isRequired?: boolean }).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 as { value?: string }).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 as { from?: number | string; count?: number | string };
+            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: WorkflowEditorFlowInput[] = [
+              { 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: WorkflowEditorFlowInput[] = [];
+      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: WorkflowEditorFlowItem = {
+        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: WorkflowEditorFlowInput[] = [];
+      const conditionBlocks =
+        (node.data as { conditionBlocks?: WorkflowEditorConditionBlock[] }).conditionBlocks ?? [];
+
+      const fieldsUsed = new Set<string>();
+      for (const block of conditionBlocks) {
+        for (const condition of block.conditions) {
+          if (condition.field) fieldsUsed.add(condition.field);
+        }
+      }
+
+      const edgesIntoIfElse = edges.filter((e) => e.target === node.id);
+      for (const fieldKey of fieldsUsed) {
+        const resolved = resolveIfElseConditionField(fieldKey, nodes);
+        const fieldNodeId = resolved?.nodeId;
+        if (!fieldNodeId) continue;
+
+        const outputHandleName =
+          resolved?.targetHandleId !== undefined ?
+            nodes
+              .find((n) => n.id === fieldNodeId)
+              ?.data.outputHandles?.find((h) => h.id === resolved.targetHandleId)?.name ?? 'output'
+          : 'output';
+
+        const celVarName = getOutputHandleVarName(fieldNodeId, outputHandleName);
+        nodeIdToInputNameMap.set(fieldKey, celVarName);
+
+        const edgeToIfElse =
+          edgesIntoIfElse
+            .filter((e) => e.source === fieldNodeId)
+            .find((e) => {
+              if (resolved.targetHandleId === undefined) return true;
+              return e.sourceHandle === resolved.targetHandleId;
+            }) ?? edgesIntoIfElse.find((e) => e.source === fieldNodeId);
+
+        if (inputNodeIds.includes(fieldNodeId)) {
+          const workflowInputName = nodeIdToInputNameMap.get(fieldNodeId);
+          if (workflowInputName) {
+            const ref =
+              edgeToIfElse ?
+                getSourceRef(edgeToIfElse, ctx)
+              : { node: 'workflow' as const, name: workflowInputName };
+            flowInputs.push({
+              name: celVarName,
+              type: 'string',
+              ref: ref ?? { node: 'workflow', name: workflowInputName },
+            });
+          }
+        } else {
+          const refFromEdge = edgeToIfElse ? getSourceRef(edgeToIfElse, ctx) : undefined;
+          const targetFlowId = nodeIdToFlowIdMap.get(fieldNodeId);
+          if (refFromEdge) {
+            flowInputs.push({ name: celVarName, type: 'string', ref: refFromEdge });
+          } else if (targetFlowId) {
+            flowInputs.push({ name: celVarName, type: 'string', ref: { node: targetFlowId, name: 'all' } });
+          }
+        }
+      }
+
+      const cases: { condition: string; value: string }[] = [];
+      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) ?? [];
+  }
+
+  applyApprovalsToFlow({ flow, edges, approvalByApprovedNodeId, nodeIdToFlowIdMap });
+
+  return flow;
+}
+
+// ---- Approval helpers ----
+
+interface ApprovalInfo {
+  approvalFlowId: string;
+  approvedFlowId: string;
+  message: string;
+}
+
+function buildApprovalByApprovedNodeIdMap({
+  nodes,
+  edges,
+  nodesInSelectedBranches,
+  selectedOutputNodeIds,
+}: {
+  nodes: WorkflowEditorNode[];
+  edges: WorkflowEditorEdge[];
+  nodesInSelectedBranches: Set<string>;
+  selectedOutputNodeIds: string[];
+}): Map<string, ApprovalInfo> {
+  const result = new Map<string, ApprovalInfo>();
+  for (const approvalNode of nodes) {
+    if (approvalNode.type !== 'approval') continue;
+    const approvalEdge = edges.find(
+      (e) => e.source === approvalNode.id && e.sourceHandle === `${approvalNode.id}-source-approval`,
+    );
+    if (!approvalEdge) continue;
+    const approvedNodeId = approvalEdge.target;
+    if (!nodesInSelectedBranches.has(approvedNodeId) && !selectedOutputNodeIds.includes(approvedNodeId))
+      continue;
+    const approvedNode = nodes.find((n) => n.id === approvedNodeId);
+    if (!approvedNode) continue;
+    const approvedFlowId =
+      approvedNode.type === 'forEachEnd' ?
+        (approvedNode.data as { parentNodeId?: string }).parentNodeId ?
+          nodeIdToFlowId((approvedNode.data as { parentNodeId?: string }).parentNodeId!)
+        : undefined
+      : nodeIdToFlowId(approvedNodeId);
+    if (!approvedFlowId) continue;
+    result.set(approvedNodeId, {
+      approvalFlowId: nodeIdToFlowId(approvalNode.id),
+      approvedFlowId,
+      message: (approvalNode.data as { message?: string }).message ?? '',
+    });
+  }
+  return result;
+}
+
+function applyApprovalsToFlow({
+  flow,
+  edges,
+  approvalByApprovedNodeId,
+  nodeIdToFlowIdMap,
+}: {
+  flow: WorkflowEditorFlowItem[];
+  edges: WorkflowEditorEdge[];
+  approvalByApprovedNodeId: Map<string, ApprovalInfo>;
+  nodeIdToFlowIdMap: Map<string, string>;
+}): void {
+  if (approvalByApprovedNodeId.size === 0) return;
+
+  const flowIdToWorkflowNodeId = new Map<string, string>(
+    [...nodeIdToFlowIdMap.entries()].map(([nodeId, flowId]) => [flowId, nodeId]),
+  );
+
+  for (const flowItem of flow) {
+    const workflowNodeId = flowIdToWorkflowNodeId.get(flowItem.id);
+    if (!workflowNodeId) continue;
+    const dependsOn = new Set(flowItem.dependsOn ?? []);
+    const incomingEdges = edges.filter(
+      (e) =>
+        e.source === workflowNodeId &&
+        !(e.data as { isForEachEndEdge?: boolean } | undefined)?.isForEachEndEdge,
+    );
+    for (const edge of incomingEdges) {
+      const approval = approvalByApprovedNodeId.get(edge.target);
+      if (approval) dependsOn.add(approval.approvalFlowId);
+    }
+    if (dependsOn.size > 0) flowItem.dependsOn = [...dependsOn].sort();
+  }
+
+  for (const approvalInfo of approvalByApprovedNodeId.values()) {
+    flow.push({
+      id: approvalInfo.approvalFlowId,
+      type: 'user-approval',
+      dependsOn: [approvalInfo.approvedFlowId],
+      label: approvalInfo.message,
+    });
+  }
+}