@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-5Y3AIUWY.js

@@ -0,0 +1,911 @@
+import {
+  buildControlFlowGraph,
+  findAllBranchingNodes,
+  findNodesInBranch,
+  performKahnsTopologicalSort
+} from "./chunk-4EUSHAY6.js";
+import {
+  COERCE_EXPRESSIONS,
+  COERCE_TYPE_MAP,
+  findExpressionReferences,
+  rewriteExpressionReferences
+} from "./chunk-4KDUEOFD.js";
+import {
+  mapToTypeScript
+} from "./chunk-E5WN7IGO.js";
+import {
+  RESERVED_PORT_NAMES,
+  isExecutePort,
+  isExitNode,
+  isFailurePort,
+  isStartNode,
+  isSuccessPort
+} from "./chunk-R4QGNK34.js";
+
+// src/generator/code-utils.ts
+function getCoercionWrapper(connection, sourceDataType, targetDataType) {
+  if (connection.coerce) {
+    return COERCE_EXPRESSIONS[COERCE_TYPE_MAP[connection.coerce]];
+  }
+  if (!sourceDataType || !targetDataType || sourceDataType === targetDataType) return null;
+  if (sourceDataType === "STEP" || targetDataType === "STEP") return null;
+  if (sourceDataType === "ANY" || targetDataType === "ANY") return null;
+  if (targetDataType === "STRING" && sourceDataType !== "STRING") {
+    return "String";
+  }
+  if (sourceDataType === "BOOLEAN" && targetDataType === "NUMBER") {
+    return "Number";
+  }
+  return null;
+}
+function toValidIdentifier(nodeId) {
+  let sanitized = nodeId.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized;
+}
+function nodeResultVar(safeNodeName, functionName) {
+  const candidate = `${safeNodeName}Result`;
+  return candidate === functionName ? `${candidate}_` : candidate;
+}
+function buildMergeExpression(sources, strategy) {
+  switch (strategy) {
+    case "FIRST":
+      return `[${sources.join(", ")}].find(v => v !== undefined)`;
+    case "LAST":
+      return `[${sources.join(", ")}].filter(v => v !== undefined).pop()`;
+    case "COLLECT":
+      return `[${sources.join(", ")}]`;
+    case "MERGE":
+      return `Object.assign({}, ${sources.join(", ")})`;
+    case "CONCAT":
+      return `[${sources.join(", ")}].flat()`;
+    default:
+      return sources[0] ?? "undefined";
+  }
+}
+
+// src/generator/connection-reads.ts
+var RESOLVE_FUNCTION_FALLBACK = `const __resolveFunction = typeof resolveFunction === 'function' ? resolveFunction : (p: unknown) => ({ fn: typeof p === 'function' ? p : () => { throw new Error('Cannot resolve function reference'); }, source: 'direct' as const });`;
+var PRIMITIVE_TYPE = /^(string|number|boolean|void|unknown|any|never|null|undefined)(\[\])?$/;
+function argumentPortType(node, portConfig, paramIndex) {
+  const rawPortType = mapToTypeScript(portConfig.dataType, portConfig.tsType);
+  return PRIMITIVE_TYPE.test(rawPortType) ? rawPortType : `Parameters<typeof ${node.functionName}>[${paramIndex}]`;
+}
+function resolveSourcePortDataType(workflow, sourceNodeId, sourcePort) {
+  if (isStartNode(sourceNodeId)) {
+    return workflow.startPorts?.[sourcePort]?.dataType;
+  }
+  if (isExitNode(sourceNodeId)) {
+    return workflow.exitPorts?.[sourcePort]?.dataType;
+  }
+  const instance = workflow.instances.find((i) => i.id === sourceNodeId);
+  if (!instance) return void 0;
+  const nodeType = workflow.nodeTypes.find(
+    (nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType
+  );
+  if (!nodeType) return void 0;
+  return nodeType.outputs?.[sourcePort]?.dataType;
+}
+function resolveReferencedPortType(workflow, sourceNodeId, sourcePort) {
+  const dataType = resolveSourcePortDataType(workflow, sourceNodeId, sourcePort);
+  if (!dataType) return "any";
+  if (isStartNode(sourceNodeId)) {
+    return mapToTypeScript(dataType, workflow.startPorts?.[sourcePort]?.tsType);
+  }
+  const instance = workflow.instances.find((i) => i.id === sourceNodeId);
+  const nodeType = instance ? workflow.nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType) : void 0;
+  const tsType = nodeType?.outputs?.[sourcePort]?.tsType;
+  const rawPortType = mapToTypeScript(dataType, tsType);
+  const isPrimitive = PRIMITIVE_TYPE.test(rawPortType);
+  if (isPrimitive || !nodeType) return rawPortType;
+  return `Awaited<ReturnType<typeof ${nodeType.functionName}>>['${sourcePort}']`;
+}
+function isPullExecutionSource(workflow, sourceNodeId) {
+  const instance = workflow.instances.find((candidate) => candidate.id === sourceNodeId);
+  if (!instance) return false;
+  const nodeType = workflow.nodeTypes.find((candidate) => candidate.name === instance.nodeType);
+  return Boolean(instance.config?.pullExecution ?? nodeType?.defaultConfig?.pullExecution);
+}
+function sourceMayNotHaveExecuted(workflow, nodeTypes, sourceNodeId) {
+  if (isStartNode(sourceNodeId) || isExitNode(sourceNodeId)) return false;
+  const branchingNodes = findAllBranchingNodes(workflow, nodeTypes);
+  if (branchingNodes.has(sourceNodeId)) return true;
+  const allInstanceIds = new Set(workflow.instances.map((instance) => instance.id));
+  for (const branchInstanceId of branchingNodes) {
+    for (const port of [RESERVED_PORT_NAMES.ON_SUCCESS, RESERVED_PORT_NAMES.ON_FAILURE]) {
+      const inBranch = findNodesInBranch(
+        branchInstanceId,
+        port,
+        workflow,
+        allInstanceIds,
+        branchingNodes
+      );
+      if (inBranch.has(sourceNodeId)) return true;
+    }
+  }
+  return false;
+}
+function sourceIndexVar(sourceNode) {
+  return isStartNode(sourceNode) ? "startIdx" : `${toValidIdentifier(sourceNode)}Idx`;
+}
+function isConstSource(em, sourceNode) {
+  return isStartNode(sourceNode) || sourceNode === em.instanceParent;
+}
+function unguardedSourceIndex(em, sourceNode) {
+  const sourceIdx = sourceIndexVar(sourceNode);
+  return isPullExecutionSource(em.workflow, sourceNode) ? `${sourceIdx} ?? 0` : `${sourceIdx}${isConstSource(em, sourceNode) ? "" : "!"}`;
+}
+function sourceNodeTypeName(workflow, sourceNode) {
+  if (isStartNode(sourceNode)) return "Start";
+  const sourceInstance = workflow.instances.find((candidate) => candidate.id === sourceNode);
+  const sourceNodeType = workflow.nodeTypes.find(
+    (candidate) => candidate.name === sourceInstance?.nodeType || candidate.functionName === sourceInstance?.nodeType
+  );
+  return sourceNodeType?.functionName ?? sourceInstance?.nodeType ?? sourceNode;
+}
+function contextRead(em, sourceNode, sourcePort, executionIndex) {
+  return `${em.getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${executionIndex}, nodeTypeName: '${sourceNodeTypeName(em.workflow, sourceNode)}' })`;
+}
+function sourceExists(workflow, sourceNode) {
+  return isStartNode(sourceNode) || workflow.instances.some((i) => i.id === sourceNode);
+}
+function emitExecuteSignal(em, executeConnections) {
+  const varName = `${em.safeId}_execute`;
+  const signal = (conn) => {
+    const sourceNode = conn.from.node;
+    const sourceIdx = sourceIndexVar(sourceNode);
+    const read = `${contextRead(em, sourceNode, conn.from.port, sourceIdx)} as boolean`;
+    return isConstSource(em, sourceNode) ? read : `${sourceIdx} !== undefined ? ${read} : false`;
+  };
+  if (executeConnections.length === 1) {
+    em.lines.push(`${em.indent}const ${varName} = ${signal(executeConnections[0])};`);
+  } else {
+    const parts = executeConnections.map((conn) => `(${signal(conn)})`);
+    em.lines.push(`${em.indent}const ${varName} = ${parts.join(" || ")};`);
+  }
+  return varName;
+}
+function emitSingleConnectionValue(em, portConfig, connection, varName, paramIndex) {
+  const { indent, lines, workflow } = em;
+  const sourceNode = connection.from.node;
+  const sourcePort = connection.from.port;
+  if (!sourceExists(workflow, sourceNode)) {
+    lines.push(`${indent}const ${varName} = undefined; // Source node '${sourceNode}' not found`);
+    return;
+  }
+  const sourceIdx = sourceIndexVar(sourceNode);
+  const sourceExecutionIndex = unguardedSourceIndex(em, sourceNode);
+  const portType = argumentPortType(em.node, portConfig, paramIndex);
+  const needsGuard = !isConstSource(em, sourceNode) && (portConfig.optional || sourceMayNotHaveExecuted(workflow, workflow.nodeTypes, sourceNode));
+  if (portConfig.dataType === "FUNCTION") {
+    lines.push(`${indent}${RESOLVE_FUNCTION_FALLBACK}`);
+    const rawVarName = `${varName}_raw`;
+    if (needsGuard) {
+      lines.push(
+        `${indent}const ${rawVarName} = ${sourceIdx} !== undefined ? ${contextRead(em, sourceNode, sourcePort, sourceIdx)} : undefined;`
+      );
+      lines.push(
+        `${indent}const ${varName}_resolved = ${rawVarName} !== undefined ? __resolveFunction(${rawVarName}) : undefined;`
+      );
+      lines.push(`${indent}const ${varName} = ${varName}_resolved?.fn as ${portType};`);
+    } else {
+      lines.push(
+        `${indent}const ${rawVarName} = ${contextRead(em, sourceNode, sourcePort, sourceExecutionIndex)};`
+      );
+      lines.push(`${indent}const ${varName}_resolved = __resolveFunction(${rawVarName});`);
+      lines.push(`${indent}const ${varName} = ${varName}_resolved.fn as ${portType};`);
+    }
+    return;
+  }
+  const sourceDataType = resolveSourcePortDataType(workflow, sourceNode, sourcePort);
+  const coerceExpr = getCoercionWrapper(connection, sourceDataType, portConfig.dataType);
+  if (needsGuard) {
+    const getExpr = contextRead(em, sourceNode, sourcePort, sourceIdx);
+    const wrappedExpr = coerceExpr ? `${coerceExpr}(${getExpr})` : getExpr;
+    lines.push(
+      portConfig.optional ? `${indent}const ${varName} = ${sourceIdx} !== undefined ? ${wrappedExpr} as ${portType} : undefined;` : `${indent}const ${varName} = (${sourceIdx} !== undefined ? ${wrappedExpr} : undefined) as ${portType};`
+    );
+  } else {
+    const getExpr = contextRead(em, sourceNode, sourcePort, sourceExecutionIndex);
+    if (coerceExpr) {
+      lines.push(`${indent}const ${varName} = ${coerceExpr}(${getExpr}) as ${portType};`);
+    } else {
+      lines.push(`${indent}const ${varName} = ${getExpr} as ${portType};`);
+    }
+  }
+}
+function mergeAttempts(attempts, strategy) {
+  const arrived = `[${attempts.join(", ")}].filter((v) => v !== undefined)`;
+  switch (strategy) {
+    case "LAST":
+      return `${arrived}.pop()`;
+    case "COLLECT":
+      return arrived;
+    case "CONCAT":
+      return `${arrived}.flat()`;
+    case "MERGE":
+      return `Object.assign({}, ...${arrived})`;
+    case "FIRST":
+    case void 0:
+    default:
+      return attempts.join(" ?? ");
+  }
+}
+function emitFanInValue(em, portConfig, connections, varName, paramIndex) {
+  const { indent, lines, workflow } = em;
+  const validConnections = connections.filter((conn) => sourceExists(workflow, conn.from.node));
+  if (validConnections.length === 0) {
+    lines.push(`${indent}const ${varName} = undefined; // All source nodes not found`);
+    return;
+  }
+  const attempts = validConnections.map((conn) => {
+    const sourceNode = conn.from.node;
+    const sourcePort = conn.from.port;
+    const sourceIdx = sourceIndexVar(sourceNode);
+    const getExpr = contextRead(em, sourceNode, sourcePort, sourceIdx);
+    if (portConfig.dataType === "FUNCTION") {
+      return `(${sourceIdx} !== undefined ? ${getExpr} : undefined)`;
+    }
+    const sourceDataType = resolveSourcePortDataType(workflow, sourceNode, sourcePort);
+    const coerceExpr = getCoercionWrapper(conn, sourceDataType, portConfig.dataType);
+    const wrapped = coerceExpr ? `${coerceExpr}(${getExpr})` : getExpr;
+    return `(${sourceIdx} !== undefined ? ${wrapped} : undefined)`;
+  });
+  const merged = mergeAttempts(attempts, portConfig.mergeStrategy);
+  const portType = argumentPortType(em.node, portConfig, paramIndex);
+  if (portConfig.dataType === "FUNCTION") {
+    lines.push(`${indent}${RESOLVE_FUNCTION_FALLBACK}`);
+    const rawVarName = `${varName}_raw`;
+    lines.push(`${indent}const ${rawVarName} = ${merged};`);
+    lines.push(
+      `${indent}const ${varName}_resolved = ${rawVarName} !== undefined ? __resolveFunction(${rawVarName}) : undefined;`
+    );
+    lines.push(`${indent}const ${varName} = ${varName}_resolved?.fn as ${portType};`);
+  } else {
+    lines.push(`${indent}const ${varName} = (${merged}) as ${portType};`);
+  }
+}
+
+// src/generator/input-port-values.ts
+function emitInputEvent(em, portName, value) {
+  if (em.emitInputEvents) {
+    em.lines.push(
+      `${em.indent}${em.setCall}({ id: '${em.id}', portName: '${portName}', executionIndex: ${em.safeId}Idx, nodeTypeName: '${em.eventNodeTypeName}', durable: false }, ${value});`
+    );
+  }
+}
+function emitInputPortValue(em, portName, paramIndex) {
+  const { node, indent, lines } = em;
+  const portConfig = node.inputs[portName];
+  const varName = `${em.safeId}_${portName}`;
+  const instancePortConfig = em.workflow.instances.find((i) => i.id === em.id)?.config?.portConfigs?.find(
+    (pc) => pc.portName === portName && (pc.direction == null || pc.direction === "INPUT")
+  );
+  const connections = em.inputConnections.filter((conn) => conn.to.port === portName);
+  if (instancePortConfig?.expression !== void 0) {
+    emitInstanceExpressionValue(em, portConfig, String(instancePortConfig.expression), varName, paramIndex);
+  } else if (connections.length === 1) {
+    emitSingleConnectionValue(em, portConfig, connections[0], varName, paramIndex);
+  } else if (connections.length > 1) {
+    emitFanInValue(em, portConfig, connections, varName, paramIndex);
+  } else if (portConfig.expression) {
+    const expression = portConfig.expression;
+    const portType = argumentPortType(node, portConfig, paramIndex);
+    if (isFunctionExpression(expression)) {
+      lines.push(`${indent}const ${varName} = ${em.isAsync ? "await " : ""}(${expression})(ctx) as ${portType};`);
+    } else {
+      lines.push(`${indent}const ${varName} = ${expression} as ${portType};`);
+    }
+  } else if (portConfig.default !== void 0) {
+    lines.push(`${indent}const ${varName} = ${JSON.stringify(portConfig.default)};`);
+  } else if (portConfig.optional) {
+    lines.push(`${indent}const ${varName} = undefined;`);
+  } else {
+    const portType = argumentPortType(node, portConfig, paramIndex);
+    lines.push(
+      `${indent}let ${varName}: ${portType} = undefined as unknown as ${portType}; // Required port '${portName}' has no connection`
+    );
+  }
+  return varName;
+}
+function isFunctionExpression(expression) {
+  return expression.includes("=>") || expression.trim().startsWith("function");
+}
+function emitInstanceExpressionValue(em, portConfig, source, varName, paramIndex) {
+  const { indent, lines } = em;
+  const expr = substituteExpressionReferences(em, source, varName);
+  const exprPortType = argumentPortType(em.node, portConfig, paramIndex);
+  if (isFunctionExpression(expr)) {
+    lines.push(`${indent}const ${varName} = ${em.isAsync ? "await " : ""}(${expr})(ctx) as ${exprPortType};`);
+  } else {
+    lines.push(`${indent}const ${varName} = (${expr}) as ${exprPortType};`);
+  }
+}
+function substituteExpressionReferences(em, expr, varName) {
+  const { workflow } = em;
+  const referenceableRoots = /* @__PURE__ */ new Set(["Start", ...workflow.instances.map((inst) => inst.id)]);
+  const isRealPort = (root, port) => {
+    if (isExecutePort(port) || isSuccessPort(port) || isFailurePort(port)) return false;
+    if (isStartNode(root)) return port in (workflow.startPorts ?? {});
+    const sourceInstance = workflow.instances.find((inst) => inst.id === root);
+    const sourceType = sourceInstance ? workflow.nodeTypes.find((nt) => nt.name === sourceInstance.nodeType || nt.functionName === sourceInstance.nodeType) : void 0;
+    return !!sourceType && port in sourceType.outputs;
+  };
+  const refs = findExpressionReferences(expr, referenceableRoots).filter(
+    (ref) => ref.root !== em.id && isRealPort(ref.root, ref.port)
+  );
+  if (refs.length === 0) return expr;
+  const fetched = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const key = `${ref.root}.${ref.port}`;
+    if (fetched.has(key)) continue;
+    const refVar = `${varName}_ref_${toValidIdentifier(ref.root)}_${toValidIdentifier(ref.port)}`;
+    const refType = resolveReferencedPortType(workflow, ref.root, ref.port);
+    em.lines.push(
+      `${em.indent}const ${refVar} = ${contextRead(em, ref.root, ref.port, unguardedSourceIndex(em, ref.root))} as ${refType};`
+    );
+    fetched.set(key, refVar);
+  }
+  return rewriteExpressionReferences(expr, refs, (ref) => fetched.get(`${ref.root}.${ref.port}`));
+}
+
+// src/generator/node-invocation.ts
+function buildDurableGatePayload(arguments_) {
+  return `{ arguments: [${arguments_.join(", ")}].map((value) => value === undefined ? { absent: true } : { value }) }`;
+}
+function emitDurableNodeCall(call, gateResultType) {
+  const { nodeType, instanceId, safeId, functionName, resultVar, args, ctxVar, indent, lines } = call;
+  if (nodeType.durableGate) {
+    const trailingRuntimeArgs = (nodeType.receivesAbortSignal ? 1 : 0) + (nodeType.receivesRuntime ? 1 : 0);
+    const gateArgs = args.slice(
+      nodeType.expression ? 0 : 1,
+      trailingRuntimeArgs > 0 ? -trailingRuntimeArgs : void 0
+    );
+    lines.push(
+      `${indent}const ${resultVar} = ${ctxVar}.resolveGate('${nodeType.durableGate}', '${instanceId}', '${functionName}', ${safeId}Idx, ${buildDurableGatePayload(gateArgs)} as unknown as WireValue) as ${gateResultType};`
+    );
+    return true;
+  }
+  if (nodeType.durableEffect) {
+    lines.push(
+      `${indent}const ${resultVar} = await ${ctxVar}.executeEffect('${instanceId}', '${functionName}', ${safeId}Idx, async (__operationKey__) => ${functionName}(${[...args, "__operationKey__"].join(", ")}));`
+    );
+    return true;
+  }
+  return false;
+}
+function emitPlainNodeCall(call, isAsync, awaitKeyword) {
+  const { nodeType, instanceId, safeId, functionName, resultVar, args, ctxVar, indent, lines } = call;
+  if (nodeType.variant === "MAP_ITERATOR") {
+    const executeArg = args[0];
+    const itemsArg = args[1];
+    const scopeFnArg = args[2];
+    lines.push(`${indent}let ${resultVar}: { onSuccess: boolean; onFailure: boolean; results: unknown[] };`);
+    lines.push(`${indent}if (!${executeArg}) {`);
+    lines.push(`${indent}  ${resultVar} = { onSuccess: false, onFailure: false, results: [] };`);
+    lines.push(`${indent}} else {`);
+    lines.push(`${indent}  const __results: unknown[] = [];`);
+    lines.push(`${indent}  for (const __item of ${itemsArg}) {`);
+    lines.push(`${indent}    __results.push((${isAsync ? "await " : ""}${scopeFnArg}(true, __item)).processed);`);
+    lines.push(`${indent}  }`);
+    lines.push(`${indent}  ${resultVar} = { onSuccess: true, onFailure: false, results: __results };`);
+    lines.push(`${indent}}`);
+    return;
+  }
+  if (nodeType.variant === "IMPORTED_WORKFLOW" || nodeType.variant === "WORKFLOW") {
+    const executeArg = args[0];
+    const dataArgs = args.slice(1);
+    const inputPortNames = Object.keys(nodeType.inputs).filter((p) => !isExecutePort(p));
+    const paramsEntries = inputPortNames.map((portName, i) => `${portName}: ${dataArgs[i]}`);
+    paramsEntries.push("__rd__: __rd__ + 1");
+    const paramsVar = `__${safeId}Params__`;
+    lines.push(`${indent}const ${paramsVar} = { ${paramsEntries.join(", ")} };`);
+    lines.push(
+      `${indent}const ${resultVar} = ${awaitKeyword}${functionName}(${executeArg}, ${paramsVar}, ${ctxVar}.createNestedRuntime('${functionName}', '${instanceId}', ${safeId}Idx));`
+    );
+    return;
+  }
+  lines.push(`${indent}const ${resultVar} = ${awaitKeyword}${functionName}(${args.join(", ")});`);
+}
+function outputLine(call, setCall, portName, value) {
+  const { instanceId, safeId, functionName, indent } = call;
+  return `${indent}${setCall}({ id: '${instanceId}', portName: '${portName}', executionIndex: ${safeId}Idx, nodeTypeName: '${functionName}' }, ${value});`;
+}
+function emitResultOutputs(call, setCall, skip = () => false) {
+  const { nodeType, resultVar, lines } = call;
+  for (const portName of Object.keys(nodeType.outputs)) {
+    if (skip(portName) || nodeType.outputs[portName].scope) continue;
+    lines.push(outputLine(call, setCall, portName, `${resultVar}.${portName}`));
+  }
+}
+function emitExpressionCallAndOutputs(call, setCall, awaitKeyword) {
+  const { nodeType, functionName, resultVar, args, indent, lines } = call;
+  lines.push(`${indent}const ${resultVar} = ${awaitKeyword}${functionName}(${args.join(", ")});`);
+  const dataOutputPorts = Object.keys(nodeType.outputs).filter((portName) => {
+    const portConfig = nodeType.outputs[portName];
+    if (portConfig.scope) return false;
+    if (isSuccessPort(portName) || isFailurePort(portName)) return false;
+    if (portConfig.isControlFlow || portConfig.failure) return false;
+    return true;
+  });
+  if (dataOutputPorts.length === 1) {
+    const portName = dataOutputPorts[0];
+    const rawVar = `${resultVar}_raw`;
+    lines.push(`${indent}const ${rawVar}: unknown = ${resultVar};`);
+    lines.push(
+      outputLine(
+        call,
+        setCall,
+        portName,
+        `typeof ${rawVar} === 'object' && ${rawVar} !== null && '${portName}' in ${rawVar} ? ${rawVar}.${portName} : ${rawVar}`
+      )
+    );
+  } else {
+    for (const portName of dataOutputPorts) {
+      lines.push(outputLine(call, setCall, portName, `${resultVar}.${portName}`));
+    }
+  }
+  lines.push(outputLine(call, setCall, "onSuccess", "true"));
+  lines.push(outputLine(call, setCall, "onFailure", "false"));
+}
+function emitNodeInvocation(call, options) {
+  const { setCall, isAsync, awaitKeyword, gateResultType, inlineStubAndCoercion } = options;
+  const { nodeType, instanceId, functionName, resultVar, args, indent, lines } = call;
+  if (emitDurableNodeCall(call, gateResultType)) {
+    emitResultOutputs(call, setCall);
+    return;
+  }
+  if (inlineStubAndCoercion && nodeType.variant === "STUB") {
+    lines.push(
+      `${indent}throw new Error('Node "${instanceId}" uses stub type "${functionName}" which has no implementation.');`
+    );
+    return;
+  }
+  if (inlineStubAndCoercion && nodeType.variant === "COERCION") {
+    const coerceExpr = COERCE_EXPRESSIONS[functionName] || "String";
+    const valueArg = args[0] || "undefined";
+    lines.push(`${indent}const ${resultVar} = ${coerceExpr}(${valueArg});`);
+    lines.push(outputLine(call, setCall, "result", resultVar));
+    lines.push(outputLine(call, setCall, "onSuccess", "true"));
+    lines.push(outputLine(call, setCall, "onFailure", "false"));
+    return;
+  }
+  if (nodeType.expression) {
+    emitExpressionCallAndOutputs(call, setCall, awaitKeyword);
+    return;
+  }
+  emitPlainNodeCall(call, isAsync, awaitKeyword);
+  emitResultOutputs(call, setCall);
+}
+
+// src/generator/scoped-child.ts
+function emitScopedChild(lines, frame, child, buildArgs) {
+  const { workflow, isAsync, production } = frame;
+  const childNodeType = workflow.nodeTypes?.find(
+    (nt) => nt.name === child.nodeType || nt.functionName === child.nodeType
+  );
+  if (!childNodeType) {
+    lines.push(`    // WARNING: Node type '${child.nodeType}' not found for child '${child.id}'`);
+    return;
+  }
+  const safeChildId = toValidIdentifier(child.id);
+  const awaitPrefix = isAsync ? "await " : "";
+  const emitDebugHooks = !production;
+  const childIndent = "      ";
+  const block = {
+    child,
+    childNodeType,
+    safeChildId,
+    awaitPrefix,
+    childIndent,
+    tryIndent: `${childIndent}  `,
+    setCall: isAsync ? `await scopedCtx.setVariable` : `scopedCtx.setVariable`
+  };
+  lines.push(``);
+  lines.push(`    // Execute: ${child.id} (${child.nodeType})`);
+  if (emitDebugHooks) {
+    lines.push(`    ${awaitPrefix}__ctrl__.beforeNode('${child.id}', scopedCtx);`);
+  }
+  lines.push(`    scopedCtx.checkAborted('${child.id}');`);
+  lines.push(`    const ${safeChildId}Idx = scopedCtx.addExecution('${child.id}');`);
+  lines.push(`    if (scopedCtx.shouldExecute('${child.id}', '${child.nodeType}', ${safeChildId}Idx)) {`);
+  lines.push(...statusEvent(block, childIndent, `'RUNNING'`));
+  lines.push(`${childIndent}try {`);
+  const args = emitChildArguments(lines, frame, block, buildArgs);
+  emitChildCallAndOutputs(lines, block, args);
+  const { tryIndent } = block;
+  lines.push(...statusEvent(block, tryIndent, `'SUCCEEDED'`));
+  lines.push(`${tryIndent}scopedCtx.commitNode('${child.id}', '${child.nodeType}', ${safeChildId}Idx);`);
+  if (emitDebugHooks) {
+    lines.push(`${tryIndent}${awaitPrefix}__ctrl__.afterNode('${child.id}', scopedCtx);`);
+  }
+  emitChildCatch(lines, block);
+  lines.push(`    }`);
+}
+function statusEvent(block, indent, status) {
+  const { child, safeChildId, awaitPrefix } = block;
+  return [
+    `${indent}${awaitPrefix}scopedCtx.sendStatusChangedEvent({`,
+    `${indent}  nodeTypeName: '${child.nodeType}',`,
+    `${indent}  id: '${child.id}',`,
+    `${indent}  executionIndex: ${safeChildId}Idx,`,
+    `${indent}  status: ${status},`,
+    `${indent}});`
+  ];
+}
+function emitChildArguments(lines, frame, block, buildArgs) {
+  const { scopeName, parentNodeId, parentNodeType, workflow, isAsync, production } = frame;
+  const { child, childNodeType, safeChildId, tryIndent, setCall } = block;
+  const argLines = [];
+  const getCall = isAsync ? "await scopedCtx.getVariable" : "scopedCtx.getVariable";
+  const preHandledPorts = /* @__PURE__ */ new Set();
+  const parentConnections = workflow.connections.filter(
+    (conn) => conn.from.node === parentNodeId && conn.to.node === child.id
+  );
+  parentConnections.forEach((conn) => {
+    const sourcePort = parentNodeType.outputs[conn.from.port];
+    if (!sourcePort || sourcePort.scope !== scopeName) return;
+    const targetPort = conn.to.port;
+    const varName = `${safeChildId}_${targetPort}`;
+    const targetPortDef = childNodeType.inputs[targetPort];
+    const portType = targetPortDef ? mapToTypeScript(targetPortDef.dataType, targetPortDef.tsType) : "unknown";
+    argLines.push(
+      `${tryIndent}const ${varName} = ${getCall}({ id: '${parentNodeId}', portName: '${conn.from.port}', executionIndex: scopeParamIdx_${conn.from.port} }) as ${portType};`
+    );
+    argLines.push(
+      `${tryIndent}${setCall}({ id: '${child.id}', portName: '${targetPort}', executionIndex: ${safeChildId}Idx, nodeTypeName: '${child.nodeType}', durable: false }, ${varName});`
+    );
+    preHandledPorts.add(targetPort);
+  });
+  const args = buildArgs({
+    node: childNodeType,
+    workflow: frame.scopeWorkflow,
+    id: child.id,
+    lines: argLines,
+    indent: tryIndent,
+    getCall,
+    isAsync,
+    instanceParent: child.parent ? `${child.parent.id}.${child.parent.scope}` : void 0,
+    skipPorts: preHandledPorts,
+    emitInputEvents: true,
+    setCall,
+    nodeTypeName: child.nodeType,
+    production,
+    runtimeContextExpression: "scopedCtx"
+  });
+  lines.push(...argLines);
+  return args;
+}
+function emitChildCallAndOutputs(lines, block, args) {
+  const { child, childNodeType, safeChildId, tryIndent, setCall, awaitPrefix } = block;
+  const childResultVar = nodeResultVar(safeChildId, child.nodeType);
+  const childCall = {
+    nodeType: childNodeType,
+    instanceId: child.id,
+    safeId: safeChildId,
+    functionName: child.nodeType,
+    resultVar: childResultVar,
+    args,
+    ctxVar: "scopedCtx",
+    indent: tryIndent,
+    lines
+  };
+  if (!emitDurableNodeCall(childCall, "any")) {
+    lines.push(`${tryIndent}const ${childResultVar} = ${awaitPrefix}${child.nodeType}(${args.join(", ")});`);
+  }
+  const storeOutput = (outPort, value) => {
+    lines.push(
+      `${tryIndent}${setCall}({ id: '${child.id}', portName: '${outPort}', executionIndex: ${safeChildId}Idx, nodeTypeName: '${child.nodeType}' }, ${value});`
+    );
+  };
+  Object.keys(childNodeType.outputs || {}).forEach((outPort) => {
+    if (!childNodeType.expression) {
+      storeOutput(outPort, `${childResultVar}.${outPort}`);
+      return;
+    }
+    const portDef = childNodeType.outputs[outPort];
+    if (portDef.failure || isFailurePort(outPort)) {
+      storeOutput(outPort, "false");
+    } else if (portDef.isControlFlow || isSuccessPort(outPort)) {
+      storeOutput(outPort, "true");
+    } else {
+      storeOutput(outPort, `${childResultVar}.${outPort}`);
+    }
+  });
+}
+function emitChildCatch(lines, block) {
+  const { child, safeChildId, childIndent, tryIndent } = block;
+  lines.push(`${childIndent}} catch (error: unknown) {`);
+  lines.push(
+    `${tryIndent}if ((error as { code?: unknown })?.code === 'FLOW_WEAVER_DURABLE_GATE_YIELD') throw error;`
+  );
+  lines.push(`${tryIndent}const isCancellation = CancellationError.isCancellationError(error);`);
+  lines.push(...statusEvent(block, tryIndent, `isCancellation ? 'CANCELLED' : 'FAILED'`));
+  lines.push(`${tryIndent}if (!isCancellation) {`);
+  lines.push(`${tryIndent}  scopedCtx.sendLogErrorEvent({`);
+  lines.push(`${tryIndent}    nodeTypeName: '${child.nodeType}',`);
+  lines.push(`${tryIndent}    id: '${child.id}',`);
+  lines.push(`${tryIndent}    executionIndex: ${safeChildId}Idx,`);
+  lines.push(`${tryIndent}    error: error instanceof Error ? error.message : String(error),`);
+  lines.push(
+    `${tryIndent}    code: typeof (error as { code?: unknown }).code === 'string' ? ((error as { code?: unknown }).code as string) : undefined,`
+  );
+  lines.push(`${tryIndent}  });`);
+  lines.push(`${tryIndent}}`);
+  lines.push(`${tryIndent}throw error;`);
+  lines.push(`${childIndent}}`);
+}
+
+// src/generator/scope-closure.ts
+function emitScopeClosure(scopeName, parentNodeId, parentNodeType, workflow, childInstances, isAsync, production, buildArgs) {
+  const lines = [];
+  const { params, returns } = collectScopedPorts(parentNodeType, scopeName);
+  emitClosureOpening(lines, scopeName, parentNodeId, parentNodeType, params, isAsync);
+  if (childInstances.length > 0) {
+    lines.push(`    // Execute child nodes in topologically sorted order`);
+    const { scopeWorkflow, order } = orderScopeChildren(scopeName, parentNodeId, parentNodeType, workflow, childInstances);
+    const frame = {
+      scopeName,
+      parentNodeId,
+      parentNodeType,
+      workflow,
+      scopeWorkflow,
+      isAsync,
+      production
+    };
+    order.forEach((childId) => {
+      const child = childInstances.find((c) => c.id === childId);
+      if (child) emitScopedChild(lines, frame, child, buildArgs);
+    });
+    lines.push(``);
+  }
+  emitScopeReturn(lines, scopeName, parentNodeId, parentNodeType, workflow, childInstances, returns, isAsync, production);
+  lines.push(`  };`);
+  lines.push(`})(ctx)`);
+  return lines.join("\n    ");
+}
+function collectScopedPorts(parentNodeType, scopeName) {
+  const params = Object.entries(parentNodeType.outputs).filter(([, portDef]) => portDef.scope === scopeName && portDef.dataType !== "FUNCTION").map(([portName]) => portName);
+  const returns = Object.entries(parentNodeType.inputs).filter(([, portDef]) => portDef.scope === scopeName).map(([portName]) => portName);
+  return { params, returns };
+}
+function emitClosureOpening(lines, scopeName, parentNodeId, parentNodeType, params, isAsync) {
+  const awaitKeyword = isAsync ? "async " : "";
+  const signature = params.map((p) => {
+    const portDef = parentNodeType.outputs[p];
+    const portType = portDef ? mapToTypeScript(portDef.dataType, portDef.tsType) : "unknown";
+    return `${p}: ${portType}`;
+  }).join(", ");
+  lines.push(`((ctx) => {`);
+  lines.push(`  return ${awaitKeyword}(${signature}) => {`);
+  lines.push(`    // Scope function body for '${scopeName}'`);
+  lines.push(``);
+  const safeParentId = toValidIdentifier(parentNodeId);
+  lines.push(`    // Create scoped context for child nodes`);
+  const isAsyncOverrideArg = isAsync ? "" : ", false";
+  lines.push(
+    `    const scopedCtx = ctx.createScope('${parentNodeId}', ${safeParentId}Idx!, '${scopeName}', true${isAsyncOverrideArg});`
+  );
+  lines.push(``);
+  if (params.length > 0) {
+    lines.push(`    // Set scope parameters as variables for child nodes`);
+    const setCall = isAsync ? `await scopedCtx.setVariable` : `scopedCtx.setVariable`;
+    params.forEach((portName) => {
+      lines.push(`    const scopeParamIdx_${portName} = scopedCtx.addExecution('${parentNodeId}_param_${portName}');`);
+      lines.push(
+        `    ${setCall}({ id: '${parentNodeId}', portName: '${portName}', executionIndex: scopeParamIdx_${portName}, nodeTypeName: '${parentNodeType.functionName}', scope: '${scopeName}', side: 'start' }, ${portName});`
+      );
+    });
+    lines.push(``);
+  }
+}
+function orderScopeChildren(scopeName, parentNodeId, parentNodeType, workflow, childInstances) {
+  const childIds = childInstances.map((c) => c.id);
+  const childConnections = workflow.connections.filter((conn) => {
+    if (childIds.includes(conn.from.node) && childIds.includes(conn.to.node)) {
+      return true;
+    }
+    if (conn.from.node === parentNodeId && childIds.includes(conn.to.node)) {
+      const sourcePort = parentNodeType.outputs[conn.from.port];
+      if (sourcePort && sourcePort.scope === scopeName) {
+        return true;
+      }
+    }
+    return false;
+  });
+  const parentVirtualInstance = {
+    type: "NodeInstance",
+    id: parentNodeId,
+    nodeType: parentNodeType.functionName,
+    parent: void 0
+  };
+  const scopeWorkflow = {
+    ...workflow,
+    instances: [parentVirtualInstance, ...childInstances],
+    connections: childConnections
+  };
+  const childNodeTypes = childInstances.map((c) => {
+    return workflow.nodeTypes?.find((nt) => nt.name === c.nodeType || nt.functionName === c.nodeType);
+  }).filter((nt) => nt !== void 0);
+  const cfg = buildControlFlowGraph(scopeWorkflow, childNodeTypes);
+  return { scopeWorkflow, order: performKahnsTopologicalSort(cfg) };
+}
+function emitScopeReturn(lines, scopeName, parentNodeId, parentNodeType, workflow, childInstances, returns, isAsync, production) {
+  lines.push(`    // Merge scoped execution back to parent context`);
+  lines.push(`    ctx.mergeScope(scopedCtx);`);
+  lines.push(``);
+  lines.push(`    // Extract return values from child outputs`);
+  const returnObj = [];
+  const getCallAfterMerge = isAsync ? "await scopedCtx.getVariable" : "scopedCtx.getVariable";
+  const setCallAfterMerge = isAsync ? "await ctx.setVariable" : "ctx.setVariable";
+  const emitExitEvent = (portName, value) => {
+    if (!production) {
+      lines.push(
+        `    ${setCallAfterMerge}({ id: '${parentNodeId}', portName: '${portName}', executionIndex: scopeExitIdx, scope: '${scopeName}', side: 'exit', nodeTypeName: '${parentNodeType.functionName}' }, ${value});`
+      );
+    }
+  };
+  lines.push(`    const scopeExitIdx = ctx.addExecution('${parentNodeId}_scope_exit');`);
+  returns.forEach((portName) => {
+    const connection = workflow.connections.find((conn) => {
+      return conn.to.port === portName && childInstances.some((c) => c.id === conn.from.node);
+    });
+    const portDef = parentNodeType.inputs[portName];
+    const portType = portDef ? mapToTypeScript(portDef.dataType, portDef.tsType) : "unknown";
+    const defaultValue = portName === "success" ? "true" : portName === "failure" ? "false" : "undefined";
+    if (!connection) {
+      emitExitEvent(portName, defaultValue);
+      returnObj.push(`${portName}: ${defaultValue}`);
+      return;
+    }
+    const sourceNode = connection.from.node;
+    const varName = `scopeReturn_${portName}`;
+    const sourceNodeTypeName2 = childInstances.find((c) => c.id === sourceNode)?.nodeType ?? "";
+    const varAddr = `{ id: '${sourceNode}', portName: '${connection.from.port}', executionIndex: ${toValidIdentifier(sourceNode)}Idx, nodeTypeName: '${sourceNodeTypeName2}' }`;
+    if (portName === "success" || portName === "failure") {
+      lines.push(
+        `    const ${varName} = scopedCtx.hasVariable(${varAddr}) ? ${getCallAfterMerge}(${varAddr}) as ${portType} : ${defaultValue};`
+      );
+    } else {
+      lines.push(`    const ${varName} = ${getCallAfterMerge}(${varAddr}) as ${portType};`);
+    }
+    emitExitEvent(portName, varName);
+    returnObj.push(`${portName}: ${varName}`);
+  });
+  lines.push(`    return { ${returnObj.join(", ")} };`);
+}
+
+// src/generator/node-arguments.ts
+function buildNodeArgumentsWithContext(opts) {
+  const {
+    node,
+    workflow,
+    id,
+    lines,
+    indent = "    ",
+    getCall = "await ctx.getVariable",
+    isAsync = true,
+    instanceParent,
+    skipPorts,
+    emitInputEvents = false,
+    setCall = "await ctx.setVariable",
+    nodeTypeName,
+    production = false,
+    abortSignalExpression = "ctx.getAbortSignal()",
+    runtimeContextExpression = "ctx"
+  } = opts;
+  const em = {
+    node,
+    workflow,
+    id,
+    safeId: toValidIdentifier(id),
+    lines,
+    indent,
+    getCall,
+    setCall,
+    isAsync,
+    instanceParent,
+    emitInputEvents,
+    eventNodeTypeName: nodeTypeName || node.functionName,
+    inputConnections: workflow.connections.filter((conn) => conn.to.node === id)
+  };
+  const args = [];
+  pushExecuteArgument(em, skipPorts, args);
+  Object.keys(node.inputs).forEach((portName) => {
+    if (isExecutePort(portName)) return;
+    if (node.inputs[portName].scope) return;
+    if (skipPorts?.has(portName)) {
+      args.push(`${em.safeId}_${portName}`);
+      return;
+    }
+    const varName = emitInputPortValue(em, portName, args.length);
+    args.push(varName);
+    emitInputEvent(em, portName, varName);
+  });
+  pushScopeFunctionArguments(em, production, args);
+  if (node.receivesAbortSignal) {
+    args.push(abortSignalExpression);
+  }
+  if (node.receivesRuntime) {
+    args.push(
+      `{ nodeId: '${id}', runtime: ${runtimeContextExpression}.getRuntime(), recursionDepth: __rd__, createNestedRuntime: (workflowId: string) => ${runtimeContextExpression}.createNestedRuntime(workflowId, '${id}', ${em.safeId}Idx!) }`
+    );
+  }
+  return args;
+}
+function pushExecuteArgument(em, skipPorts, args) {
+  const executeConnections = em.inputConnections.filter((conn) => conn.to.port === "execute");
+  if (em.node.expression) {
+    emitInputEvent(em, "execute", "true");
+  } else if (skipPorts?.has("execute")) {
+    args.push(`${em.safeId}_execute`);
+  } else if (executeConnections.length > 0) {
+    const varName = emitExecuteSignal(em, executeConnections);
+    emitInputEvent(em, "execute", varName);
+    args.push(varName);
+  } else {
+    emitInputEvent(em, "execute", "true");
+    args.push("true");
+  }
+}
+function pushScopeFunctionArguments(em, production, args) {
+  const { node, workflow, id } = em;
+  const scopeNames = /* @__PURE__ */ new Set();
+  Object.values(node.inputs).forEach((portDef) => {
+    if (portDef.scope) scopeNames.add(portDef.scope);
+  });
+  Object.values(node.outputs).forEach((portDef) => {
+    if (portDef.scope) scopeNames.add(portDef.scope);
+  });
+  scopeNames.forEach((scopeName) => {
+    const scopeFunctionVar = `${em.safeId}_${scopeName}_scopeFn`;
+    const childInstances = workflow.instances.filter((inst) => {
+      if (!inst.parent) return false;
+      return inst.parent.id === id && inst.parent.scope === scopeName;
+    });
+    const hasAsyncChild = childInstances.some((child) => {
+      const childNodeType = workflow.nodeTypes?.find(
+        (nt) => nt.name === child.nodeType || nt.functionName === child.nodeType
+      );
+      return childNodeType?.isAsync === true;
+    });
+    const scopeIsAsync = node.isAsync || hasAsyncChild;
+    const scopeFunctionCode = generateScopeFunctionClosure(
+      scopeName,
+      id,
+      node,
+      workflow,
+      childInstances,
+      scopeIsAsync,
+      production
+    );
+    em.lines.push(`${em.indent}const ${scopeFunctionVar} = ${scopeFunctionCode};`);
+    args.push(scopeFunctionVar);
+  });
+}
+function generateScopeFunctionClosure(scopeName, parentNodeId, parentNodeType, workflow, childInstances, isAsync, production) {
+  return emitScopeClosure(
+    scopeName,
+    parentNodeId,
+    parentNodeType,
+    workflow,
+    childInstances,
+    isAsync,
+    production,
+    buildNodeArgumentsWithContext
+  );
+}
+
+export {
+  getCoercionWrapper,
+  toValidIdentifier,
+  nodeResultVar,
+  buildMergeExpression,
+  emitDurableNodeCall,
+  emitPlainNodeCall,
+  emitResultOutputs,
+  emitNodeInvocation,
+  buildNodeArgumentsWithContext
+};