@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/chunks/chunk-TAIUWKZB.js

@@ -0,0 +1,3057 @@
+import {
+  durableBranchPaths,
+  validateDurableClosure
+} from "./chunk-KU3CLJI2.js";
+import {
+  buildNodeArgumentsWithContext,
+  emitDurableNodeCall,
+  emitNodeInvocation,
+  emitPlainNodeCall,
+  emitResultOutputs,
+  nodeResultVar,
+  toValidIdentifier
+} from "./chunk-5Y3AIUWY.js";
+import {
+  extractStartPorts
+} from "./chunk-CZBCCK4Y.js";
+import {
+  canonicalWireValue,
+  sha256Hex
+} from "./chunk-O2U2LO57.js";
+import {
+  VERSION
+} from "./chunk-QDE4Z7KW.js";
+import {
+  getTopologicalOrder
+} from "./chunk-P2CVDGHR.js";
+import {
+  MARKERS
+} from "./chunk-ZMGN6F3S.js";
+import {
+  buildControlFlowGraph,
+  computeParallelLevels,
+  detectBranchingChains,
+  findAllBranchingNodes,
+  findNodesInBranch,
+  isPerPortScopedChild,
+  performKahnsTopologicalSort
+} from "./chunk-4EUSHAY6.js";
+import {
+  assignPortOrders,
+  detectSugarPatterns,
+  filterStaleMacros,
+  formatJSDocDescription,
+  generateJSDocPortTag,
+  generateNodeInstanceTag,
+  httpRouteText,
+  isPathImpliedDataEdge,
+  planPortTags,
+  serializePackDeployAnnotations
+} from "./chunk-VP2P3BPA.js";
+import {
+  mapToTypeScript
+} from "./chunk-E5WN7IGO.js";
+import {
+  EXECUTION_STRATEGIES,
+  RESERVED_NODE_NAMES,
+  RESERVED_PORT_NAMES,
+  isExecutePort,
+  isExitNode,
+  isFailurePort,
+  isStartNode,
+  isSuccessPort
+} from "./chunk-R4QGNK34.js";
+import {
+  __require
+} from "./chunk-SEWDMQ6Q.js";
+
+// src/api/graph-identity.ts
+var connectionKey = (c) => `${c.from.node}.${c.from.port}\0${c.to.node}.${c.to.port}`;
+function portShape(ports) {
+  const shape = {};
+  for (const name of Object.keys(ports).sort()) {
+    const port = ports[name];
+    shape[name] = {
+      ...port.optional ? { optional: true } : {},
+      ...port.isControlFlow || port.dataType === "STEP" ? { control: true } : {},
+      ...port.failure ? { failure: true } : {}
+    };
+  }
+  return shape;
+}
+function graphIdentity(root, allWorkflows = []) {
+  const analysis = validateDurableClosure(root, allWorkflows, { enforce: false });
+  const reachable = [...analysis.reachable].sort(
+    (left, right) => left.functionName.localeCompare(right.functionName)
+  );
+  const workflowsByName = new Map(
+    [...allWorkflows, root].map((workflow) => [workflow.functionName, workflow])
+  );
+  const manifest = JSON.parse(
+    JSON.stringify(
+      reachable.map((workflow) => ({
+        functionName: workflow.functionName,
+        // Declaration order is how the file happens to be written; a
+        // regenerated JSDoc lists the same connections in another order.
+        instances: [...workflow.instances].sort((left, right) => left.id.localeCompare(right.id)).map(({ sourceLocation: _sourceLocation, ...instance }) => instance),
+        connections: [...workflow.connections].sort((left, right) => connectionKey(left).localeCompare(connectionKey(right))).map(({ sourceLocation: _sourceLocation, ...connection }) => connection),
+        scopes: workflow.scopes,
+        startPorts: portShape(workflow.startPorts),
+        exitPorts: portShape(workflow.exitPorts),
+        nodeTypes: [...workflow.nodeTypes].sort((left, right) => left.name.localeCompare(right.name)).map((nodeType) => ({
+          name: nodeType.name,
+          functionName: nodeType.functionName,
+          inputs: portShape(nodeType.inputs),
+          outputs: portShape(nodeType.outputs),
+          expression: nodeType.expression === true,
+          scope: nodeType.scope,
+          durableGate: nodeType.durableGate,
+          durableEffect: nodeType.durableEffect === true,
+          durablePure: nodeType.durablePure === true
+        }))
+      }))
+    )
+  );
+  const graphFingerprint = sha256Hex(canonicalWireValue(manifest));
+  const continuationGraph = {
+    nodes: reachable.flatMap((workflow) => {
+      const executionOrder = getTopologicalOrder(workflow, { includeScopedChildren: true });
+      const branchPaths = durableBranchPaths(workflow);
+      return [
+        {
+          workflowId: workflow.functionName,
+          nodeId: "Start",
+          nodeType: "Start",
+          executionOrder: -1,
+          inputPorts: [],
+          outputPorts: Object.keys(workflow.startPorts),
+          scopeNames: [],
+          invokedWorkflows: [],
+          branchArms: [],
+          branchPath: [],
+          predecessors: []
+        },
+        ...workflow.instances.map((instance) => {
+          const nodeType = workflow.nodeTypes.find(
+            (candidate) => candidate.name === instance.nodeType || candidate.functionName === instance.nodeType
+          );
+          const instanceOrder = executionOrder.indexOf(instance.id);
+          const instanceBranchPath = branchPaths.get(instance.id) ?? [];
+          const invokedWorkflows = instance.nodeType === "invokeWorkflow" ? reachable.map((candidate) => candidate.functionName) : workflowsByName.has(instance.nodeType) ? [instance.nodeType] : [];
+          return {
+            workflowId: workflow.functionName,
+            nodeId: instance.id,
+            nodeType: nodeType?.functionName ?? instance.nodeType,
+            executionOrder: instanceOrder,
+            inputPorts: Object.keys(nodeType?.inputs ?? {}),
+            outputPorts: Object.keys(nodeType?.outputs ?? {}),
+            scopeNames: [
+              ...nodeType?.scope === void 0 ? [] : [nodeType.scope],
+              ...nodeType?.scopes ?? [],
+              ...Object.values(nodeType?.inputs ?? {}).map((port) => port.scope).filter((scope) => scope !== void 0),
+              ...Object.values(nodeType?.outputs ?? {}).map((port) => port.scope).filter((scope) => scope !== void 0)
+            ].filter((scope, index, scopes) => scopes.indexOf(scope) === index),
+            invokedWorkflows,
+            ...instance.parent !== void 0 && instance.parent !== null && {
+              parentScope: { parentNodeId: instance.parent.id, scopeName: instance.parent.scope }
+            },
+            branchArms: [
+              ...Object.hasOwn(nodeType?.outputs ?? {}, "onSuccess") ? ["success"] : [],
+              ...Object.hasOwn(nodeType?.outputs ?? {}, "onFailure") ? ["failure"] : []
+            ],
+            branchPath: instanceBranchPath,
+            predecessors: [
+              { nodeId: "Start", branchPath: [] },
+              ...executionOrder.slice(0, instanceOrder).map((nodeId) => ({ nodeId, branchPath: branchPaths.get(nodeId) ?? [] })).filter(
+                (predecessor) => predecessor.branchPath.every(
+                  (requirement) => instanceBranchPath.some(
+                    (active) => active.nodeId === requirement.nodeId && active.arm === requirement.arm
+                  )
+                )
+              )
+            ],
+            ...nodeType?.durableGate !== void 0 && { durableGate: nodeType.durableGate },
+            ...nodeType?.durableEffect === true && { durableEffect: true }
+          };
+        })
+      ];
+    })
+  };
+  return {
+    reachable,
+    capabilities: { gate: analysis.hasDurableGate, effect: analysis.hasDurableEffect },
+    graphFingerprint,
+    continuationGraph
+  };
+}
+
+// src/generator/async-detection.ts
+function shouldWorkflowBeAsync(workflow, nodeTypes) {
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  for (const nt of nodeTypes) {
+    nodeTypeMap.set(nt.name, nt.isAsync);
+    if (nt.functionName && nt.functionName !== nt.name) {
+      nodeTypeMap.set(nt.functionName, nt.isAsync);
+    }
+  }
+  for (const instance of workflow.instances) {
+    const isAsync = nodeTypeMap.get(instance.nodeType);
+    if (isAsync === true) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateWorkflowAsync(workflow, nodeTypes) {
+  const computedAsync = shouldWorkflowBeAsync(workflow, nodeTypes);
+  const userAsync = workflow.userSpecifiedAsync ?? true;
+  if (!userAsync && computedAsync) {
+    return {
+      shouldBeAsync: true,
+      // Force async for correctness
+      warning: `Workflow function '${workflow.functionName}' was declared as sync, but contains async nodes. Generating as async function.`
+    };
+  }
+  return { shouldBeAsync: computedAsync || userAsync };
+}
+
+// src/api/in-place/node-type-jsdoc.ts
+function generateNodeTypeJSDoc(nodeType) {
+  const lines = [];
+  lines.push("/**");
+  if (nodeType.description) {
+    lines.push(...formatJSDocDescription(nodeType.description));
+    lines.push(` *`);
+  }
+  lines.push(" * @flowWeaver nodeType");
+  if (nodeType.expression) {
+    lines.push(" * @expression");
+  }
+  if (nodeType.name && nodeType.name !== nodeType.functionName) {
+    lines.push(` * @name ${nodeType.name}`);
+  }
+  if (nodeType.label) {
+    lines.push(` * @label ${nodeType.label}`);
+  }
+  if (nodeType.scope) {
+    lines.push(` * @scope ${nodeType.scope}`);
+  }
+  if (nodeType.defaultConfig?.pullExecution) {
+    lines.push(` * @pullExecution ${nodeType.defaultConfig.pullExecution.triggerPort}`);
+  }
+  if (nodeType.resilience) {
+    const retries = nodeType.resilience.retries ? ` retries=${nodeType.resilience.retries}` : "";
+    const fallback = nodeType.resilience.fallback ? ` fallback="${nodeType.resilience.fallback.replace(/"/g, '\\"')}"` : "";
+    lines.push(` * @resilience${retries}${fallback}`);
+  }
+  lines.push(...durableClassificationLines(nodeType));
+  if (nodeType.visuals) {
+    if (nodeType.visuals.color) {
+      lines.push(` * @color ${nodeType.visuals.color}`);
+    }
+    if (nodeType.visuals.icon) {
+      lines.push(` * @icon ${nodeType.visuals.icon}`);
+    }
+    if (nodeType.visuals.tags && nodeType.visuals.tags.length > 0) {
+      for (const tag of nodeType.visuals.tags) {
+        if (tag.tooltip) {
+          lines.push(` * @tag ${tag.label} "${tag.tooltip}"`);
+        } else {
+          lines.push(` * @tag ${tag.label}`);
+        }
+      }
+    }
+  }
+  let inputEntries = [];
+  let outputEntries = [];
+  if (nodeType.inputs && Object.keys(nodeType.inputs).length > 0) {
+    inputEntries = assignPortOrders(Object.entries(nodeType.inputs), "input");
+    outputEntries = assignPortOrders(Object.entries(nodeType.outputs || {}), "output");
+  } else if (nodeType.ports && nodeType.ports.length > 0) {
+    const inputs = [];
+    const outputs = [];
+    for (const port of nodeType.ports) {
+      if (isExecutePort(port.name) || isSuccessPort(port.name) || isFailurePort(port.name)) {
+        continue;
+      }
+      const portDef = {
+        dataType: port.type || port.dataType || "ANY",
+        label: port.defaultLabel || port.name,
+        scope: port.scope,
+        metadata: { order: port.defaultOrder }
+      };
+      if (port.direction === "INPUT") {
+        inputs.push([port.name, portDef]);
+      } else {
+        outputs.push([port.name, portDef]);
+      }
+    }
+    inputEntries = assignPortOrders(inputs, "input");
+    outputEntries = assignPortOrders(outputs, "output");
+  }
+  for (const { name, port, writeOrder } of planPortTags(inputEntries)) {
+    lines.push(` * ${generateJSDocPortTag(name, port, "input", void 0, { writeOrder })}`);
+  }
+  for (const { name, port, writeOrder } of planPortTags(outputEntries)) {
+    lines.push(` * ${generateJSDocPortTag(name, port, "output", void 0, { writeOrder })}`);
+  }
+  lines.push(" */");
+  return lines.join("\n");
+}
+function durableClassificationLines(nodeType) {
+  const lines = [];
+  if (nodeType.durableGate) {
+    lines.push(` * @durableGate ${nodeType.durableGate}`);
+  }
+  if (nodeType.durableEffect) {
+    lines.push(" * @durableEffect");
+  }
+  if (nodeType.durablePure) {
+    lines.push(" * @durablePure");
+  }
+  return lines;
+}
+
+// src/api/in-place/built-in-nodes.ts
+function inlineBuiltInNodes(source, ast, production) {
+  const usedNodeTypes = new Set(ast.instances.map((i) => i.nodeType));
+  const builtInNodes = ast.nodeTypes.filter(
+    (nt) => !nt.sourceLocation && nt.functionText && nt.helperText != null && usedNodeTypes.has(nt.name)
+  );
+  if (builtInNodes.length === 0) {
+    return { code: source, changed: false };
+  }
+  const workflowFnPattern = new RegExp(
+    `(/\\*\\*(?:(?!\\*/)[\\s\\S])*?@flowWeaver\\s+workflow(?:(?!\\*/)[\\s\\S])*?\\*/)\\s*\\n\\s*(?:export\\s+)?(?:async\\s+)?function\\s+${ast.functionName}\\b`
+  );
+  const match = source.match(workflowFnPattern);
+  if (!match || match.index === void 0) {
+    return { code: source, changed: false };
+  }
+  const insertionLines = [];
+  const emittedHelpers = /* @__PURE__ */ new Set();
+  for (const node of builtInNodes) {
+    const helperText = production ? node.helperTextProduction ?? null : node.helperText ?? null;
+    if (helperText && !emittedHelpers.has(helperText) && !source.includes(helperText)) {
+      emittedHelpers.add(helperText);
+      insertionLines.push(helperText);
+      insertionLines.push("");
+    }
+  }
+  for (const node of builtInNodes) {
+    const funcText = production && node.functionTextProduction != null ? node.functionTextProduction : node.functionText;
+    if (funcText) {
+      const portAnnotations = [];
+      portAnnotations.push("/**");
+      portAnnotations.push(` * @flowWeaver nodeType`);
+      portAnnotations.push(...durableClassificationLines(node));
+      for (const [name, port] of Object.entries(node.inputs)) {
+        if (name === "execute") continue;
+        const optPrefix = port.optional ? "[" : "";
+        const optSuffix = port.optional ? "]" : "";
+        portAnnotations.push(` * @input ${optPrefix}${name}${optSuffix} - ${port.label || name}`);
+      }
+      for (const [name, port] of Object.entries(node.outputs)) {
+        if (name === "onSuccess" || name === "onFailure") continue;
+        portAnnotations.push(` * @output ${name} - ${port.label || name}`);
+      }
+      portAnnotations.push(" */");
+      insertionLines.push(portAnnotations.join("\n"));
+      insertionLines.push(funcText);
+      insertionLines.push("");
+    }
+  }
+  const insertionCode = insertionLines.join("\n");
+  return {
+    code: source.slice(0, match.index) + insertionCode + "\n" + source.slice(match.index),
+    changed: true
+  };
+}
+
+// src/generator/control-flow-plan.ts
+function getPullExecutionConfig(instance, nodeType) {
+  if (instance.config?.pullExecution) {
+    const pullConfig = instance.config.pullExecution;
+    if (typeof pullConfig === "boolean") {
+      return { enabled: pullConfig, triggerPort: "execute" };
+    }
+    return {
+      enabled: true,
+      triggerPort: pullConfig.triggerPort || "execute"
+    };
+  }
+  if (nodeType.defaultConfig?.pullExecution) {
+    const pullConfig = nodeType.defaultConfig.pullExecution;
+    if (typeof pullConfig === "boolean") {
+      return { enabled: pullConfig, triggerPort: "execute" };
+    }
+    return {
+      enabled: true,
+      triggerPort: pullConfig.triggerPort || "execute"
+    };
+  }
+  return { enabled: false, triggerPort: "execute" };
+}
+function analyzeControlFlow(workflow, nodeTypes, isAsync, durableSequential) {
+  const cfg = buildControlFlowGraph(workflow, nodeTypes);
+  const executionOrder = performKahnsTopologicalSort(cfg);
+  const branchingNodes = findAllBranchingNodes(workflow, nodeTypes);
+  const branchRegions = findBranchRegions(workflow, branchingNodes);
+  const nodesInBranches = /* @__PURE__ */ new Set();
+  branchRegions.forEach((region) => {
+    region.successNodes.forEach((n) => nodesInBranches.add(n));
+    region.failureNodes.forEach((n) => nodesInBranches.add(n));
+  });
+  const pullExecutionNodes = /* @__PURE__ */ new Set();
+  workflow.instances.forEach((instance) => {
+    const nodeType = nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+    if (nodeType) {
+      const pullConfig = getPullExecutionConfig(instance, nodeType);
+      if (pullConfig.enabled) {
+        pullExecutionNodes.add(instance.id);
+      }
+    }
+  });
+  const nodeLevelScopedChildren = /* @__PURE__ */ new Set();
+  const perPortScopedChildren = /* @__PURE__ */ new Set();
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      perPortScopedChildren.add(instance.id);
+    } else if (instance.parent) {
+      nodeLevelScopedChildren.add(instance.id);
+    }
+  });
+  const conditionalNodes = /* @__PURE__ */ new Set([
+    ...nodesInBranches,
+    ...branchingNodes,
+    ...pullExecutionNodes,
+    ...nodeLevelScopedChildren
+  ]);
+  const letIndexNodes = workflow.instances.filter((instance) => !isPerPortScopedChild(instance, workflow, nodeTypes) && conditionalNodes.has(instance.id)).map((instance) => instance.id);
+  const topLevelSuccessFlags = /* @__PURE__ */ new Set();
+  branchRegions.forEach((region, nodeId) => {
+    if (region.successNodes.size > 0 || region.failureNodes.size > 0) {
+      topLevelSuccessFlags.add(toValidIdentifier(nodeId));
+    }
+  });
+  const promotedNodes = promoteNodesOutOfBranches(workflow, branchRegions);
+  const branchingNodesNeedingSuccessFlag = /* @__PURE__ */ new Set();
+  promotedNodes.forEach((promotedNodeId) => {
+    workflow.connections.forEach((conn) => {
+      if (conn.to.node === promotedNodeId && isExecutePort(conn.to.port)) {
+        const sourceNode = conn.from.node;
+        const sourcePort = conn.from.port;
+        if (branchingNodes.has(sourceNode) && (isSuccessPort(sourcePort) || isFailurePort(sourcePort))) {
+          branchingNodesNeedingSuccessFlag.add(sourceNode);
+        }
+      }
+    });
+  });
+  const branchingChains = durableSequential ? /* @__PURE__ */ new Map() : detectBranchingChains(branchingNodes, branchRegions);
+  const chainMembers = /* @__PURE__ */ new Set();
+  branchingChains.forEach((chain) => {
+    for (let i = 1; i < chain.length; i++) {
+      chainMembers.add(chain[i]);
+    }
+  });
+  const parallelGroupOf = /* @__PURE__ */ new Map();
+  if (isAsync && !durableSequential) {
+    const parallelLevels = computeParallelLevels(cfg, branchingNodes, perPortScopedChildren);
+    for (const group of parallelLevels) {
+      if (group.length < 2) continue;
+      const eligible = group.filter(
+        (id) => !conditionalNodes.has(id) && !promotedNodes.has(id) && !chainMembers.has(id)
+      );
+      if (eligible.length >= 2) {
+        for (const nodeId of eligible) {
+          parallelGroupOf.set(nodeId, eligible);
+        }
+      }
+    }
+  }
+  return {
+    executionOrder,
+    branchingNodes,
+    branchRegions,
+    conditionalNodes,
+    letIndexNodes,
+    perPortScopedChildren,
+    topLevelSuccessFlags,
+    promotedNodes,
+    branchingNodesNeedingSuccessFlag,
+    branchingChains,
+    chainMembers,
+    parallelGroupOf
+  };
+}
+function findBranchRegions(workflow, branchingNodes) {
+  const allInstanceIds = new Set(workflow.instances.map((i) => i.id));
+  const branchRegions = /* @__PURE__ */ new Map();
+  branchingNodes.forEach((branchInstanceId) => {
+    const successNodes = findNodesInBranch(
+      branchInstanceId,
+      RESERVED_PORT_NAMES.ON_SUCCESS,
+      workflow,
+      allInstanceIds,
+      branchingNodes
+    );
+    const failureNodes = findNodesInBranch(
+      branchInstanceId,
+      RESERVED_PORT_NAMES.ON_FAILURE,
+      workflow,
+      allInstanceIds,
+      branchingNodes
+    );
+    branchRegions.set(branchInstanceId, { successNodes, failureNodes });
+  });
+  return branchRegions;
+}
+function promoteNodesOutOfBranches(workflow, branchRegions) {
+  const instancesInMultipleBranches = /* @__PURE__ */ new Set();
+  workflow.instances.forEach(({ id: instanceId }) => {
+    let branchCount = 0;
+    branchRegions.forEach((region) => {
+      if (region.successNodes.has(instanceId) || region.failureNodes.has(instanceId)) {
+        branchCount++;
+      }
+    });
+    if (branchCount > 1) {
+      instancesInMultipleBranches.add(instanceId);
+    }
+  });
+  removeFromRegions(branchRegions, instancesInMultipleBranches);
+  const nodesInBothBranches = /* @__PURE__ */ new Set();
+  branchRegions.forEach((region) => {
+    region.successNodes.forEach((nodeId) => {
+      if (region.failureNodes.has(nodeId)) {
+        nodesInBothBranches.add(nodeId);
+      }
+    });
+  });
+  removeFromRegions(branchRegions, nodesInBothBranches);
+  const promotedNodes = new Set(nodesInBothBranches);
+  branchRegions.forEach((region, branchNodeId) => {
+    const allBranchNodes = /* @__PURE__ */ new Set([...region.successNodes, ...region.failureNodes]);
+    allBranchNodes.forEach((nodeId) => {
+      const hasExternalDataDep = workflow.connections.some((conn) => {
+        if (conn.to.node !== nodeId) return false;
+        if (conn.from.scope || conn.to.scope) return false;
+        const fromNode = conn.from.node;
+        if (fromNode === branchNodeId || isStartNode(fromNode)) return false;
+        if (isExecutePort(conn.to.port)) return false;
+        return !allBranchNodes.has(fromNode);
+      });
+      if (hasExternalDataDep) {
+        promotedNodes.add(nodeId);
+      }
+    });
+  });
+  removeFromRegions(branchRegions, promotedNodes);
+  return promotedNodes;
+}
+function removeFromRegions(branchRegions, nodeIds) {
+  branchRegions.forEach((region) => {
+    nodeIds.forEach((nodeId) => {
+      region.successNodes.delete(nodeId);
+      region.failureNodes.delete(nodeId);
+    });
+  });
+}
+
+// src/generator/exit-assembly.ts
+function emitExitAssembly(lines, workflow, nodeTypes, plan, isAsync, production) {
+  lines.push(`  ctx.checkAborted('${RESERVED_NODE_NAMES.EXIT}');`);
+  lines.push(`  const exitIdx = ctx.addExecution('${RESERVED_NODE_NAMES.EXIT}');`);
+  const returnProps = emitConnectedExitPorts(lines, workflow, nodeTypes, plan, isAsync, production);
+  emitUnconnectedExitPortDefaults(lines, workflow, returnProps);
+  lines.push("");
+  emitFinalResult(lines, returnProps, isAsync, production);
+}
+function emitConnectedExitPorts(lines, workflow, nodeTypes, plan, isAsync, production) {
+  const exitConnections = workflow.connections.filter((conn) => isExitNode(conn.to.node));
+  const exitConnectionsByPort = /* @__PURE__ */ new Map();
+  exitConnections.forEach((conn) => {
+    const existing = exitConnectionsByPort.get(conn.to.port) || [];
+    existing.push(conn);
+    exitConnectionsByPort.set(conn.to.port, existing);
+  });
+  const returnProps = [];
+  const setCall = isAsync ? "await ctx.setVariable" : "ctx.setVariable";
+  exitConnectionsByPort.forEach((conns, exitPort) => {
+    const exitPortDef = workflow.exitPorts[exitPort];
+    if (!exitPortDef) {
+      lines.push(`  // Exit connection skipped: '${exitPort}' is not a declared @returns port`);
+      return;
+    }
+    const varName = `exit_${exitPort}`;
+    const exitPortType = exitPortDef?.tsType || (exitPortDef ? mapToTypeScript(exitPortDef.dataType) : "unknown");
+    const validConns = conns.filter((conn) => {
+      const sourceNode = conn.from.node;
+      const sourceInstance = workflow.instances.find((i) => i.id === sourceNode);
+      const sourceNodeType = nodeTypes.find(
+        (n) => n.name === sourceInstance?.nodeType || n.functionName === sourceInstance?.nodeType
+      );
+      if (!isStartNode(sourceNode) && !sourceInstance) {
+        lines.push(`  // Exit connection skipped: source node '${sourceNode}' is not declared`);
+        return false;
+      }
+      if (!isStartNode(sourceNode) && sourceInstance && !sourceNodeType) {
+        lines.push(
+          `  // Exit connection skipped: source node '${sourceNode}' has missing type '${sourceInstance.nodeType}'`
+        );
+        return false;
+      }
+      return true;
+    });
+    if (validConns.length === 0) {
+      lines.push(`  const ${varName} = undefined as unknown;`);
+      returnProps.push(`${exitPort}: ${varName} as ${exitPortType}`);
+      return;
+    }
+    const isControlFlowPort = exitPort === "onSuccess" || exitPort === "onFailure";
+    const defaultValue = isControlFlowPort ? "false" : "undefined";
+    if (validConns.length === 1) {
+      lines.push(
+        `  const ${varName} = ${exitSourceExpression(validConns[0], defaultValue, workflow, nodeTypes, plan, isAsync)};`
+      );
+    } else {
+      const operator = isControlFlowPort ? " || " : " ?? ";
+      const parts = validConns.map(
+        (conn) => `(${exitSourceExpression(conn, defaultValue, workflow, nodeTypes, plan, isAsync)})`
+      );
+      lines.push(`  const ${varName} = ${parts.join(operator)};`);
+    }
+    if (!production) {
+      lines.push(
+        `  ${setCall}({ id: '${RESERVED_NODE_NAMES.EXIT}', portName: '${exitPort}', executionIndex: exitIdx, nodeTypeName: '${RESERVED_NODE_NAMES.EXIT}' }, ${varName});`
+      );
+    }
+    returnProps.push(`${exitPort}: ${varName} as ${exitPortType}`);
+  });
+  return returnProps;
+}
+function exitSourceExpression(conn, defaultValue, workflow, nodeTypes, plan, isAsync) {
+  const awaitKeyword = isAsync ? "await " : "";
+  const sourceNode = conn.from.node;
+  const sourcePort = conn.from.port;
+  const sourceIdx = isStartNode(sourceNode) ? "startIdx" : `${toValidIdentifier(sourceNode)}Idx`;
+  const sourceInstance = workflow.instances.find((i) => i.id === sourceNode);
+  const sourceNodeType = nodeTypes.find(
+    (n) => n.name === sourceInstance?.nodeType || n.functionName === sourceInstance?.nodeType
+  );
+  const sourceNodeTypeName = isStartNode(sourceNode) ? RESERVED_NODE_NAMES.START : sourceNodeType?.functionName ?? sourceInstance?.nodeType ?? sourceNode;
+  const pullConfig = sourceInstance && sourceNodeType ? getPullExecutionConfig(sourceInstance, sourceNodeType) : { enabled: false, triggerPort: "execute" };
+  const isPullNode = pullConfig.enabled;
+  const needsUndefinedCheck = !isStartNode(sourceNode) && plan.conditionalNodes.has(sourceNode);
+  if (isPullNode) {
+    return `${awaitKeyword}ctx.getVariable({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} ?? 0, nodeTypeName: '${sourceNodeTypeName}' })`;
+  } else if (needsUndefinedCheck) {
+    return `${sourceIdx} !== undefined ? ${awaitKeyword}ctx.getVariable({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}, nodeTypeName: '${sourceNodeTypeName}' }) : ${defaultValue}`;
+  } else {
+    return `${awaitKeyword}ctx.getVariable({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}, nodeTypeName: '${sourceNodeTypeName}' })`;
+  }
+}
+function emitUnconnectedExitPortDefaults(lines, workflow, returnProps) {
+  const connectedExitPorts = new Set(returnProps.map((prop) => prop.split(":")[0]));
+  Object.entries(workflow.exitPorts).forEach(([portName, portDef]) => {
+    if (!connectedExitPorts.has(portName) && portName !== "onSuccess" && portName !== "onFailure") {
+      const portType = portDef?.tsType || (portDef ? mapToTypeScript(portDef.dataType) : "unknown");
+      lines.push(`  // Exit port '${portName}' has no valid connection - using undefined`);
+      returnProps.push(`${portName}: undefined as unknown as ${portType}`);
+    }
+  });
+}
+function emitFinalResult(lines, returnProps, isAsync, production) {
+  const hasOnSuccess = returnProps.some((prop) => prop.startsWith("onSuccess:"));
+  const hasOnFailure = returnProps.some((prop) => prop.startsWith("onFailure:"));
+  const defaults = [];
+  const setCallForDefaults = isAsync ? "await ctx.setVariable" : "ctx.setVariable";
+  if (!hasOnSuccess) {
+    defaults.push("onSuccess: true");
+    if (!production) {
+      lines.push(
+        `  ${setCallForDefaults}({ id: '${RESERVED_NODE_NAMES.EXIT}', portName: 'onSuccess', executionIndex: exitIdx, nodeTypeName: '${RESERVED_NODE_NAMES.EXIT}' }, true);`
+      );
+    }
+  }
+  if (!hasOnFailure) {
+    defaults.push("onFailure: false");
+    if (!production) {
+      lines.push(
+        `  ${setCallForDefaults}({ id: '${RESERVED_NODE_NAMES.EXIT}', portName: 'onFailure', executionIndex: exitIdx, nodeTypeName: '${RESERVED_NODE_NAMES.EXIT}' }, false);`
+      );
+    }
+  }
+  const allPropsUnsorted = [...defaults, ...returnProps];
+  const onSuccessProp = allPropsUnsorted.find((p) => p.trimStart().startsWith("onSuccess"));
+  const onFailureProp = allPropsUnsorted.find((p) => p.trimStart().startsWith("onFailure"));
+  const dataProps = allPropsUnsorted.filter((p) => {
+    const key = p.trimStart().split(":")[0].trim();
+    return key !== "onSuccess" && key !== "onFailure";
+  });
+  const orderedProps = [];
+  if (onSuccessProp) orderedProps.push(onSuccessProp);
+  if (onFailureProp) orderedProps.push(onFailureProp);
+  orderedProps.push(...dataProps);
+  const allProps = orderedProps.join(", ");
+  const awaitPrefix = isAsync ? "await " : "";
+  lines.push(`  const finalResult = { ${allProps} };`);
+  lines.push("");
+  lines.push(`  ${awaitPrefix}ctx.sendStatusChangedEvent({`);
+  lines.push(`    nodeTypeName: '${RESERVED_NODE_NAMES.EXIT}',`);
+  lines.push(`    id: '${RESERVED_NODE_NAMES.EXIT}',`);
+  lines.push(`    executionIndex: exitIdx,`);
+  lines.push(`    status: 'SUCCEEDED',`);
+  lines.push(`  });`);
+  lines.push(`  ctx.sendWorkflowCompletedEvent({`);
+  lines.push(`    executionIndex: exitIdx,`);
+  lines.push(`    status: 'SUCCEEDED',`);
+  lines.push(`    result: finalResult,`);
+  lines.push(`  });`);
+  lines.push("");
+  lines.push(`  return finalResult;`);
+}
+
+// src/generator/unified.ts
+function startPortValue(portName, port) {
+  const supplied = `params.${portName}`;
+  if (port.default === void 0) return supplied;
+  return `${supplied} === undefined ? ${JSON.stringify(port.default)} : ${supplied}`;
+}
+function generateControlFlowWithExecutionContext(workflow, nodeTypes, isAsync, production = false, bundleMode = false, durableSequential = false, identity) {
+  const bodyAsync = isAsync || !production;
+  const lines = [];
+  emitContextSetup(lines, workflow, bodyAsync, production, identity);
+  emitStartNode(lines, workflow, bodyAsync);
+  const plan = analyzeControlFlow(workflow, nodeTypes, bodyAsync, durableSequential);
+  emitExecutionIndexDeclarations(lines, plan);
+  emitNodes({
+    workflow,
+    nodeTypes,
+    isAsync: bodyAsync,
+    production,
+    bundleMode,
+    plan,
+    lines,
+    generatedNodes: /* @__PURE__ */ new Set()
+  });
+  emitExitAssembly(lines, workflow, nodeTypes, plan, bodyAsync, production);
+  return lines.join("\n");
+}
+function emitContextSetup(lines, workflow, isAsync, production, identity) {
+  lines.push(`  // Recursion depth protection`);
+  lines.push(`  const __rd__ = (params as { __rd__?: number }).__rd__ ?? 0;`);
+  lines.push(`  if (__rd__ >= 1000) {`);
+  lines.push(`    throw new Error('Max recursion depth exceeded (1000) in workflow "${workflow.functionName}"');`);
+  lines.push(`  }`);
+  lines.push("");
+  const asyncArg = isAsync ? "true" : "false";
+  lines.push(`  const ctx = new GeneratedExecutionContext(${asyncArg}, __runtime__);`);
+  if (identity !== void 0) {
+    lines.push(`  ctx.bindWorkflow('${workflow.functionName}', '${identity.graphFingerprint}');`);
+  }
+  lines.push("");
+  if (!production) {
+    lines.push(
+      `  const __ctrl__: TDebugController = (__runtime__.services.debugController ?? { beforeNode: () => {}, afterNode: () => {} }) as TDebugController;`
+    );
+    lines.push("");
+  }
+}
+function emitStartNode(lines, workflow, isAsync) {
+  lines.push(`  const startIdx = ctx.addExecution('${RESERVED_NODE_NAMES.START}');`);
+  lines.push(`  if (ctx.shouldExecute('${RESERVED_NODE_NAMES.START}', '${RESERVED_NODE_NAMES.START}', startIdx)) {`);
+  const awaitPrefix = isAsync ? "await " : "";
+  Object.entries(extractStartPorts(workflow)).forEach(([portName, port]) => {
+    const setCall = isAsync ? `await ctx.setVariable` : `ctx.setVariable`;
+    const valueSource = isExecutePort(portName) ? "execute" : startPortValue(portName, port);
+    lines.push(
+      `    ${setCall}({ id: '${RESERVED_NODE_NAMES.START}', portName: '${portName}', executionIndex: startIdx, nodeTypeName: '${RESERVED_NODE_NAMES.START}' }, ${valueSource});`
+    );
+  });
+  lines.push(`    ${awaitPrefix}ctx.sendStatusChangedEvent({`);
+  lines.push(`      nodeTypeName: '${RESERVED_NODE_NAMES.START}',`);
+  lines.push(`      id: '${RESERVED_NODE_NAMES.START}',`);
+  lines.push(`      executionIndex: startIdx,`);
+  lines.push(`      status: 'SUCCEEDED',`);
+  lines.push(`    });`);
+  lines.push(`    ctx.commitNode('${RESERVED_NODE_NAMES.START}', '${RESERVED_NODE_NAMES.START}', startIdx);`);
+  lines.push(`  }`);
+  lines.push("");
+}
+function emitExecutionIndexDeclarations(lines, plan) {
+  plan.letIndexNodes.forEach((instanceId) => {
+    lines.push(`  let ${toValidIdentifier(instanceId)}Idx: number | undefined;`);
+  });
+  plan.topLevelSuccessFlags.forEach((safeId) => {
+    lines.push(`  let ${safeId}_success = false;`);
+  });
+  if (plan.letIndexNodes.length > 0 || plan.topLevelSuccessFlags.size > 0) {
+    lines.push("");
+  }
+  if (plan.parallelGroupOf.size > 0) {
+    plan.parallelGroupOf.forEach((_, instanceId) => {
+      if (!plan.conditionalNodes.has(instanceId)) {
+        lines.push(`  let ${toValidIdentifier(instanceId)}Idx: number | undefined;`);
+      }
+    });
+    lines.push("");
+  }
+}
+function emitNodes(body) {
+  const { workflow, nodeTypes, plan, lines, generatedNodes } = body;
+  for (const instanceId of plan.executionOrder) {
+    if (isStartNode(instanceId) || isExitNode(instanceId) || generatedNodes.has(instanceId)) {
+      continue;
+    }
+    const instance = workflow.instances.find((i) => i.id === instanceId);
+    if (!instance) {
+      lines.push(`  // Node '${instanceId}' skipped: instance not found in workflow`);
+      continue;
+    }
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      continue;
+    }
+    const nodeType = nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+    if (!nodeType) {
+      lines.push(`  // Node '${instance.id}' skipped: type '${instance.nodeType}' not found`);
+      continue;
+    }
+    const group = plan.parallelGroupOf.get(instanceId);
+    if (group && emitParallelGroup(body, group)) {
+      continue;
+    }
+    if (plan.branchingNodes.has(instanceId)) {
+      emitTopLevelBranchingNode(body, instance, nodeType);
+    } else {
+      emitTopLevelNode(body, instance, nodeType);
+    }
+  }
+}
+function emitParallelGroup(body, group) {
+  const { workflow, nodeTypes, isAsync, production, bundleMode, plan, lines, generatedNodes } = body;
+  const ungeneratedGroup = group.filter((id) => !generatedNodes.has(id));
+  if (ungeneratedGroup.length < 2) {
+    return false;
+  }
+  generateParallelGroupWithContext(
+    ungeneratedGroup,
+    workflow,
+    nodeTypes,
+    lines,
+    generatedNodes,
+    "  ",
+    isAsync,
+    "ctx",
+    bundleMode,
+    plan.branchingNodes,
+    production
+  );
+  for (const parallelNodeId of ungeneratedGroup) {
+    const inst = workflow.instances.find((i) => i.id === parallelNodeId);
+    if (!inst) continue;
+    const nt = nodeTypes.find((n) => n.name === inst.nodeType || n.functionName === inst.nodeType);
+    if (!nt) continue;
+    generateScopedChildrenExecution(
+      inst,
+      nt,
+      workflow,
+      nodeTypes,
+      generatedNodes,
+      lines,
+      "  ",
+      plan.branchingNodes,
+      plan.branchRegions,
+      isAsync,
+      bundleMode,
+      production
+    );
+  }
+  return true;
+}
+function promotedStepGuard(body, instanceId) {
+  const { workflow, plan } = body;
+  if (!plan.promotedNodes.has(instanceId)) {
+    return void 0;
+  }
+  const stepSourceConditions = [];
+  workflow.connections.forEach((conn) => {
+    if (conn.to.node === instanceId && isExecutePort(conn.to.port)) {
+      const src = conn.from.node;
+      if (!isStartNode(src)) {
+        stepSourceConditions.push(buildStepSourceCondition(src, conn.from.port, plan.branchingNodes));
+      }
+    }
+  });
+  return stepSourceConditions.length > 0 ? stepSourceConditions.join(" || ") : void 0;
+}
+function emitTopLevelBranchingNode(body, instance, nodeType) {
+  const { workflow, nodeTypes, isAsync, production, bundleMode, plan, lines, generatedNodes } = body;
+  const instanceId = instance.id;
+  if (plan.chainMembers.has(instanceId)) {
+    return;
+  }
+  const guard = promotedStepGuard(body, instanceId);
+  const indent = guard === void 0 ? "  " : "    ";
+  if (guard !== void 0) {
+    lines.push(`  if (${guard}) {`);
+  }
+  const chain = plan.branchingChains.get(instanceId);
+  if (chain) {
+    generateBranchingChainCode(
+      chain,
+      workflow,
+      nodeTypes,
+      plan.branchingNodes,
+      plan.branchRegions,
+      generatedNodes,
+      lines,
+      indent,
+      isAsync,
+      "ctx",
+      bundleMode,
+      plan.branchingNodesNeedingSuccessFlag,
+      production,
+      plan.topLevelSuccessFlags
+    );
+    if (guard !== void 0) {
+      lines.push(`  }`);
+    }
+    return;
+  }
+  const region = plan.branchRegions.get(instanceId);
+  generateBranchingNodeCode(
+    instance,
+    nodeType,
+    workflow,
+    nodeTypes,
+    region,
+    generatedNodes,
+    lines,
+    indent,
+    plan.branchingNodes,
+    plan.branchRegions,
+    isAsync,
+    "ctx",
+    bundleMode,
+    new Set(plan.topLevelSuccessFlags),
+    plan.branchingNodesNeedingSuccessFlag.has(instanceId) || plan.topLevelSuccessFlags.has(toValidIdentifier(instanceId)),
+    production
+  );
+  if (guard !== void 0) {
+    lines.push(`  }`);
+  }
+  region.successNodes.forEach((n) => generatedNodes.add(n));
+  region.failureNodes.forEach((n) => generatedNodes.add(n));
+  generateScopedChildrenExecution(
+    instance,
+    nodeType,
+    workflow,
+    nodeTypes,
+    generatedNodes,
+    lines,
+    "  ",
+    plan.branchingNodes,
+    plan.branchRegions,
+    isAsync,
+    bundleMode,
+    production
+  );
+}
+function emitTopLevelNode(body, instance, nodeType) {
+  const { workflow, nodeTypes, isAsync, production, bundleMode, plan, lines, generatedNodes } = body;
+  const instanceId = instance.id;
+  const belongsToBranch = Array.from(plan.branchRegions.values()).some(
+    (region) => region.successNodes.has(instanceId) || region.failureNodes.has(instanceId)
+  );
+  if (belongsToBranch) {
+    return;
+  }
+  const nodeUseConst = !plan.conditionalNodes.has(instanceId) && !plan.parallelGroupOf.has(instanceId);
+  generateNodeCallWithContext(
+    instance,
+    nodeType,
+    workflow,
+    lines,
+    nodeTypes,
+    "  ",
+    isAsync,
+    nodeUseConst,
+    void 0,
+    // instanceParent
+    "ctx",
+    // ctxVar
+    bundleMode,
+    false,
+    // skipExecuteGuard
+    plan.branchingNodes,
+    // for port-aware STEP guards
+    production
+  );
+  generatedNodes.add(instanceId);
+  generateScopedChildrenExecution(
+    instance,
+    nodeType,
+    workflow,
+    nodeTypes,
+    generatedNodes,
+    lines,
+    "  ",
+    plan.branchingNodes,
+    plan.branchRegions,
+    isAsync,
+    bundleMode,
+    production
+  );
+}
+function generateScopedChildrenExecution(parentInstance, parentNodeType, workflow, allNodeTypes, generatedNodes, lines, indent, branchingNodes, branchRegions, isAsync, bundleMode = false, production = false) {
+  if (!parentNodeType.scope) return;
+  const rawScopeName = parentNodeType.scope;
+  const hasPerPortScope = Object.values(parentNodeType.outputs).some((portDef) => portDef.scope === rawScopeName);
+  if (hasPerPortScope) {
+    return;
+  }
+  const scopeName = `${parentInstance.id}.${parentNodeType.scope}`;
+  const childrenInScope = [];
+  if (workflow.scopes && workflow.scopes[scopeName]) {
+    childrenInScope.push(...workflow.scopes[scopeName]);
+  }
+  workflow.instances.forEach((instance) => {
+    const parentScopeName = instance.parent ? `${instance.parent.id}.${instance.parent.scope}` : null;
+    if (parentScopeName === scopeName && !childrenInScope.includes(instance.id)) {
+      childrenInScope.push(instance.id);
+    }
+  });
+  if (childrenInScope.length === 0) return;
+  const safeParentId = toValidIdentifier(parentInstance.id);
+  lines.push(``);
+  lines.push(`${indent}// Create scope for children of ${parentInstance.id}`);
+  lines.push(
+    `${indent}const ${safeParentId}_scopedCtx = ctx.createScope('${parentInstance.id}', ${safeParentId}Idx, '${parentNodeType.scope}');`
+  );
+  lines.push(``);
+  const scopedCtxVar = `${safeParentId}_scopedCtx`;
+  childrenInScope.forEach((childInstanceId) => {
+    if (generatedNodes.has(childInstanceId)) return;
+    const childInstance = workflow.instances.find((i) => i.id === childInstanceId);
+    if (!childInstance) return;
+    const childNodeType = allNodeTypes.find(
+      (nt) => nt.name === childInstance.nodeType || nt.functionName === childInstance.nodeType
+    );
+    if (!childNodeType) return;
+    if (branchingNodes.has(childInstanceId)) {
+      generateBranchingNodeCode(
+        childInstance,
+        childNodeType,
+        workflow,
+        allNodeTypes,
+        branchRegions.get(childInstanceId),
+        generatedNodes,
+        lines,
+        indent,
+        branchingNodes,
+        branchRegions,
+        isAsync,
+        scopedCtxVar,
+        // Pass scoped context name
+        bundleMode,
+        /* @__PURE__ */ new Set(),
+        false,
+        production
+      );
+      const region = branchRegions.get(childInstanceId);
+      region.successNodes.forEach((n) => generatedNodes.add(n));
+      region.failureNodes.forEach((n) => generatedNodes.add(n));
+    } else {
+      generateNodeCallWithContext(
+        childInstance,
+        childNodeType,
+        workflow,
+        lines,
+        allNodeTypes,
+        indent,
+        isAsync,
+        false,
+        // useConst = false - scoped children need let (referenced outside scope block)
+        parentInstance.id,
+        // instanceParent - parent node is const, no ! needed when referencing it
+        scopedCtxVar,
+        // Pass scoped context name
+        bundleMode,
+        false,
+        // skipExecuteGuard
+        /* @__PURE__ */ new Set(),
+        // branchingNodes
+        production
+      );
+    }
+    generatedNodes.add(childInstanceId);
+  });
+  lines.push(``);
+  lines.push(`${indent}// Merge scope back into parent context`);
+  lines.push(`${indent}ctx.mergeScope(${parentInstance.id}_scopedCtx);`);
+  lines.push(``);
+}
+function generateParallelGroupWithContext(nodeIds, workflow, nodeTypes, lines, generatedNodes, indent, isAsync, ctxVar, bundleMode, branchingNodes, production = false) {
+  const parallelNodes = [];
+  for (const nodeId of nodeIds) {
+    const instance = workflow.instances.find((i) => i.id === nodeId);
+    if (!instance) continue;
+    const nodeType = nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+    if (!nodeType) continue;
+    parallelNodes.push({ id: nodeId, instance, nodeType });
+  }
+  if (parallelNodes.length < 2) {
+    for (const node of parallelNodes) {
+      generateNodeCallWithContext(
+        node.instance,
+        node.nodeType,
+        workflow,
+        lines,
+        nodeTypes,
+        indent,
+        isAsync,
+        false,
+        void 0,
+        ctxVar,
+        bundleMode,
+        false,
+        branchingNodes,
+        production
+      );
+      generatedNodes.add(node.id);
+    }
+    return;
+  }
+  const nodeBuffers = parallelNodes.map((node, index) => {
+    const parallelCtx = `${ctxVar}_parallel_${index}`;
+    const nodeLines = [];
+    generateNodeCallWithContext(
+      node.instance,
+      node.nodeType,
+      workflow,
+      nodeLines,
+      nodeTypes,
+      `${indent}    `,
+      isAsync,
+      false,
+      void 0,
+      parallelCtx,
+      bundleMode,
+      false,
+      branchingNodes,
+      production
+    );
+    lines.push(`${indent}const ${parallelCtx} = ${ctxVar}.forkParallel();`);
+    return { ...node, lines: nodeLines, parallelCtx };
+  });
+  lines.push(`${indent}await Promise.all([`);
+  for (let i = 0; i < nodeBuffers.length; i++) {
+    const buf = nodeBuffers[i];
+    const comma = i < nodeBuffers.length - 1 ? "," : "";
+    lines.push(`${indent}  (async () => {`);
+    for (const line of buf.lines) {
+      lines.push(line);
+    }
+    lines.push(`${indent}  })()${comma}`);
+    generatedNodes.add(buf.id);
+  }
+  lines.push(`${indent}]);`);
+  for (const buffer of nodeBuffers) {
+    lines.push(`${indent}${ctxVar}.mergeParallel(${buffer.parallelCtx});`);
+  }
+  lines.push("");
+}
+function sortBranchNodesTopologically(nodeIds, workflow) {
+  if (nodeIds.size === 0) {
+    return [];
+  }
+  const graph = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  nodeIds.forEach((id) => {
+    graph.set(id, []);
+    inDegree.set(id, 0);
+  });
+  workflow.connections.forEach((conn) => {
+    const fromNode = conn.from.node;
+    const toNode = conn.to.node;
+    if (nodeIds.has(fromNode) && nodeIds.has(toNode)) {
+      const successors = graph.get(fromNode) || [];
+      if (!successors.includes(toNode)) {
+        successors.push(toNode);
+        graph.set(fromNode, successors);
+        inDegree.set(toNode, (inDegree.get(toNode) || 0) + 1);
+      }
+    }
+  });
+  const result = [];
+  const queue = [];
+  inDegree.forEach((degree, node) => {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  });
+  while (queue.length > 0) {
+    const node = queue.shift();
+    result.push(node);
+    const successors = graph.get(node) || [];
+    successors.forEach((successor) => {
+      const newDegree = (inDegree.get(successor) || 0) - 1;
+      inDegree.set(successor, newDegree);
+      if (newDegree === 0) {
+        queue.push(successor);
+      }
+    });
+  }
+  if (result.length !== nodeIds.size) {
+    nodeIds.forEach((id) => {
+      if (!result.includes(id)) {
+        result.push(id);
+      }
+    });
+  }
+  return result;
+}
+function generateCancelledEventsForBranch(nodeIds, workflow, allNodeTypes, lines, indent, ctxVar = "ctx", isAsync = false) {
+  const awaitPrefix = isAsync ? "await " : "";
+  nodeIds.forEach((instanceId) => {
+    const instance = workflow.instances.find((i) => i.id === instanceId);
+    if (!instance) return;
+    const safeId = toValidIdentifier(instanceId);
+    lines.push(`${indent}const ${safeId}Idx = ${ctxVar}.addExecution('${instanceId}');`);
+    lines.push(
+      `${indent}${awaitPrefix}${ctxVar}.setVariable({ id: '${instanceId}', portName: 'onSuccess', executionIndex: ${safeId}Idx, nodeTypeName: '${instance.nodeType}' }, false);`
+    );
+    lines.push(
+      `${indent}${awaitPrefix}${ctxVar}.setVariable({ id: '${instanceId}', portName: 'onFailure', executionIndex: ${safeId}Idx, nodeTypeName: '${instance.nodeType}' }, false);`
+    );
+    lines.push(`${indent}${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+    lines.push(`${indent}  nodeTypeName: '${instance.nodeType}',`);
+    lines.push(`${indent}  id: '${instanceId}',`);
+    lines.push(`${indent}  executionIndex: ${safeId}Idx,`);
+    lines.push(`${indent}  status: 'CANCELLED',`);
+    lines.push(`${indent}});`);
+  });
+}
+function buildStepSourceCondition(sourceNode, sourcePort, branchingNodes) {
+  const safeNode = toValidIdentifier(sourceNode);
+  if (branchingNodes.has(sourceNode)) {
+    if (isSuccessPort(sourcePort)) {
+      return `${safeNode}_success`;
+    }
+    if (isFailurePort(sourcePort)) {
+      return `${safeNode}_success === false`;
+    }
+  }
+  return `${safeNode}Idx !== undefined`;
+}
+function generateBranchingChainCode(chain, workflow, nodeTypes, branchingNodes, branchRegions, generatedNodes, lines, indent, isAsync, ctxVar, bundleMode, forceTrackSuccessNodes = /* @__PURE__ */ new Set(), production = false, alreadyDeclaredFlags = /* @__PURE__ */ new Set()) {
+  const preDeclaredFlags = new Set(alreadyDeclaredFlags);
+  for (let i = 0; i < chain.length; i++) {
+    const isLast = i === chain.length - 1;
+    const safeId = toValidIdentifier(chain[i]);
+    if (!isLast || forceTrackSuccessNodes.has(chain[i]) || alreadyDeclaredFlags.has(safeId)) {
+      if (!alreadyDeclaredFlags.has(safeId)) {
+        lines.push(`${indent}let ${safeId}_success = false;`);
+      }
+      preDeclaredFlags.add(safeId);
+    }
+  }
+  if (chain.length > 1) {
+    lines.push("");
+  }
+  const guardParts = [];
+  for (let i = 0; i < chain.length; i++) {
+    const nodeId = chain[i];
+    const isLast = i === chain.length - 1;
+    const instance = workflow.instances.find((inst) => inst.id === nodeId);
+    if (!instance) continue;
+    const nodeType = nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+    if (!nodeType) continue;
+    const safeId = toValidIdentifier(nodeId);
+    const originalRegion = branchRegions.get(nodeId);
+    let effectiveRegion = originalRegion;
+    if (!isLast) {
+      const nextNodeId = chain[i + 1];
+      effectiveRegion = {
+        successNodes: new Set([...originalRegion.successNodes].filter((n) => n !== nextNodeId)),
+        failureNodes: new Set([...originalRegion.failureNodes].filter((n) => n !== nextNodeId))
+      };
+    }
+    const hasGuard = guardParts.length > 0;
+    const guardCondition = guardParts.join(" && ");
+    if (hasGuard) {
+      lines.push(`${indent}if (${guardCondition}) {`);
+    }
+    const nodeIndent = hasGuard ? indent + "  " : indent;
+    generateBranchingNodeCode(
+      instance,
+      nodeType,
+      workflow,
+      nodeTypes,
+      effectiveRegion,
+      generatedNodes,
+      lines,
+      nodeIndent,
+      branchingNodes,
+      branchRegions,
+      isAsync,
+      ctxVar,
+      bundleMode,
+      preDeclaredFlags,
+      !isLast || forceTrackSuccessNodes.has(chain[i]) || alreadyDeclaredFlags.has(safeId),
+      // forceTrackSuccess for non-last chain nodes, nodes with promoted dependents, or nodes with pre-declared flags
+      production
+    );
+    generateScopedChildrenExecution(
+      instance,
+      nodeType,
+      workflow,
+      nodeTypes,
+      generatedNodes,
+      lines,
+      nodeIndent,
+      branchingNodes,
+      branchRegions,
+      isAsync,
+      bundleMode,
+      production
+    );
+    if (hasGuard) {
+      lines.push(`${indent}} else {`);
+      const remainingNodes = /* @__PURE__ */ new Set();
+      for (let j = i; j < chain.length; j++) {
+        const chainNodeId = chain[j];
+        remainingNodes.add(chainNodeId);
+        const region = branchRegions.get(chainNodeId);
+        region.successNodes.forEach((n) => remainingNodes.add(n));
+        region.failureNodes.forEach((n) => remainingNodes.add(n));
+      }
+      generateCancelledEventsForBranch(remainingNodes, workflow, nodeTypes, lines, indent + "  ", ctxVar, isAsync);
+      lines.push(`${indent}}`);
+    }
+    if (!isLast) {
+      guardParts.push(`${safeId}_success`);
+    }
+    generatedNodes.add(nodeId);
+    effectiveRegion.successNodes.forEach((n) => generatedNodes.add(n));
+    effectiveRegion.failureNodes.forEach((n) => generatedNodes.add(n));
+  }
+}
+function generateBranchingNodeCode(instance, branchNode, workflow, allNodeTypes, region, generatedNodes, lines, indent, branchingNodes, branchRegions, isAsync, ctxVar = "ctx", bundleMode = false, preDeclaredSuccessFlags = /* @__PURE__ */ new Set(), forceTrackSuccess = false, production = false) {
+  const hasDownstream = region.successNodes.size > 0 || region.failureNodes.size > 0;
+  const branching = {
+    instance,
+    branchNode,
+    workflow,
+    allNodeTypes,
+    region,
+    generatedNodes,
+    lines,
+    indent,
+    branchingNodes,
+    branchRegions,
+    isAsync,
+    ctxVar,
+    bundleMode,
+    preDeclaredSuccessFlags,
+    // Track success flag when there are downstream nodes OR when chain code needs it
+    trackSuccess: hasDownstream || forceTrackSuccess,
+    production
+  };
+  emitBranchingNodeExecution(branching);
+  if (hasDownstream) {
+    emitBranchArms(branching);
+  }
+  generatedNodes.add(instance.id);
+}
+function emitBranchingNodeExecution(branching) {
+  const {
+    instance,
+    branchNode,
+    workflow,
+    allNodeTypes,
+    region,
+    lines,
+    isAsync,
+    ctxVar,
+    bundleMode,
+    preDeclaredSuccessFlags,
+    trackSuccess,
+    production
+  } = branching;
+  const instanceId = instance.id;
+  const safeId = toValidIdentifier(instanceId);
+  const functionName = branchNode.functionName;
+  const resultVar = nodeResultVar(safeId, functionName);
+  const emitDebugHooks = !production;
+  const outerIndent = branching.indent;
+  const indent = `${outerIndent}  `;
+  if (trackSuccess && !preDeclaredSuccessFlags.has(safeId)) {
+    lines.push(`${outerIndent}let ${safeId}_success = false;`);
+  }
+  if (emitDebugHooks) {
+    const awaitHook = isAsync ? "await " : "";
+    lines.push(`${outerIndent}${awaitHook}__ctrl__.beforeNode('${instanceId}', ${ctxVar});`);
+  }
+  const awaitPrefix = isAsync ? "await " : "";
+  if (!production) {
+    lines.push("");
+    lines.push(`${outerIndent}// \u2500\u2500 ${instanceId} (${functionName}) \u2500\u2500`);
+  }
+  lines.push(`${outerIndent}${ctxVar}.checkAborted('${instanceId}');`);
+  lines.push(`${outerIndent}${safeId}Idx = ${ctxVar}.addExecution('${instanceId}');`);
+  lines.push(`${outerIndent}if (${ctxVar}.shouldExecute('${instanceId}', '${functionName}', ${safeId}Idx)) {`);
+  lines.push(`${indent}${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}  nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}  id: '${instanceId}',`);
+  lines.push(`${indent}  executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}  status: 'RUNNING',`);
+  lines.push(`${indent}});`);
+  lines.push("");
+  if (trackSuccess) {
+    lines.push(`${indent}${safeId}_success = false;`);
+    lines.push("");
+  }
+  lines.push(`${indent}try {`);
+  const getCall = isAsync ? `await ${ctxVar}.getVariable` : `${ctxVar}.getVariable`;
+  const setCall = isAsync ? `await ${ctxVar}.setVariable` : `${ctxVar}.setVariable`;
+  const argNames = buildNodeArgumentsWithContext({
+    node: branchNode,
+    workflow,
+    id: instanceId,
+    lines,
+    indent: `${indent}  `,
+    getCall,
+    isAsync,
+    emitInputEvents: true,
+    setCall,
+    nodeTypeName: functionName,
+    bundleMode,
+    production,
+    abortSignalExpression: `${ctxVar}.getAbortSignal()`,
+    runtimeContextExpression: ctxVar
+  });
+  const awaitKeyword = branchNode.isAsync ? "await " : "";
+  emitNodeInvocation(
+    { nodeType: branchNode, instanceId, safeId, functionName, resultVar, args: argNames, ctxVar, indent: `${indent}  `, lines },
+    { setCall, isAsync, awaitKeyword, gateResultType: "any", inlineStubAndCoercion: false }
+  );
+  lines.push(`${indent}  ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}    nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}    id: '${instanceId}',`);
+  lines.push(`${indent}    executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}    status: 'SUCCEEDED',`);
+  lines.push(`${indent}  });`);
+  lines.push(`${indent}  ${ctxVar}.commitNode('${instanceId}', '${functionName}', ${safeId}Idx);`);
+  if (emitDebugHooks) {
+    const awaitHook = isAsync ? "await " : "";
+    lines.push(`${indent}  ${awaitHook}__ctrl__.afterNode('${instanceId}', ${ctxVar});`);
+  }
+  if (trackSuccess) {
+    lines.push(`${indent}  ${safeId}_success = ${branchNode.expression ? "true" : `${resultVar}.onSuccess`};`);
+  }
+  lines.push(`${indent}} catch (error: unknown) {`);
+  lines.push(`${indent}  if ((error as { code?: unknown })?.code === 'FLOW_WEAVER_DURABLE_GATE_YIELD') throw error;`);
+  lines.push(`${indent}  const isCancellation = CancellationError.isCancellationError(error);`);
+  lines.push(`${indent}  ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}    nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}    id: '${instanceId}',`);
+  lines.push(`${indent}    executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}    status: isCancellation ? 'CANCELLED' : 'FAILED',`);
+  lines.push(`${indent}  });`);
+  lines.push(`${indent}  if (!isCancellation) {`);
+  lines.push(`${indent}    ${ctxVar}.sendLogErrorEvent({`);
+  lines.push(`${indent}      nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}      id: '${instanceId}',`);
+  lines.push(`${indent}      executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}      error: error instanceof Error ? error.message : String(error),`);
+  lines.push(
+    `${indent}      code: typeof (error as { code?: unknown }).code === 'string' ? ((error as { code?: unknown }).code as string) : undefined,`
+  );
+  lines.push(`${indent}    });`);
+  lines.push(
+    `${indent}    ${setCall}({ id: '${instanceId}', portName: 'onSuccess', executionIndex: ${safeId}Idx, nodeTypeName: '${functionName}' }, false);`
+  );
+  lines.push(
+    `${indent}    ${setCall}({ id: '${instanceId}', portName: 'onFailure', executionIndex: ${safeId}Idx, nodeTypeName: '${functionName}' }, true);`
+  );
+  if (trackSuccess) {
+    lines.push(`${indent}    ${safeId}_success = false;`);
+  }
+  lines.push(`${indent}  }`);
+  if (region.successNodes.size > 0) {
+    generateCancelledEventsForBranch(
+      region.successNodes,
+      workflow,
+      allNodeTypes,
+      lines,
+      `${indent}  `,
+      ctxVar,
+      isAsync
+    );
+  }
+  if (region.failureNodes.size > 0) {
+    generateCancelledEventsForBranch(
+      region.failureNodes,
+      workflow,
+      allNodeTypes,
+      lines,
+      `${indent}  `,
+      ctxVar,
+      isAsync
+    );
+  }
+  lines.push(`${indent}  throw error;`);
+  lines.push(`${indent}}`);
+  lines.push(`${outerIndent}} else {`);
+  if (trackSuccess) {
+    const getPrefix = isAsync ? "await " : "";
+    lines.push(
+      `${outerIndent}  ${safeId}_success = ${getPrefix}${ctxVar}.getVariable({ id: '${instanceId}', portName: 'onSuccess', executionIndex: ${safeId}Idx, nodeTypeName: '${functionName}' }) as boolean;`
+    );
+  }
+  lines.push(`${outerIndent}}`);
+  lines.push("");
+}
+function emitBranchArms(branching) {
+  const { instance, workflow, allNodeTypes, region, lines, indent, isAsync, ctxVar } = branching;
+  const instanceId = instance.id;
+  const safeId = toValidIdentifier(instanceId);
+  const hasSuccessDownstream = region.successNodes.size > 0;
+  const hasFailureDownstream = region.failureNodes.size > 0;
+  lines.push(`${indent}if (${safeId}_success) {`);
+  lines.push(`${indent}  ${ctxVar}.enterBranch('${instanceId}', ${safeId}Idx, 'success');`);
+  if (hasFailureDownstream) {
+    generateCancelledEventsForBranch(region.failureNodes, workflow, allNodeTypes, lines, `${indent}  `, ctxVar, isAsync);
+  }
+  emitBranchArmBody(branching, region.successNodes);
+  if (hasFailureDownstream) {
+    lines.push(`${indent}  ${ctxVar}.exitBranch();`);
+    lines.push(`${indent}} else {`);
+    lines.push(`${indent}  ${ctxVar}.enterBranch('${instanceId}', ${safeId}Idx, 'failure');`);
+    if (hasSuccessDownstream) {
+      generateCancelledEventsForBranch(region.successNodes, workflow, allNodeTypes, lines, `${indent}  `, ctxVar, isAsync);
+    }
+    emitBranchArmBody(branching, region.failureNodes);
+    lines.push(`${indent}  ${ctxVar}.exitBranch();`);
+    lines.push(`${indent}}`);
+  } else if (hasSuccessDownstream) {
+    lines.push(`${indent}  ${ctxVar}.exitBranch();`);
+    lines.push(`${indent}} else {`);
+    lines.push(`${indent}  ${ctxVar}.enterBranch('${instanceId}', ${safeId}Idx, 'failure');`);
+    generateCancelledEventsForBranch(region.successNodes, workflow, allNodeTypes, lines, `${indent}  `, ctxVar, isAsync);
+    lines.push(`${indent}  ${ctxVar}.exitBranch();`);
+    lines.push(`${indent}}`);
+  } else {
+    lines.push(`${indent}  ${ctxVar}.exitBranch();`);
+    lines.push(`${indent}}`);
+  }
+}
+function emitBranchArmBody(branching, armNodes) {
+  const {
+    workflow,
+    allNodeTypes,
+    generatedNodes,
+    lines,
+    indent,
+    branchingNodes,
+    branchRegions,
+    isAsync,
+    ctxVar,
+    bundleMode,
+    preDeclaredSuccessFlags,
+    production
+  } = branching;
+  const armInstanceIds = sortBranchNodesTopologically(armNodes, workflow);
+  armInstanceIds.forEach((instanceId) => {
+    const inst = workflow.instances.find((i) => i.id === instanceId);
+    if (!inst) return;
+    const nodeType = allNodeTypes.find((nt) => nt.name === inst.nodeType || nt.functionName === inst.nodeType);
+    if (!nodeType) return;
+    if (branchingNodes.has(instanceId)) {
+      const nestedRegion = branchRegions.get(instanceId);
+      const nestedSafeId = toValidIdentifier(instanceId);
+      const nestedHasDownstream = nestedRegion.successNodes.size > 0 || nestedRegion.failureNodes.size > 0;
+      const nestedPreDeclared = new Set(preDeclaredSuccessFlags);
+      if (nestedHasDownstream && !nestedPreDeclared.has(nestedSafeId)) {
+        lines.push(`${indent}  let ${nestedSafeId}_success = false;`);
+        nestedPreDeclared.add(nestedSafeId);
+      }
+      generateBranchingNodeCode(
+        inst,
+        nodeType,
+        workflow,
+        allNodeTypes,
+        nestedRegion,
+        generatedNodes,
+        lines,
+        `${indent}  `,
+        branchingNodes,
+        branchRegions,
+        isAsync,
+        ctxVar,
+        bundleMode,
+        nestedPreDeclared,
+        nestedPreDeclared.has(nestedSafeId),
+        // force tracking if flag was pre-declared at higher scope
+        production
+      );
+    } else {
+      generateNodeCallWithContext(
+        inst,
+        nodeType,
+        workflow,
+        lines,
+        allNodeTypes,
+        `${indent}  `,
+        isAsync,
+        false,
+        // useConst
+        void 0,
+        // instanceParent
+        ctxVar,
+        bundleMode,
+        true,
+        // skipExecuteGuard — inside branch, execute is guaranteed by if/else
+        branchingNodes,
+        production
+      );
+      generatedNodes.add(instanceId);
+    }
+  });
+}
+function generatePullNodeWithContext(instance, nodeType, workflow, lines, indent, isAsync, ctxVar = "ctx", bundleMode = false, production = false) {
+  const instanceId = instance.id;
+  const safeId = toValidIdentifier(instanceId);
+  const functionName = nodeType.functionName;
+  const executorIsAsync = isAsync || nodeType.isAsync;
+  const asyncKeyword = executorIsAsync ? "async " : "";
+  const awaitKeyword = nodeType.isAsync ? "await " : "";
+  const awaitPrefix = executorIsAsync ? "await " : "";
+  lines.push(`${indent}// Pull execution node: ${instanceId}`);
+  lines.push(`${indent}const ${safeId}_executor = ${asyncKeyword}() => {`);
+  lines.push(`${indent}  if (${safeId}Idx !== undefined) {`);
+  lines.push(`${indent}    return; // Already executed`);
+  lines.push(`${indent}  }`);
+  lines.push(`${indent}  ${ctxVar}.checkAborted('${instanceId}');`);
+  lines.push(`${indent}  ${safeId}Idx = ${ctxVar}.addExecution('${instanceId}');`);
+  lines.push(`${indent}  if (!${ctxVar}.shouldExecute('${instanceId}', '${functionName}', ${safeId}Idx)) return;`);
+  lines.push(`${indent}  ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}    nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}    id: '${instanceId}',`);
+  lines.push(`${indent}    executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}    status: 'RUNNING',`);
+  lines.push(`${indent}  });`);
+  lines.push(`${indent}  try {`);
+  const getCall = executorIsAsync ? `await ${ctxVar}.getVariable` : `${ctxVar}.getVariable`;
+  const setCall = executorIsAsync ? `await ${ctxVar}.setVariable` : `${ctxVar}.setVariable`;
+  const args = buildNodeArgumentsWithContext({
+    node: nodeType,
+    workflow,
+    id: instanceId,
+    lines,
+    indent: `${indent}    `,
+    getCall,
+    isAsync: executorIsAsync,
+    emitInputEvents: true,
+    setCall,
+    nodeTypeName: functionName,
+    bundleMode,
+    production,
+    abortSignalExpression: `${ctxVar}.getAbortSignal()`,
+    runtimeContextExpression: ctxVar
+  });
+  const resultVar = nodeResultVar(safeId, functionName);
+  const call = { nodeType, instanceId, safeId, functionName, resultVar, args, ctxVar, indent: `${indent}    `, lines };
+  if (!emitDurableNodeCall(call, "any")) {
+    emitPlainNodeCall(call, executorIsAsync, awaitKeyword);
+  }
+  emitResultOutputs(call, setCall, (portName) => isSuccessPort(portName) || isFailurePort(portName));
+  lines.push(`${indent}    ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}      nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}      id: '${instanceId}',`);
+  lines.push(`${indent}      executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}      status: 'SUCCEEDED',`);
+  lines.push(`${indent}    });`);
+  lines.push(`${indent}    ${ctxVar}.commitNode('${instanceId}', '${functionName}', ${safeId}Idx);`);
+  lines.push(`${indent}  } catch (error: unknown) {`);
+  lines.push(`${indent}    if ((error as { code?: unknown })?.code === 'FLOW_WEAVER_DURABLE_GATE_YIELD') throw error;`);
+  lines.push(`${indent}    const isCancellation = CancellationError.isCancellationError(error);`);
+  lines.push(`${indent}    ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}      nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}      id: '${instanceId}',`);
+  lines.push(`${indent}      executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}      status: isCancellation ? 'CANCELLED' : 'FAILED',`);
+  lines.push(`${indent}    });`);
+  lines.push(`${indent}    if (!isCancellation) {`);
+  lines.push(`${indent}      ${ctxVar}.sendLogErrorEvent({`);
+  lines.push(`${indent}        nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}        id: '${instanceId}',`);
+  lines.push(`${indent}        executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}        error: error instanceof Error ? error.message : String(error),`);
+  lines.push(
+    `${indent}        code: typeof (error as { code?: unknown }).code === 'string' ? ((error as { code?: unknown }).code as string) : undefined,`
+  );
+  lines.push(`${indent}      });`);
+  lines.push(`${indent}    }`);
+  lines.push(`${indent}    throw error;`);
+  lines.push(`${indent}  }`);
+  lines.push(`${indent}};`);
+  lines.push(`${indent}// Register lazy executor for pull node`);
+  lines.push(`${indent}${ctxVar}.registerPullExecutor('${instanceId}', ${safeId}_executor);`);
+  lines.push(``);
+}
+function generateNodeCallWithContext(instance, nodeType, workflow, lines, _allNodeTypes, indent, isAsync, useConst = false, instanceParent, ctxVar = "ctx", bundleMode = false, skipExecuteGuard = false, branchingNodes = /* @__PURE__ */ new Set(), production = false) {
+  const instanceId = instance.id;
+  const safeId = toValidIdentifier(instanceId);
+  const functionName = nodeType.functionName;
+  const fullInstance = workflow.instances.find((i) => i.id === instanceId);
+  const pullConfig = fullInstance ? getPullExecutionConfig(fullInstance, nodeType) : { enabled: false, triggerPort: "execute" };
+  if (pullConfig.enabled) {
+    generatePullNodeWithContext(instance, nodeType, workflow, lines, indent, isAsync, ctxVar, bundleMode, production);
+    return;
+  }
+  const stepInputs = Object.entries(nodeType.inputs).filter(
+    ([portName, portConfig]) => {
+      if (isExecutePort(portName) && !useConst && !skipExecuteGuard) {
+        return portConfig.dataType === "STEP";
+      }
+      return portConfig.dataType === "STEP" && !isExecutePort(portName);
+    }
+  );
+  if (nodeType.expression && !useConst && !skipExecuteGuard && !stepInputs.some(([p]) => isExecutePort(p))) {
+    const hasExecuteConnection = workflow.connections.some(
+      (conn) => conn.to.node === instanceId && isExecutePort(conn.to.port)
+    );
+    if (hasExecuteConnection) {
+      stepInputs.push(["execute", { dataType: "STEP" }]);
+    }
+  }
+  const stepSignalSources = [];
+  if (stepInputs.length > 0) {
+    workflow.connections.forEach((conn) => {
+      const toNode = conn.to.node;
+      const toPort = conn.to.port;
+      if (toNode === instanceId && stepInputs.some(([port]) => port === toPort)) {
+        const sourceNode = conn.from.node;
+        const sourceInstance = workflow.instances.find((i) => i.id === sourceNode);
+        if (sourceInstance && isPerPortScopedChild(sourceInstance, workflow, _allNodeTypes)) {
+          return;
+        }
+        if (!isStartNode(sourceNode) && !stepSignalSources.includes(sourceNode)) {
+          stepSignalSources.push(sourceNode);
+        }
+      }
+    });
+  }
+  let shouldIndent = false;
+  if (stepSignalSources.length > 0) {
+    const conditions = [];
+    const portToSources = /* @__PURE__ */ new Map();
+    stepInputs.forEach(([portName]) => {
+      const sources = [];
+      workflow.connections.forEach((conn) => {
+        const toNode = conn.to.node;
+        const toPort = conn.to.port;
+        if (toNode === instanceId && toPort === portName) {
+          const sourceNode = conn.from.node;
+          if (!isStartNode(sourceNode)) {
+            const sourceInstance = workflow.instances.find((i) => i.id === sourceNode);
+            if (sourceInstance && isPerPortScopedChild(sourceInstance, workflow, _allNodeTypes)) {
+              return;
+            }
+            sources.push({ node: sourceNode, port: conn.from.port });
+          }
+        }
+      });
+      if (sources.length > 0) {
+        portToSources.set(portName, sources);
+      }
+    });
+    if (nodeType.executeWhen === EXECUTION_STRATEGIES.CONJUNCTION) {
+      portToSources.forEach((sources, _portName) => {
+        if (sources.length === 1) {
+          conditions.push(buildStepSourceCondition(sources[0].node, sources[0].port, branchingNodes));
+        } else {
+          const orCondition = sources.map((s) => buildStepSourceCondition(s.node, s.port, branchingNodes)).join(" || ");
+          conditions.push(`(${orCondition})`);
+        }
+      });
+      if (conditions.length > 0) {
+        const fullCondition = conditions.join(" && ");
+        lines.push(`${indent}if (${fullCondition}) {`);
+        indent = `${indent}  `;
+        shouldIndent = true;
+      }
+    } else if (nodeType.executeWhen === EXECUTION_STRATEGIES.DISJUNCTION) {
+      const allSources = [];
+      portToSources.forEach((sources) => {
+        sources.forEach((source) => {
+          if (!allSources.some((s) => s.node === source.node && s.port === source.port)) {
+            allSources.push(source);
+          }
+        });
+      });
+      if (allSources.length > 0) {
+        const fullCondition = allSources.map((s) => buildStepSourceCondition(s.node, s.port, branchingNodes)).join(" || ");
+        lines.push(`${indent}if (${fullCondition}) {`);
+        indent = `${indent}  `;
+        shouldIndent = true;
+      }
+    } else if (nodeType.executeWhen === EXECUTION_STRATEGIES.CUSTOM) {
+      const customCondition = nodeType.metadata?.customExecuteCondition;
+      if (customCondition && typeof customCondition === "string") {
+        lines.push(`${indent}if (${customCondition}) {`);
+        indent = `${indent}  `;
+        shouldIndent = true;
+      } else {
+        portToSources.forEach((sources, _portName) => {
+          if (sources.length === 1) {
+            conditions.push(buildStepSourceCondition(sources[0].node, sources[0].port, branchingNodes));
+          } else {
+            const orCondition = sources.map((s) => buildStepSourceCondition(s.node, s.port, branchingNodes)).join(" || ");
+            conditions.push(`(${orCondition})`);
+          }
+        });
+        if (conditions.length > 0) {
+          const fullCondition = conditions.join(" && ");
+          lines.push(`${indent}if (${fullCondition}) {`);
+          indent = `${indent}  `;
+          shouldIndent = true;
+        }
+      }
+    }
+  }
+  const emitDebugHooks = !production;
+  if (emitDebugHooks) {
+    const awaitHook = isAsync ? "await " : "";
+    lines.push(`${indent}${awaitHook}__ctrl__.beforeNode('${instanceId}', ${ctxVar});`);
+  }
+  const outerIndent = indent;
+  const varDecl = useConst ? "const " : "";
+  const awaitPrefix = isAsync ? "await " : "";
+  lines.push(`${indent}${ctxVar}.checkAborted('${instanceId}');`);
+  lines.push(`${indent}${varDecl}${safeId}Idx = ${ctxVar}.addExecution('${instanceId}');`);
+  lines.push(`${indent}if (${ctxVar}.shouldExecute('${instanceId}', '${functionName}', ${safeId}Idx)) {`);
+  indent = `${indent}  `;
+  lines.push(`${indent}${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}  nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}  id: '${instanceId}',`);
+  lines.push(`${indent}  executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}  status: 'RUNNING',`);
+  lines.push(`${indent}});`);
+  lines.push(`${indent}try {`);
+  const getCall = isAsync ? `await ${ctxVar}.getVariable` : `${ctxVar}.getVariable`;
+  const setCall = isAsync ? `await ${ctxVar}.setVariable` : `${ctxVar}.setVariable`;
+  const args = buildNodeArgumentsWithContext({
+    node: nodeType,
+    workflow,
+    id: instanceId,
+    lines,
+    indent: `${indent}  `,
+    getCall,
+    isAsync,
+    instanceParent,
+    emitInputEvents: true,
+    setCall,
+    nodeTypeName: functionName,
+    bundleMode,
+    production,
+    abortSignalExpression: `${ctxVar}.getAbortSignal()`
+  });
+  const resultVar = nodeResultVar(safeId, functionName);
+  const awaitKeyword = nodeType.isAsync ? "await " : "";
+  emitNodeInvocation(
+    { nodeType, instanceId, safeId, functionName, resultVar, args, ctxVar, indent: `${indent}  `, lines },
+    { setCall, isAsync, awaitKeyword, gateResultType: "Record<string, unknown>", inlineStubAndCoercion: true }
+  );
+  lines.push(`${indent}  ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}    nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}    id: '${instanceId}',`);
+  lines.push(`${indent}    executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}    status: 'SUCCEEDED',`);
+  lines.push(`${indent}  });`);
+  lines.push(`${indent}  ${ctxVar}.commitNode('${instanceId}', '${functionName}', ${safeId}Idx);`);
+  if (emitDebugHooks) {
+    const awaitHook = isAsync ? "await " : "";
+    lines.push(`${indent}  ${awaitHook}__ctrl__.afterNode('${instanceId}', ${ctxVar});`);
+  }
+  lines.push(`${indent}} catch (error: unknown) {`);
+  lines.push(`${indent}  if ((error as { code?: unknown })?.code === 'FLOW_WEAVER_DURABLE_GATE_YIELD') throw error;`);
+  lines.push(`${indent}  const isCancellation = CancellationError.isCancellationError(error);`);
+  lines.push(`${indent}  ${awaitPrefix}${ctxVar}.sendStatusChangedEvent({`);
+  lines.push(`${indent}    nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}    id: '${instanceId}',`);
+  lines.push(`${indent}    executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}    status: isCancellation ? 'CANCELLED' : 'FAILED',`);
+  lines.push(`${indent}  });`);
+  lines.push(`${indent}  if (!isCancellation) {`);
+  lines.push(`${indent}    ${ctxVar}.sendLogErrorEvent({`);
+  lines.push(`${indent}      nodeTypeName: '${functionName}',`);
+  lines.push(`${indent}      id: '${instanceId}',`);
+  lines.push(`${indent}      executionIndex: ${safeId}Idx,`);
+  lines.push(`${indent}      error: error instanceof Error ? error.message : String(error),`);
+  lines.push(
+    `${indent}      code: typeof (error as { code?: unknown }).code === 'string' ? ((error as { code?: unknown }).code as string) : undefined,`
+  );
+  lines.push(`${indent}    });`);
+  if (nodeType.expression) {
+    lines.push(
+      `${indent}    ${setCall}({ id: '${instanceId}', portName: 'onSuccess', executionIndex: ${safeId}Idx, nodeTypeName: '${functionName}' }, false);`
+    );
+    lines.push(
+      `${indent}    ${setCall}({ id: '${instanceId}', portName: 'onFailure', executionIndex: ${safeId}Idx, nodeTypeName: '${functionName}' }, true);`
+    );
+  }
+  lines.push(`${indent}  }`);
+  lines.push(`${indent}  throw error;`);
+  lines.push(`${indent}}`);
+  lines.push(`${outerIndent}}`);
+  if (shouldIndent) {
+    const originalIndent = outerIndent.slice(0, -2);
+    lines.push(`${originalIndent}}`);
+  }
+}
+
+// src/generator/body-generator.ts
+var BodyGenerator = class {
+  /**
+   * Generates a workflow function body that uses an execution context for
+   * tracing, error handling, and runtime state management.
+   *
+   * @param workflow - The workflow AST defining the graph structure.
+   * @param nodeTypes - The node type definitions referenced by the workflow.
+   * @param isAsync - Whether to generate async code. Defaults to true.
+   * @param production - If true, omits debug event emissions. Defaults to false.
+   * @param bundleMode - If true, generates code suitable for bundled deployment. Defaults to false.
+   * @param durableSequential - If true, the graph has a durable gate and runs strictly in order.
+   * @param identity - The graph identity a gated body declares to the engine before it runs.
+   * @returns The generated function body as a string.
+   */
+  generateWithExecutionContext(workflow, nodeTypes, isAsync = true, production = false, bundleMode = false, durableSequential = false, identity) {
+    return generateControlFlowWithExecutionContext(
+      workflow,
+      nodeTypes,
+      isAsync,
+      production,
+      bundleMode,
+      durableSequential,
+      identity
+    );
+  }
+  /**
+   * Generates a workflow function body using default settings (async, non-production, non-bundled).
+   * Convenience method that wraps {@link generateWithExecutionContext}.
+   *
+   * @param workflow - The workflow AST defining the graph structure.
+   * @param nodeTypes - The node type definitions referenced by the workflow.
+   * @returns The generated function body as a string.
+   */
+  generateDirectCode(workflow, nodeTypes) {
+    return generateControlFlowWithExecutionContext(workflow, nodeTypes, true, false, false, false);
+  }
+};
+var bodyGenerator = new BodyGenerator();
+
+// src/api/in-place/source-file.ts
+import * as ts from "typescript";
+function parseSource(source) {
+  return ts.createSourceFile("temp.ts", source, ts.ScriptTarget.Latest, true);
+}
+function findFunctionDeclaration(sourceFile, functionName) {
+  let functionNode;
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name?.text === functionName) {
+      functionNode = node;
+    }
+  });
+  return functionNode;
+}
+
+// src/api/in-place/function-body.ts
+function generateFunctionBody(ast, production, isAsync, durableSequential, identity) {
+  const lines = [];
+  lines.push("  // ============================================================================");
+  lines.push("  // DO NOT EDIT - This section is auto-generated by Flow Weaver");
+  lines.push("  // Edit the @flowWeaver annotations above to modify workflow behavior");
+  lines.push("  // ============================================================================");
+  lines.push("");
+  const body = bodyGenerator.generateWithExecutionContext(
+    ast,
+    ast.nodeTypes,
+    isAsync,
+    // Respect original function's async/sync nature
+    production,
+    false,
+    durableSequential,
+    identity
+  );
+  const indentedBody = body.split("\n").map((line) => line.trim() ? "  " + line : line).join("\n");
+  lines.push(indentedBody);
+  return lines.join("\n");
+}
+function replaceWorkflowFunctionBody(source, functionName, newBody) {
+  const functionNode = findFunctionDeclaration(parseSource(source), functionName);
+  if (!functionNode || !functionNode.body) {
+    return { code: source, changed: false };
+  }
+  const bodyText = source.slice(functionNode.body.pos, functionNode.body.end);
+  const bodyStartMarkerIdx = bodyText.indexOf(MARKERS.BODY_START);
+  const bodyEndMarkerIdx = bodyText.indexOf(MARKERS.BODY_END);
+  if (bodyStartMarkerIdx !== -1 && bodyEndMarkerIdx !== -1) {
+    const absoluteBodyStart = functionNode.body.pos + bodyStartMarkerIdx + MARKERS.BODY_START.length;
+    const absoluteBodyEnd = functionNode.body.pos + bodyEndMarkerIdx;
+    const before2 = source.slice(0, absoluteBodyStart);
+    const after2 = source.slice(absoluteBodyEnd);
+    const newCode = before2 + "\n" + newBody + "\n  " + after2;
+    const originalBody = source.slice(absoluteBodyStart, absoluteBodyEnd);
+    const changed = originalBody.trim() !== newBody.trim();
+    return { code: newCode, changed };
+  }
+  const openBraceIdx = source.indexOf("{", functionNode.body.pos);
+  if (openBraceIdx === -1) {
+    return { code: source, changed: false };
+  }
+  const closeBraceIdx = functionNode.body.end - 1;
+  if (closeBraceIdx <= openBraceIdx) {
+    return { code: source, changed: false };
+  }
+  const before = source.slice(0, openBraceIdx + 1);
+  const after = source.slice(closeBraceIdx);
+  const newBodyWithMarkers = [
+    "",
+    "  " + MARKERS.BODY_START,
+    newBody,
+    "  " + MARKERS.BODY_END,
+    ""
+  ].join("\n");
+  return {
+    code: before + newBodyWithMarkers + after,
+    changed: true
+  };
+}
+
+// src/api/in-place/fw-imports.ts
+function fwImportFunctionName(nodeType) {
+  if (nodeType.functionName === nodeType.name && nodeType.name.startsWith("npm/")) {
+    const parts = nodeType.name.split("/");
+    return parts[parts.length - 1];
+  }
+  return nodeType.functionName;
+}
+function ensureFwImportStatements(source, ast) {
+  const importNodeTypes = ast.nodeTypes.filter((nt) => nt.importSource);
+  const seen = /* @__PURE__ */ new Set();
+  const importLines = [];
+  for (const nt of importNodeTypes) {
+    const fnName = fwImportFunctionName(nt);
+    const key = JSON.stringify([fnName, nt.importSource]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    importLines.push(`import { ${fnName} } from '${nt.importSource}';`);
+  }
+  const block = [MARKERS.IMPORTS_START, ...importLines, MARKERS.IMPORTS_END].join("\n");
+  const startIdx = source.indexOf(MARKERS.IMPORTS_START);
+  const endIdx = source.indexOf(MARKERS.IMPORTS_END);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = source.slice(0, startIdx);
+    const after = source.slice(endIdx + MARKERS.IMPORTS_END.length);
+    const next2 = `${before}${block}${after}`;
+    return { code: next2, changed: next2 !== source };
+  }
+  if (importLines.length === 0) {
+    return { code: source, changed: false };
+  }
+  const next = `${block}
+${source}`;
+  return { code: next, changed: true };
+}
+
+// src/api/in-place/node-type-functions.ts
+import * as ts2 from "typescript";
+import * as path from "path";
+function syncNodeTypeFunctions(source, ast) {
+  let code = source;
+  let changed = false;
+  for (const nodeType of ast.nodeTypes) {
+    if (!isOwnedByFile(nodeType, ast.sourceFile)) {
+      continue;
+    }
+    const nodeTypeResult = replaceNodeTypeJSDoc(code, nodeType);
+    if (nodeTypeResult.changed) {
+      code = nodeTypeResult.code;
+      changed = true;
+    }
+  }
+  return { code, changed };
+}
+function isOwnedByFile(nodeType, workflowFile) {
+  if (nodeType.variant === "IMPORTED_WORKFLOW" || nodeType.variant === "WORKFLOW" || nodeType.variant === "MAP_ITERATOR") {
+    return false;
+  }
+  if (nodeType.sourceLocation?.file) {
+    const ntFile = nodeType.sourceLocation.file.replace(/\\/g, "/");
+    const astFile = workflowFile.replace(/\\/g, "/");
+    const ntBase = ntFile.split("/").filter(Boolean).pop() ?? "";
+    const astBase = astFile.split("/").filter(Boolean).pop() ?? "";
+    if (path.resolve(ntFile) !== path.resolve(astFile) && ntBase !== astBase) {
+      return false;
+    }
+  }
+  if (!nodeType.sourceLocation && nodeType.helperText != null) {
+    return false;
+  }
+  return true;
+}
+function nodeTypeFunctionText(nodeType) {
+  const nodeTypeWithCode = nodeType;
+  return nodeTypeWithCode.code || nodeType.functionText;
+}
+function renameFunctionInCode(code, newName) {
+  const codeSourceFile = parseSource(code);
+  let functionName;
+  let functionNameStart;
+  let functionNameEnd;
+  ts2.forEachChild(codeSourceFile, (node) => {
+    if (ts2.isFunctionDeclaration(node) && node.name) {
+      functionName = node.name.text;
+      functionNameStart = node.name.getStart();
+      functionNameEnd = node.name.getEnd();
+    }
+  });
+  if (!functionName || functionNameStart === void 0 || functionNameEnd === void 0) {
+    return code;
+  }
+  if (functionName === newName) {
+    return code;
+  }
+  const before = code.slice(0, functionNameStart);
+  const after = code.slice(functionNameEnd);
+  return before + newName + after;
+}
+function insertNodeTypeFunction(source, nodeType, functionCode) {
+  const sourceFile = parseSource(source);
+  const runtimeEndMarker = MARKERS.RUNTIME_END;
+  const runtimeEndPos = source.indexOf(runtimeEndMarker);
+  let insertPosition = -1;
+  if (runtimeEndPos !== -1) {
+    const afterMarker = source.indexOf("\n", runtimeEndPos);
+    insertPosition = afterMarker !== -1 ? afterMarker + 1 : runtimeEndPos + runtimeEndMarker.length;
+  } else {
+    let foundExportedFunction = false;
+    ts2.forEachChild(sourceFile, (node) => {
+      if (!foundExportedFunction && ts2.isFunctionDeclaration(node) && node.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword)) {
+        insertPosition = node.getFullStart();
+        foundExportedFunction = true;
+      }
+    });
+    if (insertPosition === -1) {
+      insertPosition = source.length;
+    }
+  }
+  const renamedCode = renameFunctionInCode(functionCode, nodeType.functionName);
+  const hasJSDoc = renamedCode.trim().startsWith("/**");
+  let finalCode = renamedCode;
+  if (!hasJSDoc) {
+    const jsdoc = generateNodeTypeJSDoc(nodeType);
+    finalCode = jsdoc + "\n" + renamedCode;
+  }
+  const before = source.slice(0, insertPosition);
+  const after = source.slice(insertPosition);
+  const needsLeadingNewline = before.length > 0 && !before.endsWith("\n\n");
+  const needsTrailingNewline = after.length > 0 && !after.startsWith("\n");
+  const newCode = before + (needsLeadingNewline ? "\n\n" : "") + finalCode + (needsTrailingNewline ? "\n\n" : "") + after;
+  return { code: newCode, changed: true };
+}
+function findFunctionByNameTag(source, sourceFile, targetName) {
+  let result;
+  ts2.forEachChild(sourceFile, (node) => {
+    if (ts2.isFunctionDeclaration(node) && node.name) {
+      const functionStart = node.getFullStart();
+      const leadingComments = ts2.getLeadingCommentRanges(source, functionStart);
+      if (leadingComments) {
+        for (const comment of leadingComments) {
+          if (comment.kind === ts2.SyntaxKind.MultiLineCommentTrivia) {
+            const commentText = source.slice(comment.pos, comment.end);
+            const nameMatch = commentText.match(/@name\s+(\S+)/);
+            if (nameMatch && nameMatch[1] === targetName) {
+              result = node;
+              return;
+            }
+          }
+        }
+      }
+    }
+  });
+  return result;
+}
+function replaceNodeTypeJSDoc(source, nodeType) {
+  const sourceFile = parseSource(source);
+  let needsRename = false;
+  let functionNode = findFunctionDeclaration(sourceFile, nodeType.functionName);
+  if (!functionNode && nodeType.name) {
+    functionNode = findFunctionByNameTag(source, sourceFile, nodeType.name);
+    if (functionNode && functionNode.name?.text !== nodeType.functionName) {
+      needsRename = true;
+    }
+  }
+  if (!functionNode && nodeType.name && nodeType.name !== nodeType.functionName) {
+    functionNode = findFunctionDeclaration(sourceFile, nodeType.name);
+    if (functionNode) {
+      needsRename = true;
+    }
+  }
+  if (!functionNode) {
+    const functionCode = nodeTypeFunctionText(nodeType);
+    if (functionCode) {
+      return insertNodeTypeFunction(source, nodeType, functionCode);
+    }
+    return { code: source, changed: false };
+  }
+  let result = source;
+  let hasChanges = false;
+  if (needsRename && functionNode.name) {
+    const nameStart = functionNode.name.getStart();
+    const nameEnd = functionNode.name.getEnd();
+    result = result.slice(0, nameStart) + nodeType.functionName + result.slice(nameEnd);
+    hasChanges = true;
+    const renamedNode = findFunctionDeclaration(parseSource(result), nodeType.functionName);
+    if (renamedNode) {
+      functionNode = renamedNode;
+    }
+  }
+  const functionStart = functionNode.getFullStart();
+  const leadingComments = ts2.getLeadingCommentRanges(result, functionStart);
+  if (!leadingComments || leadingComments.length === 0) {
+    return { code: result, changed: hasChanges };
+  }
+  const jsdocComments = [];
+  for (const c of leadingComments) {
+    if (c.kind === ts2.SyntaxKind.MultiLineCommentTrivia && result.slice(c.pos, c.pos + 3) === "/**") {
+      jsdocComments.push(c);
+    }
+  }
+  if (jsdocComments.length === 0) {
+    return { code: result, changed: hasChanges };
+  }
+  const jsdocComment = jsdocComments[jsdocComments.length - 1];
+  const staleDuplicates = [];
+  for (let i = 0; i < jsdocComments.length - 1; i++) {
+    const text = result.slice(jsdocComments[i].pos, jsdocComments[i].end);
+    if (text.includes("@flowWeaver")) {
+      staleDuplicates.push(jsdocComments[i]);
+    }
+  }
+  const newJSDoc = generateNodeTypeJSDoc(nodeType);
+  if (staleDuplicates.length > 0) {
+    for (let i = staleDuplicates.length - 1; i >= 0; i--) {
+      const dupe = staleDuplicates[i];
+      let removeEnd = dupe.end;
+      while (removeEnd < result.length && (result[removeEnd] === "\n" || result[removeEnd] === "\r")) {
+        removeEnd++;
+      }
+      result = result.slice(0, dupe.pos) + result.slice(removeEnd);
+      hasChanges = true;
+    }
+    const updatedFunctionNode = findFunctionDeclaration(parseSource(result), nodeType.functionName);
+    if (!updatedFunctionNode) {
+      return { code: result, changed: hasChanges };
+    }
+    const updatedStart = updatedFunctionNode.getFullStart();
+    const updatedComments = ts2.getLeadingCommentRanges(result, updatedStart);
+    if (!updatedComments) {
+      return { code: result, changed: hasChanges };
+    }
+    let updatedJsdoc;
+    for (const c of updatedComments) {
+      if (c.kind === ts2.SyntaxKind.MultiLineCommentTrivia && result.slice(c.pos, c.pos + 3) === "/**") {
+        updatedJsdoc = c;
+      }
+    }
+    if (!updatedJsdoc) {
+      return { code: result, changed: hasChanges };
+    }
+    return replaceJSDocContent(
+      result,
+      updatedJsdoc,
+      updatedFunctionNode,
+      nodeType,
+      newJSDoc,
+      hasChanges
+    );
+  }
+  return replaceJSDocContent(result, jsdocComment, functionNode, nodeType, newJSDoc, hasChanges);
+}
+function replaceJSDocContent(source, jsdocComment, functionNode, nodeType, newJSDoc, hasChanges) {
+  const originalJSDoc = source.slice(jsdocComment.pos, jsdocComment.end);
+  const jsdocChanged = originalJSDoc.trim() !== newJSDoc.trim();
+  const newFunctionText = nodeTypeFunctionText(nodeType);
+  let functionBodyChanged = false;
+  let newFunctionDeclaration = "";
+  if (newFunctionText) {
+    let strippedFunctionText = newFunctionText.trim();
+    while (strippedFunctionText.startsWith("/**")) {
+      strippedFunctionText = strippedFunctionText.replace(/^\/\*\*[\s\S]*?\*\/\s*/, "").trim();
+    }
+    newFunctionDeclaration = strippedFunctionText;
+    const currentFunctionDeclaration = source.slice(functionNode.getStart(), functionNode.getEnd()).trim();
+    const normalizedNew = newFunctionDeclaration.replace(/\s+/g, " ");
+    const normalizedCurrent = currentFunctionDeclaration.replace(/\s+/g, " ");
+    functionBodyChanged = normalizedNew !== normalizedCurrent;
+  }
+  if (!jsdocChanged && !functionBodyChanged) {
+    return { code: source, changed: hasChanges };
+  }
+  if (functionBodyChanged && newFunctionDeclaration) {
+    const before = source.slice(0, jsdocComment.pos);
+    const after = source.slice(functionNode.getEnd());
+    return {
+      code: before + newJSDoc + "\n" + newFunctionDeclaration + after,
+      changed: true
+    };
+  } else if (jsdocChanged) {
+    const before = source.slice(0, jsdocComment.pos);
+    const after = source.slice(jsdocComment.end);
+    return {
+      code: before + newJSDoc + after,
+      changed: true
+    };
+  }
+  return { code: source, changed: hasChanges };
+}
+
+// src/api/in-place/orphaned-node-types.ts
+import * as ts3 from "typescript";
+function removeOrphanedNodeTypeFunctions(source, ast, allWorkflows) {
+  const sourceFile = parseSource(source);
+  const validFunctionNames = new Set(ast.nodeTypes.map((nt) => nt.functionName));
+  if (allWorkflows) {
+    for (const workflow of allWorkflows) {
+      for (const nt of workflow.nodeTypes) {
+        validFunctionNames.add(nt.functionName);
+      }
+    }
+  }
+  const functionsToRemove = [];
+  ts3.forEachChild(sourceFile, (node) => {
+    if (ts3.isFunctionDeclaration(node) && node.name) {
+      const functionName = node.name.text;
+      const functionStart = node.getFullStart();
+      const leadingComments = ts3.getLeadingCommentRanges(source, functionStart);
+      if (!leadingComments) return;
+      let isNodeTypeFunction = false;
+      let jsdocStart = functionStart;
+      for (const comment of leadingComments) {
+        if (comment.kind === ts3.SyntaxKind.MultiLineCommentTrivia) {
+          const commentText = source.slice(comment.pos, comment.end);
+          if (commentText.includes("@flowWeaver nodeType")) {
+            isNodeTypeFunction = true;
+            jsdocStart = comment.pos;
+            break;
+          }
+        }
+      }
+      if (!isNodeTypeFunction) return;
+      if (!validFunctionNames.has(functionName)) {
+        const fullStart = jsdocStart;
+        const fullEnd = node.end;
+        let endPos = fullEnd;
+        while (endPos < source.length && (source[endPos] === "\n" || source[endPos] === "\r")) {
+          endPos++;
+        }
+        functionsToRemove.push({ start: fullStart, end: endPos });
+      }
+    }
+  });
+  if (functionsToRemove.length === 0) {
+    return { code: source, changed: false };
+  }
+  let result = source;
+  for (const { start, end } of functionsToRemove.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, start) + result.slice(end);
+  }
+  return { code: result, changed: true };
+}
+
+// src/api/in-place/runtime-section.ts
+import * as ts4 from "typescript";
+
+// src/api/inline-engine.generated.ts
+var INLINE_ENGINE_SOURCE = '// ---- src/runtime/continuation-core.ts ------------------------------------------\n\n/* The version of the engine that wrote a continuation: the package\'s own. */\nconst ENGINE_VERSION: string = VERSION;\nconst CONTINUATION_FORMAT_VERSION = 1 as const;\nconst GENERATOR_ABI = "flow-weaver-generated-v2" as const;\nconst MAX_CONTINUATION_BYTES = 1024 * 1024;\nconst MAX_CONTINUATION_DEPTH = 32;\nconst MAX_CONTINUATION_ENTRIES = 10_000;\nconst MAX_CONTINUATION_STRING_BYTES = 256 * 1024;\n\n/*\n * Who answers a gate: a person deciding, a system supplying data, an agent\n * doing a task, or the clock (`timer`: a `sleep` node, woken by whoever\n * keeps the run when its time has come).\n */\ntype DurableGateKind = "approval" | "input" | "agent" | "timer";\n\ntype WireValue =\n  | null\n  | boolean\n  | number\n  | string\n  | readonly WireValue[]\n  | { readonly [key: string]: WireValue };\n\ninterface WorkflowFrameAddress {\n  readonly workflowId: string;\n  readonly invocation: number;\n  readonly callerNodeId?: string;\n  readonly callerExecutionIndex?: number;\n}\n\ninterface ScopeAddress {\n  readonly parentNodeId: string;\n  readonly parentExecutionIndex: number;\n  readonly scopeName: string;\n  readonly invocation: number;\n  readonly loopIteration?: number;\n  readonly branchArm?: string;\n}\n\ninterface BranchAddress {\n  readonly workflowId: string;\n  readonly frameDepth: number;\n  readonly nodeId: string;\n  readonly executionIndex: number;\n  readonly arm: string;\n}\n\ninterface ExecutionAddress {\n  readonly frames: readonly WorkflowFrameAddress[];\n  readonly scopes: readonly ScopeAddress[];\n  readonly branches: readonly BranchAddress[];\n  readonly nodeId: string;\n  readonly nodeType: string;\n  readonly executionIndex: number;\n}\n\ninterface ContinuationVariable {\n  readonly address: ExecutionAddress;\n  readonly portName: string;\n  readonly value: WireValue;\n}\n\ninterface EffectReceipt {\n  readonly address: ExecutionAddress;\n  readonly operationKey: string;\n  readonly receipt: WireValue;\n}\n\ninterface ContinuationState {\n  readonly completed: readonly ExecutionAddress[];\n  readonly variables: readonly ContinuationVariable[];\n  readonly nextBoundary: ExecutionAddress;\n}\n\ninterface DurableGate {\n  readonly id: string;\n  readonly kind: DurableGateKind;\n  readonly address: ExecutionAddress;\n  readonly payload: WireValue;\n}\n\n/* The branch arms a node sits under, as the compiled graph describes them. */\ntype ContinuationGraphNodeBranchPath = readonly {\n  readonly nodeId: string;\n  readonly arm: string;\n}[];\n\ninterface ContinuationEnvelope {\n  readonly formatVersion: typeof CONTINUATION_FORMAT_VERSION;\n  readonly runId: string;\n  readonly gateId: string;\n  readonly gateKind: DurableGateKind;\n  readonly workflowId: string;\n  readonly bundleDigest: string;\n  readonly graphFingerprint: string;\n  readonly engineVersion: string;\n  readonly generatorAbi: string;\n  readonly location: ExecutionAddress;\n  readonly state: ContinuationState;\n  readonly receipts: readonly EffectReceipt[];\n  readonly createdAt: string;\n  readonly checksum: string;\n}\n\ndeclare const acceptedContinuationBrand: unique symbol;\ntype AcceptedContinuationEnvelope = ContinuationEnvelope & {\n  readonly [acceptedContinuationBrand]: true;\n};\n\ntype ContinuationRefusalReason =\n  | "malformed"\n  | "oversized"\n  | "unsupported-format"\n  | "incompatible-engine"\n  | "incompatible-generator"\n  | "wrong-workflow"\n  | "wrong-bundle"\n  | "wrong-graph"\n  | "checksum-mismatch"\n  | "stale-gate"\n  | "wrong-run"\n  | "ambiguous-effect";\n\ninterface ContinuationRefusal {\n  readonly accepted: false;\n  readonly reason: ContinuationRefusalReason;\n  readonly message: string;\n}\n\ninterface AcceptedContinuation {\n  readonly accepted: true;\n  readonly envelope: AcceptedContinuationEnvelope;\n}\n\ntype DecodedContinuation = AcceptedContinuation | ContinuationRefusal;\n\n/* What a resume must match before an envelope is trusted. */\ninterface ContinuationIdentity {\n  readonly runId: string;\n  readonly workflowId: string;\n  /* When given, the envelope must be the one this gate answer belongs to. */\n  readonly gateId?: string;\n}\n\nconst ENVELOPE_KEYS = [\n  "formatVersion",\n  "runId",\n  "gateId",\n  "gateKind",\n  "workflowId",\n  "bundleDigest",\n  "graphFingerprint",\n  "engineVersion",\n  "generatorAbi",\n  "location",\n  "state",\n  "receipts",\n  "createdAt",\n  "checksum",\n] as const;\n\nconst acceptedContinuations = new WeakSet<object>();\n\n// ---------------------------------------------------------------------------\n// Hashing. A compiled file has no `node:crypto`, and Web Crypto only hashes\n// asynchronously, while gate ids are needed synchronously in the middle of a\n// run. This is SHA-256 from the specification, over UTF-8 bytes.\n// ---------------------------------------------------------------------------\n\nfunction utf8BytesOf(text: string): number[] {\n  const bytes: number[] = [];\n  for (let index = 0; index < text.length; index++) {\n    let code = text.charCodeAt(index);\n    if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {\n      const low = text.charCodeAt(index + 1);\n      if (low >= 0xdc00 && low <= 0xdfff) {\n        code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);\n        index++;\n      }\n    }\n    // A lone surrogate is not encodable. Every UTF-8 encoder, Node\'s\n    // included, writes the replacement character for it.\n    if (code >= 0xd800 && code <= 0xdfff) code = 0xfffd;\n    if (code < 0x80) bytes.push(code);\n    else if (code < 0x800) bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));\n    else if (code < 0x10000) {\n      bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));\n    } else {\n      bytes.push(\n        0xf0 | (code >> 18),\n        0x80 | ((code >> 12) & 0x3f),\n        0x80 | ((code >> 6) & 0x3f),\n        0x80 | (code & 0x3f),\n      );\n    }\n  }\n  return bytes;\n}\n\nfunction utf8ByteLength(text: string): number {\n  return utf8BytesOf(text).length;\n}\n\nconst SHA256_K = [\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\n];\n\n/* The SHA-256 of a string\'s UTF-8 bytes, as lowercase hex. */\nfunction sha256Hex(text: string): string {\n  const bytes = utf8BytesOf(text);\n  const bitLength = bytes.length * 8;\n  bytes.push(0x80);\n  while (bytes.length % 64 !== 56) bytes.push(0);\n  // The length is a 64-bit big-endian integer. Strings this long never\n  // occur, so the high word is the floor of the division.\n  const high = Math.floor(bitLength / 0x100000000);\n  const low = bitLength >>> 0;\n  bytes.push(\n    (high >>> 24) & 0xff, (high >>> 16) & 0xff, (high >>> 8) & 0xff, high & 0xff,\n    (low >>> 24) & 0xff, (low >>> 16) & 0xff, (low >>> 8) & 0xff, low & 0xff,\n  );\n\n  const h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];\n  const w = new Array<number>(64);\n  const rotr = (value: number, bits: number): number => (value >>> bits) | (value << (32 - bits));\n\n  for (let offset = 0; offset < bytes.length; offset += 64) {\n    for (let i = 0; i < 16; i++) {\n      const j = offset + i * 4;\n      w[i] = ((bytes[j] << 24) | (bytes[j + 1] << 16) | (bytes[j + 2] << 8) | bytes[j + 3]) >>> 0;\n    }\n    for (let i = 16; i < 64; i++) {\n      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);\n      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);\n      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;\n    }\n    let [a, b, c, d, e, f, g, hh] = h;\n    for (let i = 0; i < 64; i++) {\n      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);\n      const ch = (e & f) ^ (~e & g);\n      const temp1 = (hh + S1 + ch + SHA256_K[i] + w[i]) >>> 0;\n      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);\n      const maj = (a & b) ^ (a & c) ^ (b & c);\n      const temp2 = (S0 + maj) >>> 0;\n      hh = g;\n      g = f;\n      f = e;\n      e = (d + temp1) >>> 0;\n      d = c;\n      c = b;\n      b = a;\n      a = (temp1 + temp2) >>> 0;\n    }\n    h[0] = (h[0] + a) >>> 0;\n    h[1] = (h[1] + b) >>> 0;\n    h[2] = (h[2] + c) >>> 0;\n    h[3] = (h[3] + d) >>> 0;\n    h[4] = (h[4] + e) >>> 0;\n    h[5] = (h[5] + f) >>> 0;\n    h[6] = (h[6] + g) >>> 0;\n    h[7] = (h[7] + hh) >>> 0;\n  }\n  return h.map((word) => word.toString(16).padStart(8, "0")).join("");\n}\n\n// ---------------------------------------------------------------------------\n// Wire values: what may cross a gate or live in a continuation.\n// ---------------------------------------------------------------------------\n\nclass WireValidationError extends Error {\n  constructor(\n    readonly reason: "malformed" | "oversized",\n    message: string,\n  ) {\n    super(message);\n    this.name = "WireValidationError";\n  }\n}\n\ninterface ValidationBudget {\n  entries: number;\n  bytes: number;\n  readonly seen: Set<object>;\n}\n\nconst ownKeyOf = (value: object, key: string): boolean => Object.prototype.hasOwnProperty.call(value, key);\n\nfunction assertWireValue(\n  value: unknown,\n  path: string,\n  depth: number,\n  budget: ValidationBudget,\n): asserts value is WireValue {\n  if (depth > MAX_CONTINUATION_DEPTH) {\n    throw new WireValidationError("oversized", `${path} exceeds maximum depth`);\n  }\n\n  budget.entries++;\n  if (budget.entries > MAX_CONTINUATION_ENTRIES) {\n    throw new WireValidationError("oversized", "continuation exceeds aggregate entry limit");\n  }\n\n  if (value === null || typeof value === "boolean") return;\n  if (typeof value === "number") {\n    if (!Number.isFinite(value)) {\n      throw new WireValidationError("malformed", `${path} contains a non-finite number`);\n    }\n    return;\n  }\n  if (typeof value === "string") {\n    const bytes = utf8ByteLength(value);\n    if (bytes > MAX_CONTINUATION_STRING_BYTES) {\n      throw new WireValidationError("oversized", `${path} exceeds maximum string size`);\n    }\n    budget.bytes += bytes;\n    if (budget.bytes > MAX_CONTINUATION_BYTES) {\n      throw new WireValidationError("oversized", "continuation exceeds maximum wire size");\n    }\n    return;\n  }\n  if (\n    value === undefined ||\n    typeof value === "bigint" ||\n    typeof value === "symbol" ||\n    typeof value === "function"\n  ) {\n    throw new WireValidationError("malformed", `${path} is not a plain wire value`);\n  }\n  // Everything that is not an object was returned or refused above. The cast\n  // is for a compiled file checked without strictNullChecks, where `unknown`\n  // does not narrow to `object` by exclusion.\n  const seen = value as object;\n  if (budget.seen.has(seen)) {\n    throw new WireValidationError("malformed", `${path} contains a cycle or repeated object`);\n  }\n  budget.seen.add(seen);\n\n  if (Array.isArray(value)) {\n    if (Object.getOwnPropertySymbols(value).length > 0) {\n      throw new WireValidationError("malformed", `${path} contains a symbol property`);\n    }\n    const descriptors = Object.getOwnPropertyDescriptors(value);\n    for (const [key, descriptor] of Object.entries(descriptors)) {\n      if (key === "length") continue;\n      if (!/^(0|[1-9]\\d*)$/.test(key) || descriptor.get || descriptor.set || !descriptor.enumerable) {\n        throw new WireValidationError("malformed", `${path} contains an accessor or property`);\n      }\n    }\n    for (let index = 0; index < value.length; index++) {\n      if (!ownKeyOf(descriptors, String(index))) {\n        throw new WireValidationError("malformed", `${path} contains a sparse array`);\n      }\n      assertWireValue(descriptors[String(index)].value, `${path}[${index}]`, depth + 1, budget);\n    }\n    budget.seen.delete(seen);\n    return;\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (prototype !== Object.prototype && prototype !== null) {\n    throw new WireValidationError("malformed", `${path} contains a class or host object`);\n  }\n  if (Object.getOwnPropertySymbols(value).length > 0) {\n    throw new WireValidationError("malformed", `${path} contains a symbol property`);\n  }\n  const descriptors = Object.getOwnPropertyDescriptors(value);\n  for (const [key, descriptor] of Object.entries(descriptors)) {\n    if (descriptor.get || descriptor.set || !descriptor.enumerable) {\n      throw new WireValidationError("malformed", `${path}.${key} is an accessor or non-enumerable property`);\n    }\n    const keyBytes = utf8ByteLength(key);\n    if (keyBytes > MAX_CONTINUATION_STRING_BYTES) {\n      throw new WireValidationError("oversized", `${path} contains an oversized key`);\n    }\n    budget.bytes += keyBytes;\n    assertWireValue(descriptor.value, `${path}.${key}`, depth + 1, budget);\n  }\n  budget.seen.delete(seen);\n}\n\nfunction validateWireValue(value: unknown): asserts value is WireValue {\n  assertWireValue(value, "$", 0, { entries: 0, bytes: 0, seen: new Set() });\n}\n\nfunction canonicalJson(value: WireValue): string {\n  if (value === null || typeof value === "boolean" || typeof value === "number") {\n    return JSON.stringify(value);\n  }\n  if (typeof value === "string") return JSON.stringify(value);\n  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;\n  const record = value as { readonly [key: string]: WireValue };\n  return `{${Object.keys(record)\n    .sort()\n    .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)\n    .join(",")}}`;\n}\n\nfunction canonicalWireValue(value: unknown): string {\n  validateWireValue(value);\n  return canonicalJson(value);\n}\n\nfunction cloneAndFreezeWireValue<T extends WireValue>(value: T): T {\n  const cloned = JSON.parse(canonicalJson(value)) as T;\n  const freeze = (entry: WireValue): void => {\n    if (typeof entry !== "object" || entry === null) return;\n    for (const child of Array.isArray(entry) ? entry : Object.values(entry)) {\n      freeze(child);\n    }\n    Object.freeze(entry);\n  };\n  freeze(cloned);\n  return cloned;\n}\n\n// ---------------------------------------------------------------------------\n// Identity: addresses, gate ids, operation keys, checksums.\n// ---------------------------------------------------------------------------\n\nfunction executionAddressKey(address: ExecutionAddress): string {\n  return canonicalWireValue(address);\n}\n\nfunction durableGateId(runId: string, kind: DurableGateKind, address: ExecutionAddress): string {\n  return sha256Hex(`${runId}\\0${kind}\\0${executionAddressKey(address)}`);\n}\n\nfunction operationKey(runId: string, address: ExecutionAddress): string {\n  validateWireValue(address);\n  return sha256Hex(`${runId}\\0${canonicalJson(address as unknown as WireValue)}`);\n}\n\nfunction withoutChecksum(envelope: ContinuationEnvelope): WireValue {\n  const { checksum: _checksum, ...unsigned } = envelope;\n  return unsigned as unknown as WireValue;\n}\n\nfunction continuationChecksum(envelope: ContinuationEnvelope): string {\n  validateWireValue(withoutChecksum(envelope));\n  return sha256Hex(canonicalJson(withoutChecksum(envelope)));\n}\n\nfunction createContinuationEnvelope(\n  fields: Omit<\n    ContinuationEnvelope,\n    "formatVersion" | "engineVersion" | "generatorAbi" | "createdAt" | "checksum"\n  > & {\n    readonly engineVersion?: string;\n    readonly generatorAbi?: string;\n    readonly createdAt?: string;\n  },\n): ContinuationEnvelope {\n  const unsigned = {\n    formatVersion: CONTINUATION_FORMAT_VERSION,\n    runId: fields.runId,\n    gateId: fields.gateId,\n    gateKind: fields.gateKind,\n    workflowId: fields.workflowId,\n    bundleDigest: fields.bundleDigest,\n    graphFingerprint: fields.graphFingerprint,\n    engineVersion: fields.engineVersion ?? VERSION,\n    generatorAbi: fields.generatorAbi ?? GENERATOR_ABI,\n    location: fields.location,\n    state: fields.state,\n    receipts: fields.receipts,\n    createdAt: fields.createdAt ?? new Date().toISOString(),\n  } satisfies Omit<ContinuationEnvelope, "checksum">;\n  validateWireValue(unsigned);\n  const envelope = Object.assign({}, unsigned, { checksum: "" }) as ContinuationEnvelope;\n  return { ...envelope, checksum: continuationChecksum(envelope) };\n}\n\n// ---------------------------------------------------------------------------\n// Structure: is this JSON shaped like an envelope at all?\n// ---------------------------------------------------------------------------\n\nfunction isPlainObjectRecord(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n}\n\nfunction hasExactlyTheKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {\n  const actual = Object.keys(value).sort();\n  const expected = [...keys].sort();\n  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);\n}\n\nfunction hasRequiredAndOptionalKeys(\n  value: Record<string, unknown>,\n  required: readonly string[],\n  optional: readonly string[] = [],\n): boolean {\n  const keys = Object.keys(value);\n  return (\n    required.every((key) => ownKeyOf(value, key)) &&\n    keys.every((key) => required.includes(key) || optional.includes(key))\n  );\n}\n\nfunction isNonNegativeInteger(value: unknown): value is number {\n  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;\n}\n\nfunction isFrameAddress(value: unknown): value is WorkflowFrameAddress {\n  return (\n    isPlainObjectRecord(value) &&\n    hasRequiredAndOptionalKeys(value, ["workflowId", "invocation"], ["callerNodeId", "callerExecutionIndex"]) &&\n    typeof value.workflowId === "string" &&\n    value.workflowId.length > 0 &&\n    isNonNegativeInteger(value.invocation) &&\n    (value.callerNodeId === undefined || typeof value.callerNodeId === "string") &&\n    (value.callerExecutionIndex === undefined || isNonNegativeInteger(value.callerExecutionIndex)) &&\n    ((value.callerNodeId === undefined && value.callerExecutionIndex === undefined) ||\n      (typeof value.callerNodeId === "string" && isNonNegativeInteger(value.callerExecutionIndex)))\n  );\n}\n\nfunction isScopeAddress(value: unknown): value is ScopeAddress {\n  return (\n    isPlainObjectRecord(value) &&\n    hasRequiredAndOptionalKeys(\n      value,\n      ["parentNodeId", "parentExecutionIndex", "scopeName", "invocation"],\n      ["loopIteration", "branchArm"],\n    ) &&\n    typeof value.parentNodeId === "string" &&\n    value.parentNodeId.length > 0 &&\n    isNonNegativeInteger(value.parentExecutionIndex) &&\n    typeof value.scopeName === "string" &&\n    value.scopeName.length > 0 &&\n    isNonNegativeInteger(value.invocation) &&\n    (value.loopIteration === undefined || isNonNegativeInteger(value.loopIteration)) &&\n    (value.branchArm === undefined || typeof value.branchArm === "string")\n  );\n}\n\nfunction isExecutionAddress(value: unknown): value is ExecutionAddress {\n  return (\n    isPlainObjectRecord(value) &&\n    hasExactlyTheKeys(value, ["frames", "scopes", "branches", "nodeId", "nodeType", "executionIndex"]) &&\n    Array.isArray(value.frames) &&\n    value.frames.length > 0 &&\n    value.frames.every(isFrameAddress) &&\n    Array.isArray(value.scopes) &&\n    value.scopes.every(isScopeAddress) &&\n    Array.isArray(value.branches) &&\n    value.branches.every(\n      (branch) =>\n        isPlainObjectRecord(branch) &&\n        hasExactlyTheKeys(branch, ["workflowId", "frameDepth", "nodeId", "executionIndex", "arm"]) &&\n        typeof branch.workflowId === "string" &&\n        branch.workflowId.length > 0 &&\n        isNonNegativeInteger(branch.frameDepth) &&\n        typeof branch.nodeId === "string" &&\n        branch.nodeId.length > 0 &&\n        isNonNegativeInteger(branch.executionIndex) &&\n        typeof branch.arm === "string" &&\n        branch.arm.length > 0,\n    ) &&\n    typeof value.nodeId === "string" &&\n    value.nodeId.length > 0 &&\n    typeof value.nodeType === "string" &&\n    value.nodeType.length > 0 &&\n    isNonNegativeInteger(value.executionIndex)\n  );\n}\n\nfunction isContinuationVariable(value: unknown): value is ContinuationVariable {\n  return (\n    isPlainObjectRecord(value) &&\n    hasExactlyTheKeys(value, ["address", "portName", "value"]) &&\n    isExecutionAddress(value.address) &&\n    typeof value.portName === "string" &&\n    value.portName.length > 0\n  );\n}\n\nfunction isEffectReceipt(value: unknown): value is EffectReceipt {\n  return (\n    isPlainObjectRecord(value) &&\n    hasExactlyTheKeys(value, ["address", "operationKey", "receipt"]) &&\n    isExecutionAddress(value.address) &&\n    typeof value.operationKey === "string" &&\n    /^[0-9a-f]{64}$/.test(value.operationKey)\n  );\n}\n\nfunction isContinuationState(value: unknown): value is ContinuationState {\n  return (\n    isPlainObjectRecord(value) &&\n    hasExactlyTheKeys(value, ["completed", "variables", "nextBoundary"]) &&\n    Array.isArray(value.completed) &&\n    value.completed.every(isExecutionAddress) &&\n    Array.isArray(value.variables) &&\n    value.variables.every(isContinuationVariable) &&\n    isExecutionAddress(value.nextBoundary)\n  );\n}\n\nfunction isExactIsoUtc(value: string): boolean {\n  const timestamp = Date.parse(value);\n  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;\n}\n\nfunction structurallyValidEnvelope(value: unknown): value is ContinuationEnvelope {\n  if (!isPlainObjectRecord(value) || !hasExactlyTheKeys(value, ENVELOPE_KEYS)) return false;\n  return !(\n    typeof value.formatVersion !== "number" ||\n    typeof value.runId !== "string" ||\n    typeof value.gateId !== "string" ||\n    !["approval", "input", "agent", "timer"].includes(value.gateKind as string) ||\n    typeof value.workflowId !== "string" ||\n    typeof value.bundleDigest !== "string" ||\n    typeof value.graphFingerprint !== "string" ||\n    typeof value.engineVersion !== "string" ||\n    typeof value.generatorAbi !== "string" ||\n    typeof value.createdAt !== "string" ||\n    typeof value.checksum !== "string" ||\n    value.runId.length === 0 ||\n    !/^[0-9a-f]{64}$/.test(value.gateId) ||\n    value.workflowId.length === 0 ||\n    value.engineVersion.length === 0 ||\n    value.generatorAbi.length === 0 ||\n    !isExecutionAddress(value.location) ||\n    !isContinuationState(value.state) ||\n    !Array.isArray(value.receipts) ||\n    !value.receipts.every(isEffectReceipt) ||\n    !/^sha256:[0-9a-f]{64}$/.test(value.bundleDigest) ||\n    !/^[0-9a-f]{64}$/.test(value.graphFingerprint) ||\n    !/^[0-9a-f]{64}$/.test(value.checksum) ||\n    !isExactIsoUtc(value.createdAt) ||\n    executionAddressKey(value.location) !== executionAddressKey(value.state.nextBoundary)\n  );\n}\n\n// ---------------------------------------------------------------------------\n// Acceptance: the checks a host can make without the compiled graph.\n// ---------------------------------------------------------------------------\n\n/*\n * Take an envelope back from wherever a host kept it. It is parsed when given\n * as text, checked for shape, checksum, gate identity, engine and generator\n * versions, and bound to the run and workflow it is about to resume. What is\n * accepted is a frozen copy; the input is never trusted afterwards.\n *\n * This is what the compiled file offers a host of its own. The coordinator\'s\n * `decodeContinuation` does this and, having the compiled graph, more.\n */\nfunction acceptContinuation(input: unknown, identity: ContinuationIdentity): DecodedContinuation {\n  let value: unknown = input;\n  if (typeof input === "string") {\n    if (utf8ByteLength(input) > MAX_CONTINUATION_BYTES) {\n      return { accepted: false, reason: "oversized", message: "continuation exceeds maximum wire size" };\n    }\n    try {\n      value = JSON.parse(input);\n    } catch {\n      return { accepted: false, reason: "malformed", message: "continuation is not valid JSON" };\n    }\n  }\n  try {\n    validateWireValue(value);\n  } catch (error) {\n    if (error instanceof WireValidationError) {\n      return { accepted: false, reason: error.reason, message: error.message };\n    }\n    return { accepted: false, reason: "malformed", message: "continuation is not a wire value" };\n  }\n  if (!structurallyValidEnvelope(value)) {\n    return { accepted: false, reason: "malformed", message: "continuation has missing, unknown, or invalid fields" };\n  }\n  if (value.formatVersion !== CONTINUATION_FORMAT_VERSION) {\n    return { accepted: false, reason: "unsupported-format", message: `unsupported continuation format ${value.formatVersion}` };\n  }\n  if (continuationChecksum(value) !== value.checksum) {\n    return { accepted: false, reason: "checksum-mismatch", message: "continuation checksum does not match" };\n  }\n  if (value.gateId !== durableGateId(value.runId, value.gateKind, value.location)) {\n    return { accepted: false, reason: "malformed", message: "continuation gate identity does not match its execution address" };\n  }\n  if (value.engineVersion !== VERSION) {\n    return { accepted: false, reason: "incompatible-engine", message: `continuation was written by engine ${value.engineVersion}, this is ${VERSION}` };\n  }\n  if (value.generatorAbi !== GENERATOR_ABI) {\n    return { accepted: false, reason: "incompatible-generator", message: "continuation generator ABI does not match" };\n  }\n  if (value.runId !== identity.runId) {\n    return { accepted: false, reason: "wrong-run", message: "continuation belongs to another run" };\n  }\n  if (value.workflowId !== identity.workflowId) {\n    return { accepted: false, reason: "wrong-workflow", message: "continuation belongs to another workflow" };\n  }\n  if (identity.gateId !== undefined && value.gateId !== identity.gateId) {\n    return { accepted: false, reason: "stale-gate", message: "continuation gate is stale or reordered" };\n  }\n  const accepted = cloneAndFreezeWireValue(value as unknown as WireValue) as unknown as AcceptedContinuationEnvelope;\n  acceptedContinuations.add(accepted);\n  return { accepted: true, envelope: accepted };\n}\n\nfunction assertAcceptedContinuation(\n  value: ContinuationEnvelope,\n): asserts value is AcceptedContinuationEnvelope {\n  if (!acceptedContinuations.has(value)) {\n    throw new Error("ContinuationEnvelope must come from a successful decodeContinuation or acceptContinuation result");\n  }\n}\n\n// ---- src/runtime/durable-execution.ts ------------------------------------------\n\ninterface GateResolution {\n  readonly gateId: string;\n  readonly value: WireValue;\n}\n\nfunction acceptGateResolution(resolution: GateResolution | undefined): GateResolution | undefined {\n  if (resolution === undefined) return undefined;\n  validateWireValue(resolution);\n  const keys = Object.keys(resolution).sort();\n  if (keys.length !== 2 || keys[0] !== \'gateId\' || keys[1] !== \'value\' || !/^[0-9a-f]{64}$/.test(resolution.gateId)) {\n    throw new Error(\'resolution must contain exactly a canonical gateId and wire value\');\n  }\n  return cloneAndFreezeWireValue(resolution as unknown as WireValue) as unknown as GateResolution;\n}\n\ntype EffectRecovery =\n  | { readonly kind: \'not-committed\' }\n  | {\n      readonly kind: \'committed\';\n      readonly receipt: WireValue;\n      readonly result: WireValue;\n    }\n  | { readonly kind: \'repeatable\' }\n  | { readonly kind: \'ambiguous\' };\n\ninterface EffectAdapter {\n  recover(operationKey: string, address: ExecutionAddress): Promise<EffectRecovery>;\n  /* Persist the exact successful effect result before it enters a continuation. */\n  commit?(\n    operationKey: string,\n    address: ExecutionAddress,\n    execution: EffectExecution<WireValue>,\n  ): Promise<void>;\n}\n\ninterface WorkflowRuntimeServices {\n  readonly debugger?: TDebugger;\n  readonly debugController?: DebugController;\n  readonly mocks?: FwMockConfig;\n  readonly workflowRegistry?: Readonly<Record<string, (...args: unknown[]) => unknown>>;\n  readonly effectAdapter?: EffectAdapter;\n}\n\n/*\n * The engine as a generated body sees it. It is an interface, not the class,\n * so a runtime built by the package and one built by a compiled file\'s own\n * copy of the engine are interchangeable to the type checker: two classes\n * with private members never are.\n */\ninterface DurableEngine {\n  address(\n    runtime: Pick<WorkflowRuntime, \'frames\' | \'scopes\' | \'branches\'>,\n    nodeId: string,\n    nodeType: string,\n    executionIndex: number,\n  ): ExecutionAddress;\n  /* Called once at the top of a root body: the workflow\'s name and graph identity. */\n  bind(runtime: Pick<WorkflowRuntime, \'frames\'>, workflowId: string, graphFingerprint: string): void;\n  shouldExecute(address: ExecutionAddress): boolean;\n  commitNode(address: ExecutionAddress): void;\n  setVariable(address: ExecutionAddress, portName: string, value: unknown): void;\n  getVariable(address: ExecutionAddress, portName: string, allowAncestorLookup?: boolean): unknown;\n  resolveGate(runtime: WorkflowRuntime, boundary: GateBoundary): WireValue;\n  executeEffect<T extends WireValue>(\n    runtime: WorkflowRuntime,\n    boundary: EffectBoundary,\n    execute: (operationKey: string) => Promise<EffectExecution<T>>,\n  ): Promise<T>;\n  assertResumeResolutionConsumed(): void;\n}\n\ninterface WorkflowRuntime {\n  readonly runId: string;\n  readonly abortSignal?: AbortSignal;\n  readonly services: WorkflowRuntimeServices;\n  readonly durable: DurableEngine;\n  readonly frames: readonly WorkflowFrameAddress[];\n  readonly scopes: readonly ScopeAddress[];\n  readonly branches: readonly BranchAddress[];\n}\n\ninterface NodeExecutionRuntime {\n  readonly nodeId: string;\n  readonly runtime: WorkflowRuntime;\n  readonly recursionDepth: number;\n  createNestedRuntime(workflowId: string): WorkflowRuntime;\n}\n\ninterface CreateWorkflowRuntimeOptions {\n  readonly runId: string;\n  readonly workflowId: string;\n  readonly abortSignal?: AbortSignal;\n  readonly services?: WorkflowRuntimeServices;\n  readonly continuation?: AcceptedContinuationEnvelope;\n  readonly resolution?: GateResolution;\n  /*\n   * The identity of the compiled artifact this run executes, `sha256:<hex>`.\n   * A coordinator that hashes the artifact passes it, and a continuation is\n   * refused on resume when it names another. Left out, the engine derives one\n   * from the workflow\'s own graph identity, so a host that keeps a\n   * continuation and brings it back to the same compiled file needs nothing\n   * more.\n   */\n  readonly bundleDigest?: string;\n}\n\ninterface GateBoundary {\n  readonly kind: DurableGateKind;\n  readonly nodeId: string;\n  readonly nodeType: string;\n  readonly executionIndex: number;\n  readonly payload: WireValue;\n}\n\n/*\n * A gate answered from the mocks, or undefined to yield for real.\n *\n * Any gate is answered by its node id through `gates`, with its data outputs\n * as the object. The built-in agent and event gates are also answered from\n * their own sections, keyed by what the node was given as its first input\n * (the agent id, the event name), by `node:key`, or by `node:*`. The answer\n * becomes the gate\'s whole output envelope, control ports filled in, which\n * is exactly what a person\'s answer becomes in `buildGateResolution`.\n */\nfunction mockedGateAnswer(mocks: FwMockConfig | undefined, boundary: GateBoundary): WireValue | undefined {\n  if (!mocks) return undefined;\n  const { nodeId, nodeType } = boundary;\n  const pick = (section: Record<string, object> | undefined, key: string | undefined): object | undefined => {\n    if (!section) return undefined;\n    if (key !== undefined && section[`${nodeId}:${key}`] !== undefined) return section[`${nodeId}:${key}`];\n    if (section[`${nodeId}:*`] !== undefined) return section[`${nodeId}:*`];\n    return key !== undefined ? section[key] : undefined;\n  };\n  const firstInput = (): string | undefined => {\n    const p = boundary.payload as { arguments?: Array<{ value?: unknown; absent?: boolean }> } | null;\n    const v = p?.arguments?.[0]?.value;\n    return v === undefined || v === null ? undefined : String(v);\n  };\n  let data: object | undefined = mocks.gates?.[nodeId];\n  if (data === undefined && nodeType === \'waitForAgent\') {\n    const v = pick(mocks.agents, firstInput());\n    if (v !== undefined) data = { agentResult: v };\n  }\n  if (data === undefined && nodeType === \'waitForEvent\') {\n    const v = pick(mocks.events, firstInput());\n    if (v !== undefined) data = { eventData: v };\n  }\n  // `fast` skips waits: a sleeping run wakes at once, as `delay` returns at once.\n  if (data === undefined && nodeType === \'sleep\' && mocks.fast === true) {\n    data = { wokeAt: new Date().toISOString() };\n  }\n  if (data === undefined || typeof data !== \'object\') return undefined;\n  const value = { onSuccess: true, onFailure: false, ...(data as Record<string, unknown>) };\n  validateWireValue(value);\n  return value as WireValue;\n}\n\ninterface EffectBoundary {\n  readonly nodeId: string;\n  readonly nodeType: string;\n  readonly executionIndex: number;\n}\n\ninterface EffectExecution<T extends WireValue> {\n  readonly result: T;\n  readonly receipt: WireValue;\n}\n\n/*\n * Thrown out of a generated body when a gate has to wait for the outside.\n * It carries everything a host needs to keep: the gate to answer, and the\n * continuation to bring back with the answer. `continuation` is present when\n * the body declared its identity (every body compiled by this version does);\n * a coordinator may also build its own from `state` and `receipts`.\n */\nclass DurableGateYield extends Error {\n  readonly code = \'FLOW_WEAVER_DURABLE_GATE_YIELD\';\n\n  constructor(\n    readonly gate: DurableGate,\n    readonly state: ContinuationState,\n    readonly receipts: readonly EffectReceipt[],\n    readonly continuation?: ContinuationEnvelope,\n  ) {\n    super(`Workflow yielded at ${gate.kind} gate "${gate.id}"`);\n    this.name = \'DurableGateYield\';\n  }\n}\n\nclass AmbiguousEffectError extends Error {\n  readonly code = \'FLOW_WEAVER_AMBIGUOUS_EFFECT\';\n\n  constructor(\n    readonly operationKey: string,\n    readonly address: ExecutionAddress,\n  ) {\n    super(`Effect "${operationKey}" has an ambiguous commit state`);\n    this.name = \'AmbiguousEffectError\';\n  }\n}\n\nfunction durableAddressKey(address: ExecutionAddress): string {\n  return executionAddressKey(address);\n}\n\nfunction durableVariableKey(address: ExecutionAddress, portName: string): string {\n  return `${executionAddressKey(address)}\\0${portName}`;\n}\n\nfunction cloneExecutionAddress(address: ExecutionAddress): ExecutionAddress {\n  return {\n    frames: address.frames.map((frame) => ({ ...frame })),\n    scopes: address.scopes.map((scope) => ({ ...scope })),\n    branches: address.branches.map((branch) => ({ ...branch })),\n    nodeId: address.nodeId,\n    nodeType: address.nodeType,\n    executionIndex: address.executionIndex,\n  };\n}\n\nfunction isCanonicalPrefix(candidate: readonly unknown[], current: readonly unknown[]): boolean {\n  return (\n    candidate.length <= current.length &&\n    canonicalWireValue(candidate) === canonicalWireValue(current.slice(0, candidate.length))\n  );\n}\n\nfunction isCanonicalEqual(left: readonly unknown[], right: readonly unknown[]): boolean {\n  return left.length === right.length && canonicalWireValue(left) === canonicalWireValue(right);\n}\n\nfunction requireEffectRecovery(value: unknown, key: string, address: ExecutionAddress): EffectRecovery {\n  try {\n    validateWireValue(value);\n  } catch {\n    throw new AmbiguousEffectError(key, address);\n  }\n  if (typeof value !== \'object\' || value === null || Array.isArray(value)) {\n    throw new AmbiguousEffectError(key, address);\n  }\n  const record = value as Record<string, unknown>;\n  const kind = record.kind;\n  if ((kind === \'not-committed\' || kind === \'repeatable\' || kind === \'ambiguous\') && Object.keys(record).length === 1) {\n    return { kind };\n  }\n  if (\n    kind === \'committed\' &&\n    Object.keys(record).length === 3 &&\n    Object.prototype.hasOwnProperty.call(record, \'receipt\') &&\n    Object.prototype.hasOwnProperty.call(record, \'result\')\n  ) {\n    return {\n      kind,\n      receipt: record.receipt as WireValue,\n      result: record.result as WireValue,\n    };\n  }\n  throw new AmbiguousEffectError(key, address);\n}\n\nfunction requireEffectExecution<T extends WireValue>(\n  value: unknown,\n  key: string,\n  address: ExecutionAddress,\n): EffectExecution<T> {\n  try {\n    validateWireValue(value);\n  } catch {\n    throw new AmbiguousEffectError(key, address);\n  }\n  if (typeof value !== \'object\' || value === null || Array.isArray(value)) {\n    throw new AmbiguousEffectError(key, address);\n  }\n  const record = value as Record<string, unknown>;\n  if (\n    Object.keys(record).length !== 2 ||\n    !Object.prototype.hasOwnProperty.call(record, \'result\') ||\n    !Object.prototype.hasOwnProperty.call(record, \'receipt\')\n  ) {\n    throw new AmbiguousEffectError(key, address);\n  }\n  return {\n    result: record.result as T,\n    receipt: record.receipt as WireValue,\n  };\n}\n\nclass DurableExecution implements DurableEngine {\n  private readonly completed = new Map<string, ExecutionAddress>();\n  private readonly variables = new Map<string, Omit<ContinuationVariable, \'value\'> & { readonly value: unknown }>();\n  private readonly receipts = new Map<string, EffectReceipt>();\n  private readonly resumeEnvelope?: ContinuationEnvelope;\n  private readonly resolution?: GateResolution;\n  private readonly givenBundleDigest?: string;\n  private graphFingerprint?: string;\n  private resolutionConsumed = false;\n\n  constructor(\n    readonly runId: string,\n    readonly workflowId: string,\n    continuation?: AcceptedContinuationEnvelope,\n    resolution?: GateResolution,\n    bundleDigest?: string,\n  ) {\n    if (continuation !== undefined) {\n      assertAcceptedContinuation(continuation);\n      if (continuation.runId !== runId) {\n        throw new Error(\'accepted continuation belongs to another run\');\n      }\n      if (continuation.workflowId !== workflowId) {\n        throw new Error(\'accepted continuation belongs to another workflow\');\n      }\n    }\n    if (bundleDigest !== undefined && !/^sha256:[0-9a-f]{64}$/.test(bundleDigest)) {\n      throw new Error(\'bundleDigest must use canonical sha256:<64hex> form\');\n    }\n    this.givenBundleDigest = bundleDigest;\n    this.resumeEnvelope = continuation;\n    this.resolution = acceptGateResolution(resolution);\n\n    for (const address of continuation?.state.completed ?? []) {\n      this.completed.set(durableAddressKey(address), cloneExecutionAddress(address));\n    }\n    for (const variable of continuation?.state.variables ?? []) {\n      this.variables.set(durableVariableKey(variable.address, variable.portName), {\n        address: cloneExecutionAddress(variable.address),\n        portName: variable.portName,\n        value: variable.value,\n      });\n    }\n    for (const receipt of continuation?.receipts ?? []) {\n      this.receipts.set(durableAddressKey(receipt.address), {\n        address: cloneExecutionAddress(receipt.address),\n        operationKey: receipt.operationKey,\n        receipt: receipt.receipt,\n      });\n    }\n  }\n\n  address(\n    runtime: Pick<WorkflowRuntime, \'frames\' | \'scopes\' | \'branches\'>,\n    nodeId: string,\n    nodeType: string,\n    executionIndex: number,\n  ): ExecutionAddress {\n    return {\n      frames: runtime.frames.map((frame) => ({ ...frame })),\n      scopes: runtime.scopes.map((scope) => ({ ...scope })),\n      branches: runtime.branches.map((branch) => ({ ...branch })),\n      nodeId,\n      nodeType,\n      executionIndex,\n    };\n  }\n\n  /*\n   * The artifact identity this run executes under: the one the coordinator\n   * gave, or one derived from the graph identity the body declared. Known\n   * only after `bind`.\n   */\n  bundleDigest(): string | undefined {\n    if (this.givenBundleDigest !== undefined) return this.givenBundleDigest;\n    if (this.graphFingerprint === undefined) return undefined;\n    return `sha256:${sha256Hex(`flow-weaver-inline\\0${this.workflowId}\\0${this.graphFingerprint}\\0${ENGINE_VERSION}`)}`;\n  }\n\n  bind(runtime: Pick<WorkflowRuntime, \'frames\'>, workflowId: string, graphFingerprint: string): void {\n    // Nested bodies (a workflow used as a node, `invokeWorkflow`) bind too;\n    // only the root frame names the run\'s graph.\n    if (runtime.frames.length !== 1) return;\n    if (workflowId !== this.workflowId) {\n      throw new Error(`runtime was created for workflow "${this.workflowId}" but "${workflowId}" is running on it`);\n    }\n    this.graphFingerprint = graphFingerprint;\n    if (this.resumeEnvelope === undefined) return;\n    if (this.resumeEnvelope.graphFingerprint !== graphFingerprint) {\n      const error = new Error(\'continuation belongs to another workflow graph\');\n      error.name = \'ContinuationMismatchError\';\n      throw error;\n    }\n    const bundleDigest = this.bundleDigest();\n    if (bundleDigest !== undefined && this.resumeEnvelope.bundleDigest !== bundleDigest) {\n      const error = new Error(\'continuation belongs to another bundle\');\n      error.name = \'ContinuationMismatchError\';\n      throw error;\n    }\n  }\n\n  shouldExecute(address: ExecutionAddress): boolean {\n    return !this.completed.has(durableAddressKey(address));\n  }\n\n  commitNode(address: ExecutionAddress): void {\n    this.completed.set(durableAddressKey(address), cloneExecutionAddress(address));\n  }\n\n  setVariable(address: ExecutionAddress, portName: string, value: unknown): void {\n    this.variables.set(durableVariableKey(address, portName), {\n      address: cloneExecutionAddress(address),\n      portName,\n      value,\n    });\n  }\n\n  getVariable(address: ExecutionAddress, portName: string, allowAncestorLookup = true): unknown {\n    const exact = this.variables.get(durableVariableKey(address, portName));\n    if (exact !== undefined) return exact.value;\n    if (!allowAncestorLookup) return undefined;\n\n    const candidates = [...this.variables.values()]\n      .filter(\n        (variable) =>\n          variable.portName === portName &&\n          variable.address.nodeId === address.nodeId &&\n          variable.address.nodeType === address.nodeType &&\n          variable.address.executionIndex === address.executionIndex &&\n          isCanonicalPrefix(variable.address.frames, address.frames) &&\n          isCanonicalPrefix(variable.address.scopes, address.scopes) &&\n          isCanonicalPrefix(variable.address.branches, address.branches),\n      )\n      .sort(\n        (left, right) =>\n          right.address.frames.length +\n          right.address.scopes.length +\n          right.address.branches.length -\n          (left.address.frames.length + left.address.scopes.length + left.address.branches.length),\n      );\n    const specificity = (candidate: (typeof candidates)[number]): number =>\n      candidate.address.frames.length + candidate.address.scopes.length + candidate.address.branches.length;\n    if (candidates.length > 1 && specificity(candidates[0]) === specificity(candidates[1])) {\n      throw new Error(`Ambiguous durable variable address for ${address.nodeId}.${portName}`);\n    }\n    if (candidates[0] !== undefined) return candidates[0].value;\n\n    // Generated workflows leave a selected control-flow branch before\n    // projecting its outputs through Exit. A fresh continuation resume has no\n    // process-local variable cache, so that projection must recover the one\n    // value committed by the branch that actually ran. This is deliberately\n    // narrower than ancestor lookup: it cannot cross workflow frames or\n    // scopes, and more than one compatible descendant fails closed.\n    const converged = [...this.variables.values()].filter(\n      (variable) =>\n        variable.portName === portName &&\n        variable.address.nodeId === address.nodeId &&\n        variable.address.nodeType === address.nodeType &&\n        variable.address.executionIndex === address.executionIndex &&\n        isCanonicalEqual(variable.address.frames, address.frames) &&\n        isCanonicalEqual(variable.address.scopes, address.scopes) &&\n        isCanonicalPrefix(address.branches, variable.address.branches),\n    );\n    if (converged.length > 1) {\n      throw new Error(`Ambiguous durable variable address for ${address.nodeId}.${portName}`);\n    }\n    return converged[0]?.value;\n  }\n\n  resolveGate(runtime: WorkflowRuntime, boundary: GateBoundary): WireValue {\n    validateWireValue(boundary.payload);\n    // A mocked gate is answered here, on the first run and on every replay\n    // alike, so it never pauses and never enters the resume bookkeeping below.\n    const mocked = mockedGateAnswer(runtime.services.mocks, boundary);\n    if (mocked !== undefined) return mocked;\n    const address = this.address(runtime, boundary.nodeId, boundary.nodeType, boundary.executionIndex);\n    const id = durableGateId(this.runId, boundary.kind, address);\n\n    if (this.resumeEnvelope !== undefined && !this.resolutionConsumed) {\n      if (\n        durableAddressKey(this.resumeEnvelope.location) !== durableAddressKey(address) ||\n        this.resumeEnvelope.gateId !== id ||\n        this.resumeEnvelope.gateKind !== boundary.kind ||\n        this.resolution === undefined ||\n        this.resolution.gateId !== id\n      ) {\n        const error = new Error(\'Gate resolution is stale, reordered, or does not match the resume boundary\');\n        error.name = \'StaleGateError\';\n        throw error;\n      }\n      validateWireValue(this.resolution.value);\n      this.resolutionConsumed = true;\n      return this.resolution.value;\n    }\n\n    if (this.resumeEnvelope !== undefined && durableAddressKey(this.resumeEnvelope.location) === durableAddressKey(address)) {\n      const error = new Error(\'The consumed resume gate was re-entered\');\n      error.name = \'StaleGateError\';\n      throw error;\n    }\n\n    const gate: DurableGate = {\n      id,\n      kind: boundary.kind,\n      address,\n      payload: boundary.payload,\n    };\n    const state = this.snapshot(address);\n    const receipts = [...this.receipts.values()];\n    const bundleDigest = this.bundleDigest();\n    const continuation =\n      this.graphFingerprint === undefined || bundleDigest === undefined\n        ? undefined\n        : createContinuationEnvelope({\n            runId: this.runId,\n            gateId: id,\n            gateKind: boundary.kind,\n            workflowId: this.workflowId,\n            bundleDigest,\n            graphFingerprint: this.graphFingerprint,\n            location: address,\n            state,\n            receipts,\n          });\n    throw new DurableGateYield(gate, state, receipts, continuation);\n  }\n\n  async executeEffect<T extends WireValue>(\n    runtime: WorkflowRuntime,\n    boundary: EffectBoundary,\n    execute: (operationKey: string) => Promise<EffectExecution<T>>,\n  ): Promise<T> {\n    const address = this.address(runtime, boundary.nodeId, boundary.nodeType, boundary.executionIndex);\n    const key = operationKey(this.runId, address);\n    const committed = this.receipts.get(durableAddressKey(address));\n    if (committed !== undefined) {\n      throw new Error(`Committed effect "${key}" reached its execution body`);\n    }\n\n    let recovery: EffectRecovery | undefined;\n    try {\n      recovery = await runtime.services.effectAdapter?.recover(key, address);\n    } catch {\n      throw new AmbiguousEffectError(key, address);\n    }\n    if (recovery === undefined) {\n      throw new AmbiguousEffectError(key, address);\n    }\n    recovery = requireEffectRecovery(recovery, key, address);\n    if (recovery.kind === \'ambiguous\') throw new AmbiguousEffectError(key, address);\n    if (recovery.kind === \'committed\') {\n      this.receipts.set(durableAddressKey(address), {\n        address: cloneExecutionAddress(address),\n        operationKey: key,\n        receipt: recovery.receipt,\n      });\n      return recovery.result as T;\n    }\n\n    let executed: EffectExecution<T>;\n    try {\n      executed = requireEffectExecution<T>(await execute(key), key, address);\n    } catch (error) {\n      let afterFailure: EffectRecovery;\n      try {\n        afterFailure =\n          (await runtime.services.effectAdapter?.recover(key, address)) ?? ({ kind: \'ambiguous\' } as const);\n      } catch {\n        throw new AmbiguousEffectError(key, address);\n      }\n      afterFailure = requireEffectRecovery(afterFailure, key, address);\n      if (afterFailure.kind === \'committed\') {\n        this.receipts.set(durableAddressKey(address), {\n          address: cloneExecutionAddress(address),\n          operationKey: key,\n          receipt: afterFailure.receipt,\n        });\n        return afterFailure.result as T;\n      }\n      if (afterFailure.kind === \'ambiguous\') {\n        throw new AmbiguousEffectError(key, address);\n      }\n      throw error;\n    }\n    if (runtime.services.effectAdapter?.commit !== undefined) {\n      try {\n        await runtime.services.effectAdapter.commit(key, address, executed);\n      } catch {\n        let committed: EffectRecovery;\n        try {\n          committed = requireEffectRecovery(\n            await runtime.services.effectAdapter.recover(key, address),\n            key,\n            address,\n          );\n        } catch {\n          throw new AmbiguousEffectError(key, address);\n        }\n        if (\n          committed.kind !== \'committed\' ||\n          canonicalWireValue(committed.receipt) !== canonicalWireValue(executed.receipt) ||\n          canonicalWireValue(committed.result) !== canonicalWireValue(executed.result)\n        ) throw new AmbiguousEffectError(key, address);\n        this.receipts.set(durableAddressKey(address), {\n          address: cloneExecutionAddress(address),\n          operationKey: key,\n          receipt: committed.receipt,\n        });\n        return committed.result as T;\n      }\n    }\n    this.receipts.set(durableAddressKey(address), {\n      address: cloneExecutionAddress(address),\n      operationKey: key,\n      receipt: executed.receipt,\n    });\n    return executed.result;\n  }\n\n  snapshot(nextBoundary: ExecutionAddress): ContinuationState {\n    const completedKeys = new Set(this.completed.keys());\n    return {\n      completed: [...this.completed.values()].map(cloneExecutionAddress),\n      variables: [...this.variables.values()]\n        .filter((variable) => completedKeys.has(durableAddressKey(variable.address)))\n        .map((variable) => {\n          try {\n            validateWireValue(variable.value);\n          } catch (error) {\n            throw new Error(\n              `Continuation variable ${variable.address.nodeId}.${variable.portName} is not a wire value: ${error instanceof Error ? error.message : String(error)}`,\n            );\n          }\n          return {\n            address: cloneExecutionAddress(variable.address),\n            portName: variable.portName,\n            value: variable.value,\n          };\n        }),\n      nextBoundary: cloneExecutionAddress(nextBoundary),\n    };\n  }\n\n  assertResumeResolutionConsumed(): void {\n    if (this.resumeEnvelope !== undefined && !this.resolutionConsumed) {\n      const error = new Error(\'Resumed execution completed or yielded without consuming its exact gate resolution\');\n      error.name = \'UnconsumedGateResolutionError\';\n      throw error;\n    }\n  }\n}\n\nfunction createWorkflowRuntime(options: CreateWorkflowRuntimeOptions): WorkflowRuntime {\n  if (options.runId.trim().length === 0) {\n    throw new Error(\'runId must be a non-empty coordinator-owned identity\');\n  }\n  const rootFrame: WorkflowFrameAddress = {\n    workflowId: options.workflowId,\n    invocation: 0,\n  };\n  return {\n    runId: options.runId,\n    abortSignal: options.abortSignal,\n    services: options.services ?? {},\n    durable: new DurableExecution(\n      options.runId,\n      options.workflowId,\n      options.continuation,\n      options.resolution,\n      options.bundleDigest,\n    ),\n    frames: [rootFrame],\n    scopes: [],\n    branches: [],\n  };\n}\n\nfunction createNestedWorkflowRuntime(\n  runtime: WorkflowRuntime,\n  workflowId: string,\n  callerNodeId: string,\n  callerExecutionIndex: number,\n  invocation: number,\n): WorkflowRuntime {\n  return {\n    ...runtime,\n    frames: [\n      ...runtime.frames,\n      {\n        workflowId,\n        invocation,\n        callerNodeId,\n        callerExecutionIndex,\n      },\n    ],\n    scopes: runtime.scopes,\n    branches: runtime.branches,\n  };\n}\n\nfunction createScopedWorkflowRuntime(runtime: WorkflowRuntime, scope: ScopeAddress): WorkflowRuntime {\n  return {\n    ...runtime,\n    scopes: [...runtime.scopes, scope],\n    branches: runtime.branches,\n  };\n}\n\nfunction isDurableGateYield(error: unknown): error is DurableGateYield {\n  return (\n    error instanceof DurableGateYield ||\n    (typeof error === \'object\' &&\n      error !== null &&\n      (error as { code?: unknown }).code === \'FLOW_WEAVER_DURABLE_GATE_YIELD\')\n  );\n}\n\nfunction isAmbiguousEffectError(error: unknown): error is AmbiguousEffectError {\n  return (\n    error instanceof AmbiguousEffectError ||\n    (typeof error === \'object\' &&\n      error !== null &&\n      (error as { code?: unknown }).code === \'FLOW_WEAVER_AMBIGUOUS_EFFECT\')\n  );\n}\n';
+var INLINE_EXECUTION_CONTEXT_SOURCE = "// ---- src/runtime/ExecutionContext.ts -------------------------------------------\n\n/*\n * Address of a variable in the execution context. Variables are stored under\n * the key `id:portName:executionIndex`.\n */\ninterface VariableAddress {\n  id: string;\n  portName: string;\n  executionIndex: number;\n  nodeTypeName?: string | undefined;\n  scope?: string | undefined;\n  side?: 'start' | 'exit' | undefined;\n  /* Inputs remain live/debug-visible but are never serialized as durable outputs. */\n  durable?: boolean | undefined;\n}\n\ninterface ExecutionInfo {\n  id: string;\n  index: number;\n  parentIndex?: number | undefined;\n  scopeName?: string | undefined;\n}\n\ntype VariableValue = unknown | (() => unknown) | (() => Promise<unknown>);\n\n/*\n * Variable storage with execution-scoped addressing, per-node execution\n * indices, pull execution (lazy evaluation), scopes and parallel lanes, debug\n * events, and the durable engine calls a generated body makes.\n *\n * Scope counters start at 0 on every construction. A resume replays the body\n * from its first node, skipping what the continuation holds, and so reaches\n * the same iteration ordinals the first run assigned\n * (`tests/continuation/durable-loops.test.ts`).\n */\nclass GeneratedExecutionContext {\n  private variables: Map<string, VariableValue> = new Map();\n  private executions: Map<string, ExecutionInfo> = new Map();\n  private executionCounter: number = 0;\n  private nodeExecutionCounts: Map<string, number> = new Map();\n  private isAsync: boolean;\n  // inline: development only\n  private flowWeaverDebugger?: TDebugger | undefined;\n  // inline: end\n  private pullExecutors: Map<string, () => void | Promise<void>> = new Map();\n  private nodeExecutionIndices: Map<string, number> = new Map();\n  private runtime: WorkflowRuntime;\n  private scopeInvocationCounts: Map<string, number> = new Map();\n  private nestedInvocationCounts: Map<string, number> = new Map();\n  private branchStack: BranchAddress[];\n  private allowAncestorDurableVariables = true;\n\n  /* `isAsync` is the workflow's async mode; `runtime` is the execution-scoped runtime. */\n  constructor(isAsync: boolean = true, runtime: WorkflowRuntime) {\n    this.isAsync = isAsync;\n    // inline: development only\n    this.flowWeaverDebugger = runtime.services.debugger;\n    // inline: end\n    this.runtime = runtime;\n    this.branchStack = [...runtime.branches];\n  }\n\n  registerPullExecutor(id: string, executor: () => void | Promise<void>): void {\n    this.pullExecutors.set(id, executor);\n  }\n\n  /* Record one execution of a node; each node counts its own executions from 0. */\n  addExecution(id: string, parentIndex?: number, scopeName?: string): number {\n    const index = this.nodeExecutionCounts.get(id) ?? 0;\n    this.nodeExecutionCounts.set(id, index + 1);\n    this.executionCounter++;\n    this.executions.set(this.getExecutionKey(id, index), {\n      id,\n      index,\n      parentIndex,\n      scopeName,\n    });\n    this.nodeExecutionIndices.set(id, index);\n    return index;\n  }\n\n  setVariable(address: VariableAddress, value: VariableValue): void | Promise<void> {\n    const key = this.getVariableKey(address);\n    this.variables.set(key, value);\n    if (typeof value !== 'function' && address.durable !== false) {\n      this.runtime.durable.setVariable(this.executionAddress(address), address.portName, value);\n    }\n    // inline: development only\n    if (this.flowWeaverDebugger) {\n      const actualValue = typeof value === 'function' ? value() : value;\n      this.sendVariableSetEvent({\n        identifier: {\n          nodeTypeName: address.nodeTypeName || 'unknown',\n          id: address.id,\n          portName: address.portName,\n          executionIndex: address.executionIndex,\n          key: 'default',\n          ...(address.scope && { scope: address.scope }),\n          ...(address.side && { side: address.side }),\n        },\n        value: actualValue,\n      });\n    }\n    // inline: end\n    return this.isAsync ? Promise.resolve() : undefined;\n  }\n\n  getVariable(address: VariableAddress): unknown | Promise<unknown> {\n    const executor = this.pullExecutors.get(address.id);\n    if (executor) {\n      if (!this.hasVariable(address)) {\n        const result = executor();\n        // Handle async executor (returns Promise)\n        if (result instanceof Promise) {\n          return result.then(() => {\n            const trackedIndex = this.nodeExecutionIndices.get(address.id);\n            const finalAddress = trackedIndex !== undefined ? { ...address, executionIndex: trackedIndex } : address;\n            return this.retrieveVariable(finalAddress);\n          });\n        }\n        // Handle sync executor (returns void)\n        const trackedIndex = this.nodeExecutionIndices.get(address.id);\n        const finalAddress = trackedIndex !== undefined ? { ...address, executionIndex: trackedIndex } : address;\n        return this.retrieveVariable(finalAddress);\n      }\n    }\n    return this.retrieveVariable(address);\n  }\n\n  private retrieveVariable(address: VariableAddress): unknown | Promise<unknown> {\n    const key = this.getVariableKey(address);\n    let value = this.variables.get(key);\n    if (!this.variables.has(key)) {\n      value = this.runtime.durable.getVariable(\n        this.executionAddress(address),\n        address.portName,\n        this.allowAncestorDurableVariables,\n      );\n      if (value === undefined) {\n        throw new Error(`Variable not found: ${address.id}.${address.portName}[${address.executionIndex}]`);\n      }\n      this.variables.set(key, value);\n    }\n    if (typeof value === 'function') {\n      const result = value();\n      if (result instanceof Promise) {\n        return result;\n      }\n      return this.isAsync ? Promise.resolve(result) : result;\n    }\n    return this.isAsync ? Promise.resolve(value) : value;\n  }\n\n  hasVariable(address: VariableAddress): boolean {\n    const key = this.getVariableKey(address);\n    return (\n      this.variables.has(key) ||\n      this.runtime.durable.getVariable(\n        this.executionAddress(address),\n        address.portName,\n        this.allowAncestorDurableVariables,\n      ) !== undefined\n    );\n  }\n\n  executionAddress(address: Pick<VariableAddress, 'id' | 'executionIndex' | 'nodeTypeName'>): ExecutionAddress {\n    const runtime = this.getRuntime();\n    return runtime.durable.address(runtime, address.id, address.nodeTypeName ?? address.id, address.executionIndex);\n  }\n\n  shouldExecute(nodeId: string, nodeType: string, executionIndex: number): boolean {\n    const runtime = this.getRuntime();\n    return runtime.durable.shouldExecute(runtime.durable.address(runtime, nodeId, nodeType, executionIndex));\n  }\n\n  commitNode(nodeId: string, nodeType: string, executionIndex: number): void {\n    const runtime = this.getRuntime();\n    runtime.durable.commitNode(runtime.durable.address(runtime, nodeId, nodeType, executionIndex));\n  }\n\n  /* The first thing a gated body does: name its workflow and graph to the engine. */\n  bindWorkflow(workflowId: string, graphFingerprint: string): void {\n    this.runtime.durable.bind(this.runtime, workflowId, graphFingerprint);\n  }\n\n  resolveGate(\n    kind: DurableGateKind,\n    nodeId: string,\n    nodeType: string,\n    executionIndex: number,\n    payload: WireValue,\n  ): WireValue {\n    const runtime = this.getRuntime();\n    return runtime.durable.resolveGate(runtime, { kind, nodeId, nodeType, executionIndex, payload });\n  }\n\n  executeEffect<T extends WireValue>(\n    nodeId: string,\n    nodeType: string,\n    executionIndex: number,\n    execute: (operationKey: string) => Promise<{ result: T; receipt: WireValue }>,\n  ): Promise<T> {\n    const runtime = this.getRuntime();\n    return runtime.durable.executeEffect(runtime, { nodeId, nodeType, executionIndex }, execute);\n  }\n\n  createNestedRuntime(workflowId: string, callerNodeId: string, callerExecutionIndex: number): WorkflowRuntime {\n    const invocation = this.nestedInvocationCounts.get(callerNodeId) ?? 0;\n    this.nestedInvocationCounts.set(callerNodeId, invocation + 1);\n    const parentRuntime = this.getRuntime();\n    return {\n      ...parentRuntime,\n      frames: [...parentRuntime.frames, { workflowId, invocation, callerNodeId, callerExecutionIndex }],\n      scopes: parentRuntime.scopes,\n    };\n  }\n\n  enterBranch(nodeId: string, executionIndex: number, arm: string): void {\n    const frameDepth = this.runtime.frames.length - 1;\n    const workflowId = this.runtime.frames[frameDepth].workflowId;\n    this.branchStack.push({ workflowId, frameDepth, nodeId, executionIndex, arm });\n  }\n\n  exitBranch(): void {\n    this.branchStack.pop();\n  }\n\n  getRuntime(): WorkflowRuntime {\n    return { ...this.runtime, branches: [...this.branchStack] };\n  }\n\n  /*\n   * Fork the mutable bookkeeping for one lane of a parallel group. Durable\n   * state stays execution-scoped and shared through `runtime`, while the\n   * branch and scope address stacks are copied so concurrent lanes cannot\n   * corrupt one another's continuation addresses.\n   */\n  forkParallel(): GeneratedExecutionContext {\n    const parallelContext = new GeneratedExecutionContext(this.isAsync, this.getRuntime());\n    parallelContext.variables = new Map(this.variables);\n    parallelContext.executions = new Map(this.executions);\n    parallelContext.executionCounter = this.executionCounter;\n    parallelContext.pullExecutors = new Map(this.pullExecutors);\n    parallelContext.nodeExecutionIndices = new Map(this.nodeExecutionIndices);\n    parallelContext.nodeExecutionCounts = new Map(this.nodeExecutionCounts);\n    parallelContext.scopeInvocationCounts = new Map(this.scopeInvocationCounts);\n    parallelContext.nestedInvocationCounts = new Map(this.nestedInvocationCounts);\n    parallelContext.allowAncestorDurableVariables = this.allowAncestorDurableVariables;\n    return parallelContext;\n  }\n\n  mergeParallel(parallelContext: GeneratedExecutionContext): void {\n    this.mergeScope(parallelContext);\n    parallelContext.nodeExecutionIndices.forEach((index, id) => {\n      this.nodeExecutionIndices.set(id, index);\n    });\n    parallelContext.scopeInvocationCounts.forEach((count, key) => {\n      this.scopeInvocationCounts.set(key, Math.max(this.scopeInvocationCounts.get(key) ?? 0, count));\n    });\n    parallelContext.nestedInvocationCounts.forEach((count, key) => {\n      this.nestedInvocationCounts.set(key, Math.max(this.nestedInvocationCounts.get(key) ?? 0, count));\n    });\n  }\n\n  getExecution(id: string, index: number): ExecutionInfo | undefined {\n    return this.executions.get(this.getExecutionKey(id, index));\n  }\n\n  /*\n   * Create the execution context for one invocation of a scope (a loop body,\n   * a per-port function). Each call is the next invocation of that scope key.\n   * A clean scope (a per-port scope) starts with no variables and cannot read\n   * its ancestors' durable variables; any other (a node-level scope) inherits\n   * the parent's variables. `isAsyncOverride` is the scope's own async mode,\n   * when it differs from the parent's.\n   */\n  createScope(\n    _parentNodeName: string,\n    _parentIndex: number,\n    _scopeName: string,\n    cleanScope: boolean = false,\n    isAsyncOverride?: boolean,\n  ): GeneratedExecutionContext {\n    const effectiveIsAsync = isAsyncOverride !== undefined ? isAsyncOverride : this.isAsync;\n    const scopeKey = `${_parentNodeName}:${_parentIndex}:${_scopeName}`;\n    const scopeInvocation = this.scopeInvocationCounts.get(scopeKey) ?? 0;\n    this.scopeInvocationCounts.set(scopeKey, scopeInvocation + 1);\n    const parentRuntime = this.getRuntime();\n    const scopedRuntime: WorkflowRuntime = {\n      ...parentRuntime,\n      scopes: [\n        ...parentRuntime.scopes,\n        {\n          parentNodeId: _parentNodeName,\n          parentExecutionIndex: _parentIndex,\n          scopeName: _scopeName,\n          invocation: scopeInvocation,\n          loopIteration: scopeInvocation,\n        },\n      ],\n    };\n    const scopedContext = new GeneratedExecutionContext(effectiveIsAsync, scopedRuntime);\n    scopedContext.variables = cleanScope ? new Map() : new Map(this.variables);\n    scopedContext.allowAncestorDurableVariables = this.allowAncestorDurableVariables && !cleanScope;\n    scopedContext.executions = new Map(this.executions);\n    scopedContext.executionCounter = this.executionCounter;\n    scopedContext.nodeExecutionCounts = new Map(this.nodeExecutionCounts);\n    return scopedContext;\n  }\n\n  /* Merge a scope's variables, executions and counters back into this context. */\n  mergeScope(scopedContext: GeneratedExecutionContext): void {\n    scopedContext.executions.forEach((info, key) => {\n      this.executions.set(key, info);\n    });\n    scopedContext.variables.forEach((value, key) => {\n      this.variables.set(key, value);\n    });\n    this.executionCounter = Math.max(this.executionCounter, scopedContext.executionCounter);\n    scopedContext.nodeExecutionCounts.forEach((count, id) => {\n      this.nodeExecutionCounts.set(id, Math.max(this.nodeExecutionCounts.get(id) ?? 0, count));\n    });\n  }\n\n  private getVariableKey(address: VariableAddress): string {\n    return `${address.id}:${address.portName}:${address.executionIndex}`;\n  }\n\n  private getExecutionKey(id: string, index: number): string {\n    return `${id}:${index}`;\n  }\n\n  getExecutionCount(): number {\n    return this.executionCounter;\n  }\n\n  reset(): void {\n    this.variables.clear();\n    this.executions.clear();\n    this.executionCounter = 0;\n    this.nodeExecutionCounts.clear();\n  }\n\n  isAborted(): boolean {\n    return this.runtime.abortSignal?.aborted ?? false;\n  }\n\n  /* Return the parent-owned signal without transferring ownership. */\n  getAbortSignal(): AbortSignal | undefined {\n    return this.runtime.abortSignal;\n  }\n\n  /* Throw a CancellationError, naming `nodeId` when given, if the run was aborted. */\n  checkAborted(nodeId?: string): void {\n    if (this.runtime.abortSignal?.aborted) {\n      throw new CancellationError(\n        `Workflow execution cancelled${nodeId ? ` at ${nodeId}` : ''}`,\n        this.executionCounter,\n        nodeId,\n      );\n    }\n  }\n\n  // inline: development only, a no-op stub in production\n  /* Awaited by generated code, so a debugger can hold a node at a breakpoint. */\n  async sendStatusChangedEvent(args: {\n    nodeTypeName: string;\n    id: string;\n    scope?: string;\n    side?: 'start' | 'exit';\n    executionIndex: number;\n    status: TStatusType;\n  }): Promise<void> {\n    if (this.flowWeaverDebugger) {\n      await this.flowWeaverDebugger.sendEvent({\n        type: 'STATUS_CHANGED',\n        ...args,\n        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,\n      });\n    }\n  }\n\n  async sendLogErrorEvent(args: {\n    nodeTypeName: string;\n    id: string;\n    scope?: string;\n    side?: 'start' | 'exit';\n    executionIndex: number;\n    error: string;\n    code?: string;\n  }): Promise<void> {\n    if (this.flowWeaverDebugger) {\n      await this.flowWeaverDebugger.sendEvent({\n        type: 'LOG_ERROR',\n        ...args,\n        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,\n      });\n    }\n  }\n\n  async sendWorkflowCompletedEvent(args: {\n    executionIndex: number;\n    status: 'SUCCEEDED' | 'FAILED' | 'CANCELLED';\n    result?: unknown;\n  }): Promise<void> {\n    if (this.flowWeaverDebugger) {\n      await this.flowWeaverDebugger.sendEvent({\n        type: 'WORKFLOW_COMPLETED',\n        ...args,\n        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,\n      });\n    }\n  }\n  // inline: end\n  // inline: development only\n\n  private async sendVariableSetEvent(args: { identifier: TVariableIdentification; value: unknown }): Promise<void> {\n    if (this.flowWeaverDebugger) {\n      await this.flowWeaverDebugger.sendEvent({\n        type: 'VARIABLE_SET',\n        ...args,\n        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,\n      });\n    }\n  }\n\n  /* Return live debugger-visible variables without invoking lazy values. */\n  inspectVariables(): Record<string, unknown> {\n    const vars: Record<string, unknown> = {};\n    for (const [key, value] of this.variables) {\n      vars[key] = typeof value === 'function' ? '[lazy value]' : value;\n    }\n    return vars;\n  }\n  // inline: end\n}\n";
+
+// src/api/inline-runtime.ts
+var INLINE_ENGINE_EXPORTS = [
+  "createWorkflowRuntime",
+  "acceptContinuation",
+  "createContinuationEnvelope",
+  "isDurableGateYield",
+  "isAmbiguousEffectError",
+  "DurableGateYield",
+  "AmbiguousEffectError",
+  "CancellationError",
+  "ENGINE_VERSION"
+];
+var INLINE_ENGINE_TYPE_EXPORTS = [
+  "WorkflowRuntime",
+  "WorkflowRuntimeServices",
+  "CreateWorkflowRuntimeOptions",
+  "ContinuationEnvelope",
+  "DecodedContinuation",
+  "DurableGate",
+  "GateResolution",
+  "EffectAdapter",
+  "WireValue"
+];
+function generateInlineEngine(production) {
+  const lines = [];
+  lines.push("// ============================================================================");
+  lines.push("// Durable Engine");
+  lines.push("// The package's own engine, copied here so this file runs without it.");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push(`const VERSION = ${JSON.stringify(VERSION)};`);
+  if (!production) {
+    lines.push("type DebugController = TDebugController;");
+  }
+  lines.push(
+    "type FwMockConfig = { readonly events?: Readonly<Record<string, object>>, readonly invocations?: Readonly<Record<string, object>>, readonly agents?: Readonly<Record<string, object>>, readonly gates?: Readonly<Record<string, object>>, readonly fast?: boolean };"
+  );
+  lines.push("");
+  const source = production ? INLINE_ENGINE_SOURCE.replace(/\bTDebugger\b/g, "unknown").replace(/\bDebugController\b/g, "unknown") : INLINE_ENGINE_SOURCE;
+  lines.push(source);
+  return lines.join("\n");
+}
+var DEVELOPMENT_REGION = /^([ \t]*)\/\/ inline: development only(, a no-op stub in production)?\n([\s\S]*?)^[ \t]*\/\/ inline: end\n/gm;
+var CLASS_METHOD = /^ {2}(?:async\s+)?([A-Za-z_$][\w$]*)\(/gm;
+function inlineExecutionContext(production, exportClasses) {
+  let source = INLINE_EXECUTION_CONTEXT_SOURCE.replace(
+    DEVELOPMENT_REGION,
+    (_region, indent, stubbed, body) => {
+      if (!production) return body;
+      if (stubbed === void 0) return "";
+      return Array.from(
+        body.matchAll(CLASS_METHOD),
+        ([, name]) => [`${indent}${name}(_args: unknown): void {`, `${indent}  // No-op in production mode`, `${indent}}`, ""].join("\n")
+      ).join("\n");
+    }
+  );
+  if (/\/\/ inline:/.test(source)) {
+    throw new Error("src/runtime/ExecutionContext.ts has an unbalanced `// inline:` marker");
+  }
+  if (exportClasses) {
+    source = source.replace(/^class GeneratedExecutionContext\b/m, "export class GeneratedExecutionContext");
+  }
+  return source.trimEnd();
+}
+function stripTypeScript(code) {
+  const { transformSync } = __require("esbuild");
+  const result = transformSync(code, {
+    loader: "ts",
+    target: "es2020",
+    // Keep the code readable (no minification)
+    minify: false,
+    // Preserve formatting as much as possible
+    keepNames: true
+  });
+  return result.code;
+}
+function generateInlineRuntime(production, exportClasses = false, outputFormat = "typescript", moduleFormat = "esm") {
+  const exportKeyword = exportClasses ? "export " : "";
+  const lines = [];
+  lines.push("// ============================================================================");
+  lines.push("// Runtime Types");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("type TStatusType =");
+  lines.push('  | "RUNNING"');
+  lines.push('  | "SCHEDULED"');
+  lines.push('  | "SUCCEEDED"');
+  lines.push('  | "FAILED"');
+  lines.push('  | "CANCELLED"');
+  lines.push('  | "PENDING";');
+  lines.push("");
+  lines.push("type TVariableIdentification = {");
+  lines.push("  nodeTypeName: string;");
+  lines.push("  id: string;");
+  lines.push("  scope?: string | undefined;");
+  lines.push('  side?: "start" | "exit" | undefined;');
+  lines.push("  portName: string;");
+  lines.push("  executionIndex: number;");
+  lines.push("  key?: string | undefined;");
+  lines.push("};");
+  lines.push("");
+  if (!production) {
+    lines.push("type TStatusChangedEvent = {");
+    lines.push('  type: "STATUS_CHANGED";');
+    lines.push("  nodeTypeName: string;");
+    lines.push("  id: string;");
+    lines.push("  scope?: string;");
+    lines.push('  side?: "start" | "exit";');
+    lines.push("  executionIndex: number;");
+    lines.push("  status: TStatusType;");
+    lines.push("  innerFlowInvocation?: boolean;");
+    lines.push("};");
+    lines.push("");
+    lines.push("type TVariableSetEvent = {");
+    lines.push('  type: "VARIABLE_SET";');
+    lines.push("  identifier: TVariableIdentification;");
+    lines.push("  value?: unknown;");
+    lines.push("  innerFlowInvocation?: boolean;");
+    lines.push("};");
+    lines.push("");
+    lines.push("type TErrorLogEvent = {");
+    lines.push('  type: "LOG_ERROR";');
+    lines.push("  nodeTypeName: string;");
+    lines.push("  id: string;");
+    lines.push("  scope?: string;");
+    lines.push('  side?: "start" | "exit";');
+    lines.push("  executionIndex: number;");
+    lines.push("  error: string;");
+    lines.push("  code?: string;");
+    lines.push("  innerFlowInvocation?: boolean;");
+    lines.push("};");
+    lines.push("");
+    lines.push("type TWorkflowCompletedEvent = {");
+    lines.push('  type: "WORKFLOW_COMPLETED";');
+    lines.push("  executionIndex: number;");
+    lines.push('  status: "SUCCEEDED" | "FAILED" | "CANCELLED";');
+    lines.push("  result?: unknown;");
+    lines.push("  innerFlowInvocation?: boolean;");
+    lines.push("};");
+    lines.push("");
+    lines.push(`${exportKeyword}type TEvent =`);
+    lines.push("  | TStatusChangedEvent");
+    lines.push("  | TVariableSetEvent");
+    lines.push("  | TErrorLogEvent");
+    lines.push("  | TWorkflowCompletedEvent;");
+    lines.push("");
+    lines.push(`${exportKeyword}type TDebugger = {`);
+    lines.push("  sendEvent: (event: TEvent) => void | Promise<void>;");
+    lines.push("  innerFlowInvocation: boolean;");
+    lines.push("  sessionId?: string;");
+    lines.push("};");
+    lines.push("");
+    lines.push("type TDebugController = {");
+    lines.push("  beforeNode(nodeId: string, ctx: unknown): Promise<void> | void;");
+    lines.push("  afterNode(nodeId: string, ctx: unknown): Promise<void> | void;");
+    lines.push("};");
+    lines.push("");
+  }
+  lines.push("// ============================================================================");
+  lines.push("// Cancellation Error");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push(`${exportKeyword}class CancellationError extends Error {`);
+  lines.push("  public readonly executionIndex: number;");
+  lines.push("  public readonly nodeId?: string;");
+  lines.push("  public readonly timestamp: number;");
+  lines.push("");
+  lines.push("  constructor(");
+  lines.push("    message: string = 'Workflow execution cancelled',");
+  lines.push("    executionIndex: number = 0,");
+  lines.push("    nodeId?: string,");
+  lines.push("    timestamp: number = Date.now()");
+  lines.push("  ) {");
+  lines.push("    super(message);");
+  lines.push("    this.name = 'CancellationError';");
+  lines.push("    this.executionIndex = executionIndex;");
+  lines.push("    this.nodeId = nodeId;");
+  lines.push("    this.timestamp = timestamp;");
+  lines.push("  }");
+  lines.push("");
+  lines.push("  static isCancellationError(error: unknown): error is CancellationError {");
+  lines.push("    return (");
+  lines.push("      error instanceof CancellationError ||");
+  lines.push("      (error instanceof Error && error.name === 'CancellationError')");
+  lines.push("    );");
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Execution Context");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push(inlineExecutionContext(production, exportClasses));
+  lines.push("");
+  lines.push(generateInlineEngine(production));
+  lines.push("");
+  if (moduleFormat === "esm") {
+    const values = INLINE_ENGINE_EXPORTS.filter((name) => !exportClasses || name !== "CancellationError");
+    lines.push(`export { ${values.join(", ")} };`);
+    lines.push(`export type { ${INLINE_ENGINE_TYPE_EXPORTS.join(", ")} };`);
+    lines.push("");
+  }
+  const output = lines.join("\n");
+  if (outputFormat === "javascript") {
+    return stripTypeScript(output);
+  }
+  return output;
+}
+
+// src/api/in-place/runtime-section.ts
+function replaceOrInsertRuntimeSection(source, production) {
+  return replaceOrInsertSection(
+    source,
+    MARKERS.RUNTIME_START,
+    MARKERS.RUNTIME_END,
+    generateRuntimeSection(production)
+  );
+}
+function generateRuntimeSection(production) {
+  const lines = [];
+  lines.push("// ============================================================================");
+  lines.push("// DO NOT EDIT - This section is auto-generated by Flow Weaver");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push(generateInlineRuntime(production));
+  return lines.join("\n");
+}
+function replaceOrInsertSection(source, startMarker, endMarker, newContent) {
+  const startIdx = source.indexOf(startMarker);
+  const endIdx = source.indexOf(endMarker);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before2 = source.slice(0, startIdx + startMarker.length);
+    const after2 = source.slice(endIdx);
+    const newCode = before2 + "\n" + newContent + "\n" + after2;
+    const originalContent = source.slice(startIdx + startMarker.length, endIdx);
+    const changed = originalContent.trim() !== newContent.trim();
+    return { code: newCode, changed };
+  }
+  const insertIdx = findInsertPositionAfterImports(source);
+  const before = source.slice(0, insertIdx);
+  const after = source.slice(insertIdx);
+  const newSection = ["", startMarker, newContent, endMarker, ""].join("\n");
+  return {
+    code: before + newSection + after,
+    changed: true
+  };
+}
+function findInsertPositionAfterImports(source) {
+  const sourceFile = parseSource(source);
+  let lastImportEnd = 0;
+  ts4.forEachChild(sourceFile, (node) => {
+    if (ts4.isImportDeclaration(node)) {
+      lastImportEnd = node.end;
+    }
+  });
+  if (lastImportEnd > 0) {
+    const nextNewline = source.indexOf("\n", lastImportEnd);
+    return nextNewline !== -1 ? nextNewline + 1 : lastImportEnd;
+  }
+  return 0;
+}
+
+// src/api/in-place/signature.ts
+import * as ts5 from "typescript";
+function detectFunctionIsAsync(source, functionName) {
+  const functionNode = findFunctionDeclaration(parseSource(source), functionName);
+  return !!functionNode?.modifiers?.some((m) => m.kind === ts5.SyntaxKind.AsyncKeyword);
+}
+function ensureParamsParameter(source, functionName) {
+  const functionNode = findFunctionDeclaration(parseSource(source), functionName);
+  if (!functionNode) {
+    return { code: source, changed: false };
+  }
+  const hasParams = functionNode.parameters.some(
+    (param) => ts5.isIdentifier(param.name) && param.name.text === "params"
+  );
+  if (hasParams) {
+    return { code: source, changed: false };
+  }
+  const PARAMS_DECL = "params: Record<string, unknown> = {}";
+  const firstParam = functionNode.parameters[0];
+  if (!firstParam) {
+    const openParen = source.indexOf("(", functionNode.name?.end || 0);
+    if (openParen === -1) {
+      return { code: source, changed: false };
+    }
+    const before2 = source.slice(0, openParen + 1);
+    const after2 = source.slice(openParen + 1);
+    return { code: before2 + PARAMS_DECL + after2, changed: true };
+  }
+  const firstParamEnd = firstParam.end;
+  const before = source.slice(0, firstParamEnd);
+  const after = source.slice(firstParamEnd);
+  return { code: before + ", " + PARAMS_DECL + after, changed: true };
+}
+function ensureRuntimeParameter(source, functionName) {
+  const sourceFile = parseSource(source);
+  const functionNode = findFunctionDeclaration(sourceFile, functionName);
+  if (!functionNode) {
+    return { code: source, changed: false };
+  }
+  const parameters = functionNode.parameters.slice(0, 2).map((parameter) => parameter.getText(sourceFile));
+  parameters.push("__runtime__: WorkflowRuntime");
+  const openParen = source.indexOf("(", functionNode.name?.end ?? 0);
+  if (openParen === -1) return { code: source, changed: false };
+  const closeParen = functionNode.parameters.end;
+  const replacement = parameters.join(", ");
+  const current = source.slice(openParen + 1, closeParen);
+  if (current.trim() === replacement) return { code: source, changed: false };
+  return {
+    code: source.slice(0, openParen + 1) + replacement + source.slice(closeParen),
+    changed: true
+  };
+}
+function ensureAsyncKeyword(source, functionName, shouldBeAsync) {
+  if (!shouldBeAsync) {
+    return { code: source, changed: false };
+  }
+  const functionNode = findFunctionDeclaration(parseSource(source), functionName);
+  if (!functionNode) {
+    return { code: source, changed: false };
+  }
+  const alreadyAsync = !!functionNode.modifiers?.some((m) => m.kind === ts5.SyntaxKind.AsyncKeyword);
+  if (alreadyAsync) {
+    return { code: source, changed: false };
+  }
+  const funcStart = functionNode.getStart();
+  const textAfter = source.slice(funcStart);
+  const functionKeywordOffset = textAfter.indexOf("function");
+  if (functionKeywordOffset === -1) {
+    return { code: source, changed: false };
+  }
+  const insertPos = funcStart + functionKeywordOffset;
+  const before = source.slice(0, insertPos);
+  const after = source.slice(insertPos);
+  return {
+    code: before + "async " + after,
+    changed: true
+  };
+}
+function ensurePromiseReturnType(source, functionName, shouldBeAsync) {
+  if (!shouldBeAsync) {
+    return { code: source, changed: false };
+  }
+  const functionNode = findFunctionDeclaration(parseSource(source), functionName);
+  if (!functionNode || !functionNode.type) {
+    return { code: source, changed: false };
+  }
+  const returnTypeText = source.slice(functionNode.type.pos, functionNode.type.end).trim();
+  if (returnTypeText.startsWith("Promise<")) {
+    return { code: source, changed: false };
+  }
+  const before = source.slice(0, functionNode.type.pos);
+  const after = source.slice(functionNode.type.end);
+  return {
+    code: before + " Promise<" + returnTypeText + ">" + after,
+    changed: true
+  };
+}
+
+// src/api/in-place/workflow-jsdoc.ts
+import * as ts6 from "typescript";
+
+// src/api/in-place/macro-coverage.ts
+function isConnectionCoveredByMacro(conn, macros) {
+  for (const macro of macros) {
+    if (macro.type === "map") {
+      const [sourceNode, sourcePort] = macro.sourcePort.split(".");
+      if ((conn.from.node === macro.instanceId || conn.from.node === macro.childId) && (conn.to.node === macro.instanceId || conn.to.node === macro.childId) && (conn.from.scope === "iterate" || conn.to.scope === "iterate")) {
+        return true;
+      }
+      if (conn.from.node === sourceNode && conn.from.port === sourcePort && !conn.from.scope && conn.to.node === macro.instanceId && conn.to.port === "items" && !conn.to.scope) {
+        return true;
+      }
+    } else if (macro.type === "path") {
+      if (conn.from.scope || conn.to.scope) continue;
+      const steps = macro.steps;
+      const fromIdx = steps.findIndex((s) => s.node === conn.from.node);
+      const toIdx = steps.findIndex((s) => s.node === conn.to.node);
+      if (fromIdx === -1 || toIdx === -1 || fromIdx >= toIdx) continue;
+      if (toIdx === fromIdx + 1) {
+        const route = steps[fromIdx].route || "ok";
+        if (conn.from.node === "Start" && conn.from.port === "execute" && conn.to.port === "execute") return true;
+        if (conn.to.node === "Exit") {
+          if (route === "fail" && conn.from.port === "onFailure" && conn.to.port === "onFailure") return true;
+          if (route === "ok" && conn.from.port === "onSuccess" && conn.to.port === "onSuccess") return true;
+        }
+        if (route === "fail" && conn.from.port === "onFailure" && conn.to.port === "execute") return true;
+        if (route === "ok" && conn.from.port === "onSuccess" && conn.to.port === "execute") return true;
+      }
+      if (isPathImpliedDataEdge(conn.from.node, conn.from.port, conn.to.node, conn.to.port)) {
+        return true;
+      }
+    } else if (macro.type === "fanOut") {
+      if (conn.from.scope || conn.to.scope) continue;
+      if (conn.from.node === macro.source.node && conn.from.port === macro.source.port) {
+        for (const target of macro.targets) {
+          const targetPort = target.port ?? macro.source.port;
+          if (conn.to.node === target.node && conn.to.port === targetPort) {
+            return true;
+          }
+        }
+      }
+    } else if (macro.type === "fanIn") {
+      if (conn.from.scope || conn.to.scope) continue;
+      if (conn.to.node === macro.target.node && conn.to.port === macro.target.port) {
+        for (const source of macro.sources) {
+          const sourcePort = source.port ?? macro.target.port;
+          if (conn.from.node === source.node && conn.from.port === sourcePort) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// src/api/in-place/workflow-jsdoc.ts
+function replaceWorkflowJSDoc(source, ast, options = {}) {
+  const sourceFile = parseSource(source);
+  let functionNode;
+  ts6.forEachChild(sourceFile, (node) => {
+    if (functionNode) return;
+    if (ts6.isFunctionDeclaration(node) && node.name?.text === ast.functionName) {
+      functionNode = node;
+    }
+  });
+  if (!functionNode) {
+    return { code: source, changed: false };
+  }
+  const functionStart = functionNode.getFullStart();
+  const leadingComments = ts6.getLeadingCommentRanges(source, functionStart);
+  if (!leadingComments || leadingComments.length === 0) {
+    return { code: source, changed: false };
+  }
+  const jsdocComment = leadingComments.find(
+    (c) => c.kind === ts6.SyntaxKind.MultiLineCommentTrivia && source.slice(c.pos, c.pos + 3) === "/**"
+  );
+  if (!jsdocComment) {
+    return { code: source, changed: false };
+  }
+  const newJSDoc = generateWorkflowJSDoc(ast, { skipParamReturns: options.skipParamReturns });
+  const originalJSDoc = source.slice(jsdocComment.pos, jsdocComment.end);
+  if (originalJSDoc.trim() === newJSDoc.trim()) {
+    return { code: source, changed: false };
+  }
+  const before = source.slice(0, jsdocComment.pos);
+  const after = source.slice(jsdocComment.end);
+  return {
+    code: before + newJSDoc + after,
+    changed: true
+  };
+}
+function generateWorkflowJSDoc(ast, options = {}) {
+  const lines = [];
+  const macroInstanceIds = /* @__PURE__ */ new Set();
+  const macroChildIds = /* @__PURE__ */ new Set();
+  const macroScopeNames = /* @__PURE__ */ new Set();
+  const allCoerceInstanceIds = /* @__PURE__ */ new Set();
+  if (ast.macros && ast.macros.length > 0) {
+    for (const macro of ast.macros) {
+      if (macro.type === "map") {
+        macroInstanceIds.add(macro.instanceId);
+        macroChildIds.add(macro.childId);
+        macroScopeNames.add(`${macro.instanceId}.iterate`);
+      } else if (macro.type === "coerce") {
+        allCoerceInstanceIds.add(macro.instanceId);
+      }
+    }
+  }
+  lines.push("/**");
+  if (ast.description) {
+    lines.push(...formatJSDocDescription(ast.description));
+    lines.push(` *`);
+  }
+  lines.push(" * @flowWeaver workflow");
+  if (ast.options?.strictTypes) {
+    lines.push(" * @strictTypes");
+  }
+  if (ast.options?.autoConnect) {
+    lines.push(" * @autoConnect");
+  }
+  if (ast.options?.trigger) {
+    const t = ast.options.trigger;
+    const parts = [];
+    if (t.event) parts.push(`event="${t.event}"`);
+    if (t.cron) parts.push(`cron="${t.cron}"`);
+    if (parts.length > 0) lines.push(` * @trigger ${parts.join(" ")}`);
+  }
+  for (const r of ast.options?.http ?? []) lines.push(` * @http ${httpRouteText(r)}`);
+  if (ast.options?.cancelOn) {
+    const c = ast.options.cancelOn;
+    let line = ` * @cancelOn event="${c.event}"`;
+    if (c.match) line += ` match="${c.match}"`;
+    if (c.timeout) line += ` timeout="${c.timeout}"`;
+    lines.push(line);
+  }
+  if (ast.options?.retries !== void 0) {
+    lines.push(` * @retries ${ast.options.retries}`);
+  }
+  if (ast.options?.timeout) {
+    lines.push(` * @timeout "${ast.options.timeout}"`);
+  }
+  if (ast.options?.throttle) {
+    const t = ast.options.throttle;
+    let line = ` * @throttle limit=${t.limit}`;
+    if (t.period) line += ` period="${t.period}"`;
+    lines.push(line);
+  }
+  lines.push(...serializePackDeployAnnotations(ast.options?.deploy));
+  if (ast.name && ast.name !== ast.functionName) {
+    lines.push(` * @name ${ast.name}`);
+  }
+  const npmNodeTypes = ast.nodeTypes.filter((nt) => nt.importSource);
+  const seenImportNames = /* @__PURE__ */ new Set();
+  for (const npmType of npmNodeTypes) {
+    if (seenImportNames.has(npmType.name)) continue;
+    seenImportNames.add(npmType.name);
+    lines.push(` * @fwImport ${npmType.name} ${fwImportFunctionName(npmType)} from "${npmType.importSource}"`);
+  }
+  for (const instance of ast.instances) {
+    if (macroInstanceIds.has(instance.id)) continue;
+    if (allCoerceInstanceIds.has(instance.id)) continue;
+    const inst = instance;
+    if (macroChildIds.has(inst.id) && inst.parent) {
+      const stripped = { ...inst, parent: void 0 };
+      lines.push(generateNodeInstanceTag(stripped));
+    } else {
+      lines.push(generateNodeInstanceTag(inst));
+    }
+  }
+  const authoredConnections = ast.connections.filter((conn) => !conn.derived);
+  const existingMacros = filterStaleMacros(
+    ast.macros || [],
+    authoredConnections,
+    ast.instances,
+    ast.nodeTypes,
+    ast.startPorts,
+    ast.exitPorts
+  );
+  const survivingCoerceIds = /* @__PURE__ */ new Set();
+  for (const macro of existingMacros) {
+    if (macro.type === "coerce") survivingCoerceIds.add(macro.instanceId);
+  }
+  const droppedCoerceIds = /* @__PURE__ */ new Set();
+  for (const id of allCoerceInstanceIds) {
+    if (!survivingCoerceIds.has(id)) droppedCoerceIds.add(id);
+  }
+  const detected = detectSugarPatterns(
+    authoredConnections,
+    ast.instances,
+    existingMacros,
+    ast.nodeTypes,
+    ast.startPorts,
+    ast.exitPorts
+  );
+  const allMacros = [
+    ...existingMacros,
+    ...detected.paths
+  ];
+  if (allMacros.length > 0) {
+    for (const macro of allMacros) {
+      if (macro.type === "map") {
+        let mapLine = ` * @map ${macro.instanceId} ${macro.childId}`;
+        if (macro.inputPort || macro.outputPort) {
+          mapLine += `(${macro.inputPort} -> ${macro.outputPort})`;
+        }
+        mapLine += ` over ${macro.sourcePort}`;
+        lines.push(mapLine);
+      } else if (macro.type === "path") {
+        const stepsStr = macro.steps.map((s) => s.route ? `${s.node}:${s.route}` : s.node).join(" -> ");
+        lines.push(` * @path ${stepsStr}`);
+      } else if (macro.type === "fanOut") {
+        const src = `${macro.source.node}.${macro.source.port}`;
+        const tgts = macro.targets.map((t) => t.port ? `${t.node}.${t.port}` : t.node).join(", ");
+        lines.push(` * @fanOut ${src} -> ${tgts}`);
+      } else if (macro.type === "fanIn") {
+        const srcs = macro.sources.map((s) => s.port ? `${s.node}.${s.port}` : s.node).join(", ");
+        const tgt = `${macro.target.node}.${macro.target.port}`;
+        lines.push(` * @fanIn ${srcs} -> ${tgt}`);
+      }
+    }
+  }
+  if (!ast.options?.autoConnect) {
+    for (const conn of authoredConnections) {
+      if (allMacros.length > 0 && isConnectionCoveredByMacro(conn, allMacros)) continue;
+      if (droppedCoerceIds.has(conn.from.node) || droppedCoerceIds.has(conn.to.node)) continue;
+      const fromScope = conn.from.scope ? `:${conn.from.scope}` : "";
+      const toScope = conn.to.scope ? `:${conn.to.scope}` : "";
+      lines.push(
+        ` * @connect ${conn.from.node}.${conn.from.port}${fromScope} -> ${conn.to.node}.${conn.to.port}${toScope}`
+      );
+    }
+  }
+  if (!options.skipParamReturns && ast.startPorts && Object.keys(ast.startPorts).length > 0) {
+    for (const { name, port, writeOrder } of planPortTags(Object.entries(ast.startPorts))) {
+      const paramTag = generateJSDocPortTag(name, port, "input", void 0, { writeOrder });
+      lines.push(` * ${paramTag.replace("@input", "@param")}`);
+    }
+  }
+  if (!options.skipParamReturns && ast.exitPorts && Object.keys(ast.exitPorts).length > 0) {
+    for (const { name, port, writeOrder } of planPortTags(Object.entries(ast.exitPorts))) {
+      const returnTag = generateJSDocPortTag(name, port, "output", void 0, { writeOrder });
+      lines.push(` * ${returnTag.replace("@output", "@returns")}`);
+    }
+  }
+  if (ast.scopes) {
+    for (const [scopeName, children] of Object.entries(ast.scopes)) {
+      if (macroScopeNames.has(scopeName)) continue;
+      lines.push(` * @scope ${scopeName} [${children.join(", ")}]`);
+    }
+  }
+  lines.push(" */");
+  return lines.join("\n");
+}
+
+// src/api/generate-in-place.ts
+function generateInPlace(sourceCode, ast, options = {}) {
+  const {
+    production = false,
+    allWorkflows,
+    skipParamReturns = false,
+    annotationsOnly = false
+  } = options;
+  const durableSequential = validateDurableClosure(
+    ast,
+    allWorkflows ?? []
+  ).hasDurableGate;
+  let result = sourceCode;
+  let hasChanges = false;
+  const apply = (edit) => {
+    if (edit.changed) {
+      result = edit.code;
+      hasChanges = true;
+    }
+  };
+  apply(syncNodeTypeFunctions(result, ast));
+  if (!annotationsOnly) {
+    apply(inlineBuiltInNodes(result, ast, production));
+  }
+  apply(removeOrphanedNodeTypeFunctions(result, ast, allWorkflows));
+  apply(replaceWorkflowJSDoc(result, ast, { skipParamReturns }));
+  if (annotationsOnly) {
+    return { code: result, hasChanges: hasChanges && result !== sourceCode };
+  }
+  apply(ensureFwImportStatements(result, ast));
+  apply(replaceOrInsertRuntimeSection(result, production));
+  apply(ensureParamsParameter(result, ast.functionName));
+  apply(ensureRuntimeParameter(result, ast.functionName));
+  const nodesRequireAsync = shouldWorkflowBeAsync(ast, ast.nodeTypes);
+  const sourceIsAsync = detectFunctionIsAsync(result, ast.functionName);
+  const forceAsync = nodesRequireAsync || !production;
+  const isAsync = forceAsync || sourceIsAsync;
+  apply(ensureAsyncKeyword(result, ast.functionName, forceAsync));
+  apply(ensurePromiseReturnType(result, ast.functionName, forceAsync));
+  const identity = durableSequential ? { graphFingerprint: graphIdentity(ast, allWorkflows ?? []).graphFingerprint } : void 0;
+  const functionBody = generateFunctionBody(ast, production, isAsync, durableSequential, identity);
+  apply(replaceWorkflowFunctionBody(result, ast.functionName, functionBody));
+  if (hasChanges && result === sourceCode) {
+    hasChanges = false;
+  }
+  return { code: result, hasChanges };
+}
+
+export {
+  bodyGenerator,
+  INLINE_ENGINE_EXPORTS,
+  stripTypeScript,
+  generateInlineRuntime,
+  graphIdentity,
+  validateWorkflowAsync,
+  generateInPlace
+};