@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-GBUNNP33.mjs

@@ -0,0 +1,1329 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  getAvailableWorkflows
+} from "./flow-weaver-chunk-NQKKWDGF.mjs";
+import {
+  compileWorkflow
+} from "./flow-weaver-chunk-V6DHWFQG.mjs";
+import {
+  CONTINUATION_FORMAT_VERSION,
+  ENGINE_VERSION,
+  GENERATOR_ABI,
+  MAX_CONTINUATION_BYTES,
+  MAX_CONTINUATION_DEPTH,
+  MAX_CONTINUATION_ENTRIES,
+  MAX_CONTINUATION_STRING_BYTES,
+  WireValidationError,
+  acceptContinuation,
+  assertAcceptedContinuation,
+  canonicalWireValue,
+  cloneAndFreezeWireValue,
+  continuationChecksum,
+  createContinuationEnvelope,
+  durableGateId,
+  executionAddressKey,
+  graphIdentity,
+  hasExactlyTheKeys,
+  isPlainObjectRecord,
+  operationKey,
+  sha256Hex,
+  structurallyValidEnvelope,
+  utf8ByteLength,
+  validateWireValue
+} from "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import {
+  VERSION
+} from "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  validateDurableClosure
+} from "./flow-weaver-chunk-EM5HWQ4R.mjs";
+
+// src/mcp/workflow-executor.ts
+import * as path from "path";
+import * as fs2 from "fs";
+import { pathToFileURL } from "url";
+import ts from "typescript";
+
+// src/runtime/CancellationError.ts
+var CancellationError = class _CancellationError extends Error {
+  constructor(message = "Workflow execution cancelled", executionIndex = 0, nodeId, timestamp = Date.now()) {
+    super(message);
+    this.executionIndex = executionIndex;
+    this.nodeId = nodeId;
+    this.timestamp = timestamp;
+    this.name = "CancellationError";
+  }
+  executionIndex;
+  nodeId;
+  timestamp;
+  static isCancellationError(error) {
+    return error instanceof _CancellationError || error instanceof Error && error.name === "CancellationError";
+  }
+};
+
+// src/mcp/dist-imports.ts
+import * as fs from "node:fs";
+import * as nodePath from "node:path";
+function rewriteSrcImportsToDist(code, srcDir, fileExists = fs.existsSync, path2 = nodePath) {
+  const srcSegment = `${path2.sep}src${path2.sep}`;
+  if (!`${srcDir}${path2.sep}`.includes(srcSegment)) return code;
+  return code.replace(/from\s+['"](\.[^'"]+)['"]/g, (match, specifier) => {
+    const resolvedSrc = path2.resolve(srcDir, specifier);
+    if (fileExists(resolvedSrc)) return match;
+    const distEquivalent = resolvedSrc.replace(srcSegment, `${path2.sep}dist${path2.sep}`);
+    if (!fileExists(distEquivalent)) return match;
+    const relative = path2.relative(srcDir, distEquivalent).replace(/\\/g, "/");
+    return `from '${relative.startsWith(".") ? relative : `./${relative}`}'`;
+  });
+}
+
+// src/runtime/strict-json.ts
+var encoder = new TextEncoder();
+function parseStrictJson(text, limits) {
+  let index = 0;
+  let aggregateEntries = 0;
+  const fail = (code, message) => {
+    throw new StrictJsonError(code, message);
+  };
+  const skipWhitespace = () => {
+    while (text[index] === " " || text[index] === "\n" || text[index] === "\r" || text[index] === "	") {
+      index += 1;
+    }
+  };
+  const parseString = () => {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const character = text[index];
+      if (character === '"') {
+        index += 1;
+        let value2;
+        try {
+          value2 = JSON.parse(text.slice(start, index));
+        } catch {
+          return fail("malformed", "JSON string is malformed");
+        }
+        if (typeof value2 !== "string" || encoder.encode(value2).byteLength > limits.maxStringBytes) {
+          return fail("oversized", "JSON string byte limit exceeded");
+        }
+        return value2;
+      }
+      if (character === "\\") {
+        index += 1;
+        if (index >= text.length) {
+          return fail("malformed", "JSON string escape is incomplete");
+        }
+        if (text[index] === "u") {
+          for (let offset = 1; offset <= 4; offset += 1) {
+            if (!/[0-9a-fA-F]/.test(text[index + offset] ?? "")) {
+              return fail("malformed", "JSON unicode escape is malformed");
+            }
+          }
+          index += 4;
+        } else if (!/["\\/bfnrt]/.test(text[index])) {
+          return fail("malformed", "JSON string escape is malformed");
+        }
+      } else if ((character?.charCodeAt(0) ?? 0) < 32) {
+        return fail("malformed", "JSON string contains a control character");
+      }
+      index += 1;
+    }
+    return fail("malformed", "JSON string is unterminated");
+  };
+  const parseValue = (depth) => {
+    if (depth > limits.maxDepth) {
+      return fail("oversized", "JSON depth limit exceeded");
+    }
+    skipWhitespace();
+    const character = text[index];
+    if (character === '"') return parseString();
+    if (text.startsWith("true", index)) {
+      index += 4;
+      return true;
+    }
+    if (text.startsWith("false", index)) {
+      index += 5;
+      return false;
+    }
+    if (text.startsWith("null", index)) {
+      index += 4;
+      return null;
+    }
+    if (character === "[") {
+      index += 1;
+      skipWhitespace();
+      const values = [];
+      if (text[index] === "]") {
+        index += 1;
+        return values;
+      }
+      while (true) {
+        if (values.length >= limits.maxArrayItems) {
+          return fail("oversized", "JSON array item limit exceeded");
+        }
+        aggregateEntries += 1;
+        if (aggregateEntries > limits.maxAggregateEntries) {
+          return fail("oversized", "JSON aggregate entry limit exceeded");
+        }
+        values.push(parseValue(depth + 1));
+        skipWhitespace();
+        if (text[index] === "]") {
+          index += 1;
+          return values;
+        }
+        if (text[index] !== ",") {
+          return fail("malformed", "JSON array separator is malformed");
+        }
+        index += 1;
+      }
+    }
+    if (character === "{") {
+      index += 1;
+      skipWhitespace();
+      const value2 = /* @__PURE__ */ Object.create(null);
+      const keys = /* @__PURE__ */ new Set();
+      if (text[index] === "}") {
+        index += 1;
+        return value2;
+      }
+      while (true) {
+        if (keys.size >= limits.maxObjectKeys) {
+          return fail("oversized", "JSON object key limit exceeded");
+        }
+        skipWhitespace();
+        if (text[index] !== '"') {
+          return fail("malformed", "JSON object key must be a string");
+        }
+        const key = parseString();
+        if (keys.has(key)) {
+          return fail("malformed", `duplicate JSON object member ${key}`);
+        }
+        keys.add(key);
+        aggregateEntries += 1;
+        if (aggregateEntries > limits.maxAggregateEntries) {
+          return fail("oversized", "JSON aggregate entry limit exceeded");
+        }
+        skipWhitespace();
+        if (text[index] !== ":") {
+          return fail("malformed", "JSON object member is missing a colon");
+        }
+        index += 1;
+        value2[key] = parseValue(depth + 1);
+        skipWhitespace();
+        if (text[index] === "}") {
+          index += 1;
+          return value2;
+        }
+        if (text[index] !== ",") {
+          return fail("malformed", "JSON object separator is malformed");
+        }
+        index += 1;
+      }
+    }
+    const number = text.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/)?.[0];
+    if (number !== void 0) {
+      index += number.length;
+      const value2 = Number(number);
+      if (!Number.isFinite(value2)) {
+        return fail("malformed", "JSON number must be finite");
+      }
+      return value2;
+    }
+    return fail("malformed", "JSON value is malformed");
+  };
+  const value = parseValue(0);
+  skipWhitespace();
+  if (index !== text.length) {
+    fail("malformed", "JSON has trailing data");
+  }
+  return value;
+}
+var StrictJsonError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+  name = "StrictJsonError";
+};
+
+// src/runtime/continuation.ts
+function refusal(reason, message) {
+  return { accepted: false, reason, message };
+}
+function isGraphBranchPath(value) {
+  return Array.isArray(value) && value.every(
+    (requirement) => isPlainObjectRecord(requirement) && hasExactlyTheKeys(requirement, ["nodeId", "arm"]) && typeof requirement.nodeId === "string" && requirement.nodeId.length > 0 && typeof requirement.arm === "string" && requirement.arm.length > 0
+  );
+}
+function graphNodeFor(graph, workflowId, nodeId, nodeType) {
+  return graph.nodes.find(
+    (node) => node.workflowId === workflowId && node.nodeId === nodeId && node.nodeType === nodeType
+  );
+}
+function graphNodeForAddress(graph, address) {
+  const workflowId = address.frames[address.frames.length - 1]?.workflowId;
+  return workflowId === void 0 ? void 0 : graphNodeFor(graph, workflowId, address.nodeId, address.nodeType);
+}
+function progressVector(graph, address) {
+  const progress = [];
+  for (let index = 1; index < address.frames.length; index++) {
+    const frame = address.frames[index];
+    const parent = address.frames[index - 1];
+    if (frame.callerNodeId === void 0 || frame.callerExecutionIndex === void 0) {
+      return void 0;
+    }
+    const caller = graph.nodes.find(
+      (node2) => node2.workflowId === parent.workflowId && node2.nodeId === frame.callerNodeId
+    );
+    if (caller === void 0 || !caller.invokedWorkflows.includes(frame.workflowId)) {
+      return void 0;
+    }
+    progress.push(caller.executionOrder, frame.callerExecutionIndex, frame.invocation);
+  }
+  const lastFrameWorkflowId = address.frames[address.frames.length - 1]?.workflowId;
+  for (const scope of address.scopes) {
+    const owner = graph.nodes.find(
+      (node2) => node2.workflowId === lastFrameWorkflowId && node2.nodeId === scope.parentNodeId
+    );
+    if (owner === void 0) return void 0;
+    progress.push(owner.executionOrder, scope.loopIteration ?? scope.invocation);
+  }
+  const node = graphNodeForAddress(graph, address);
+  if (node === void 0) return void 0;
+  progress.push(node.executionOrder, address.executionIndex);
+  return progress;
+}
+function compareProgress(left, right) {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    if (left[index] !== right[index]) return left[index] - right[index];
+  }
+  return left.length - right.length;
+}
+function sameFrames(left, right) {
+  return canonicalWireValue(left) === canonicalWireValue(right);
+}
+function hasCompleteRequiredPrefix(graph, location, completed) {
+  for (let frameIndex = 0; frameIndex < location.frames.length; frameIndex++) {
+    const frame = location.frames[frameIndex];
+    const frameAddress = location.frames.slice(0, frameIndex + 1);
+    const boundaryNodeId = frameIndex === location.frames.length - 1 ? location.nodeId : location.frames[frameIndex + 1].callerNodeId;
+    if (boundaryNodeId === void 0) return false;
+    const boundaryNode = graph.nodes.find(
+      (node) => node.workflowId === frame.workflowId && node.nodeId === boundaryNodeId
+    );
+    if (boundaryNode === void 0) return false;
+    const boundaryScopeOwners = new Set(
+      frameIndex === location.frames.length - 1 ? location.scopes.map((scope) => scope.parentNodeId) : []
+    );
+    for (const predecessor of boundaryNode.predecessors) {
+      if (boundaryScopeOwners.has(predecessor.nodeId)) continue;
+      const predecessorNode = graph.nodes.find(
+        (node) => node.workflowId === frame.workflowId && node.nodeId === predecessor.nodeId
+      );
+      if (predecessorNode === void 0 || !completed.some(
+        (address) => sameFrames(address.frames, frameAddress) && address.nodeId === predecessorNode.nodeId && address.nodeType === predecessorNode.nodeType && predecessor.branchPath.every(
+          (requirement) => address.branches.some(
+            (branch) => branch.nodeId === requirement.nodeId && branch.arm === requirement.arm
+          )
+        )
+      )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function addressBelongsToGraph(graph, rootWorkflowId, address) {
+  const isScopedAddress = address.scopes.length > 0;
+  if (address.frames[0]?.workflowId !== rootWorkflowId || address.frames[0]?.invocation !== 0 || address.frames[0]?.callerNodeId !== void 0 || !isScopedAddress && address.executionIndex !== 0 || // Scopes are authenticated per-scope below (each scope's parent node must
+  // declare it) and, for a scoped node, against the node's own parentScope.
+  // A scoped durable boundary therefore carries scopes; blanket-rejecting any
+  // scope here would refuse a legitimate loop iteration's committed address.
+  address.branches.some((branch) => branch.executionIndex !== 0) || address.frames.some(
+    (frame, index) => frame.invocation !== 0 || index > 0 && frame.callerExecutionIndex !== 0
+  )) {
+    return false;
+  }
+  for (let index = 1; index < address.frames.length; index++) {
+    const frame = address.frames[index];
+    const parent = address.frames[index - 1];
+    const caller = frame.callerNodeId === void 0 ? void 0 : graph.nodes.find(
+      (node2) => node2.workflowId === parent.workflowId && node2.nodeId === frame.callerNodeId
+    );
+    if (caller === void 0 || frame.callerExecutionIndex === void 0 || !caller.invokedWorkflows.includes(frame.workflowId)) {
+      return false;
+    }
+  }
+  const workflowId = address.frames[address.frames.length - 1]?.workflowId;
+  const node = graphNodeForAddress(graph, address);
+  const graphNodeInFrames = (nodeId) => address.frames.map(
+    (frame) => graph.nodes.find((candidate) => candidate.workflowId === frame.workflowId && candidate.nodeId === nodeId)
+  ).find((candidate) => candidate !== void 0);
+  if (workflowId === void 0 || node === void 0 || address.scopes.some((scope) => {
+    const parent = graphNodeInFrames(scope.parentNodeId);
+    return parent === void 0 || !parent.scopeNames.includes(scope.scopeName);
+  }) || address.branches.some((branch) => {
+    const frame = address.frames[branch.frameDepth];
+    const owner = graph.nodes.find(
+      (candidate) => candidate.workflowId === branch.workflowId && candidate.nodeId === branch.nodeId
+    );
+    return frame === void 0 || frame.workflowId !== branch.workflowId || owner === void 0 || !owner.branchArms.includes(branch.arm);
+  })) {
+    return false;
+  }
+  for (let frameDepth = 0; frameDepth < address.frames.length; frameDepth++) {
+    const frame = address.frames[frameDepth];
+    const boundaryNodeId = frameDepth === address.frames.length - 1 ? address.nodeId : address.frames[frameDepth + 1].callerNodeId;
+    const boundaryNode = graph.nodes.find(
+      (candidate) => candidate.workflowId === frame.workflowId && candidate.nodeId === boundaryNodeId
+    );
+    const observedBranchPath = address.branches.filter((branch) => branch.frameDepth === frameDepth && branch.workflowId === frame.workflowId).map((branch) => ({ nodeId: branch.nodeId, arm: branch.arm }));
+    if (boundaryNode === void 0 || canonicalWireValue(observedBranchPath) !== canonicalWireValue(boundaryNode.branchPath)) {
+      return false;
+    }
+  }
+  if (node.parentScope !== void 0) {
+    const localScope = address.scopes[address.scopes.length - 1];
+    if (localScope === void 0 || localScope.parentNodeId !== node.parentScope.parentNodeId || localScope.scopeName !== node.parentScope.scopeName) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasConflictingBranchHistory(addresses) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const address of addresses) {
+    for (const branch of address.branches) {
+      const key = `${branch.frameDepth}\0${branch.workflowId}\0${branch.nodeId}\0${branch.executionIndex}`;
+      const prior = selected.get(key);
+      if (prior !== void 0 && prior !== branch.arm) return true;
+      selected.set(key, branch.arm);
+    }
+  }
+  return false;
+}
+function decodeContinuation(input, compatibility) {
+  let value = input;
+  try {
+    if (typeof input === "string") {
+      if (utf8ByteLength(input) > MAX_CONTINUATION_BYTES) {
+        return refusal("oversized", "continuation exceeds maximum wire size");
+      }
+      value = parseStrictJson(input, {
+        maxDepth: MAX_CONTINUATION_DEPTH,
+        maxStringBytes: MAX_CONTINUATION_STRING_BYTES,
+        maxObjectKeys: MAX_CONTINUATION_ENTRIES,
+        maxArrayItems: MAX_CONTINUATION_ENTRIES,
+        maxAggregateEntries: MAX_CONTINUATION_ENTRIES
+      });
+    }
+    validateWireValue(value);
+  } catch (error) {
+    if (error instanceof WireValidationError) {
+      return refusal(error.reason, error.message);
+    }
+    if (error instanceof StrictJsonError) {
+      return refusal(error.code, error.message);
+    }
+    return refusal("malformed", "continuation is not valid JSON");
+  }
+  if (!structurallyValidEnvelope(value)) {
+    return refusal("malformed", "continuation has missing, unknown, or invalid fields");
+  }
+  if (value.formatVersion !== CONTINUATION_FORMAT_VERSION) {
+    return refusal("unsupported-format", `unsupported continuation format ${value.formatVersion}`);
+  }
+  if (continuationChecksum(value) !== value.checksum) {
+    return refusal("checksum-mismatch", "continuation checksum does not match");
+  }
+  if (value.gateId !== durableGateId(value.runId, value.gateKind, value.location)) {
+    return refusal("malformed", "continuation gate identity does not match its execution address");
+  }
+  const graphNodes = compatibility.graph.nodes;
+  const graphNodeKeys = new Set(graphNodes.map((node) => `${node.workflowId}\0${node.nodeId}\0${node.nodeType}`));
+  const graphOrderKeys = new Set(graphNodes.map((node) => `${node.workflowId}\0${node.executionOrder}`));
+  if (graphNodeKeys.size !== graphNodes.length || graphOrderKeys.size !== graphNodes.length || graphNodes.some(
+    (node) => !Number.isSafeInteger(node.executionOrder) || node.executionOrder < -1 || new Set(node.inputPorts).size !== node.inputPorts.length || new Set(node.outputPorts).size !== node.outputPorts.length || new Set(node.scopeNames).size !== node.scopeNames.length || new Set(node.invokedWorkflows).size !== node.invokedWorkflows.length || new Set(node.branchArms).size !== node.branchArms.length || !isGraphBranchPath(node.branchPath) || new Set(node.branchPath.map((requirement) => `${requirement.nodeId}\0${requirement.arm}`)).size !== node.branchPath.length || node.branchPath.some((requirement) => {
+      const owner = graphNodes.find(
+        (candidate) => candidate.workflowId === node.workflowId && candidate.nodeId === requirement.nodeId
+      );
+      return owner === void 0 || !owner.branchArms.includes(requirement.arm);
+    }) || !Array.isArray(node.predecessors) || new Set(node.predecessors.map((predecessor) => predecessor.nodeId)).size !== node.predecessors.length || node.predecessors.some(
+      (predecessor) => typeof predecessor.nodeId !== "string" || predecessor.nodeId.length === 0 || predecessor.nodeId === node.nodeId || !isGraphBranchPath(predecessor.branchPath) || (() => {
+        const predecessorNode = graphNodes.find(
+          (candidate) => candidate.workflowId === node.workflowId && candidate.nodeId === predecessor.nodeId
+        );
+        return predecessorNode === void 0 || predecessorNode.executionOrder >= node.executionOrder || canonicalWireValue(predecessor.branchPath) !== canonicalWireValue(predecessorNode.branchPath) || predecessor.branchPath.some(
+          (requirement) => !node.branchPath.some(
+            (active) => active.nodeId === requirement.nodeId && active.arm === requirement.arm
+          )
+        );
+      })() || new Set(
+        predecessor.branchPath.map(
+          (requirement) => `${requirement.nodeId}\0${requirement.arm}`
+        )
+      ).size !== predecessor.branchPath.length || predecessor.branchPath.some((requirement) => {
+        const owner = graphNodes.find(
+          (candidate) => candidate.workflowId === node.workflowId && candidate.nodeId === requirement.nodeId
+        );
+        return typeof requirement.nodeId !== "string" || typeof requirement.arm !== "string" || owner === void 0 || !owner.branchArms.includes(requirement.arm);
+      })
+    )
+  ) || !addressBelongsToGraph(compatibility.graph, compatibility.workflowId, value.location) || graphNodeForAddress(compatibility.graph, value.location)?.durableGate !== value.gateKind) {
+    return refusal("wrong-graph", "continuation boundary is not owned by the compiled graph");
+  }
+  const completed = new Set(value.state.completed.map(executionAddressKey));
+  if (completed.size !== value.state.completed.length) {
+    return refusal("malformed", "continuation contains duplicate completed addresses");
+  }
+  if (value.state.completed.some(
+    (address) => !addressBelongsToGraph(compatibility.graph, compatibility.workflowId, address)
+  )) {
+    return refusal("wrong-graph", "continuation contains an address outside the compiled graph");
+  }
+  const boundaryProgress = progressVector(compatibility.graph, value.location);
+  if (boundaryProgress === void 0 || value.state.completed.some((address) => {
+    const completedProgress = progressVector(compatibility.graph, address);
+    return completedProgress === void 0 || compareProgress(completedProgress, boundaryProgress) >= 0;
+  }) || hasConflictingBranchHistory([...value.state.completed, value.location])) {
+    return refusal(
+      "wrong-graph",
+      "continuation completed state is not a valid execution prefix before its boundary"
+    );
+  }
+  if (!hasCompleteRequiredPrefix(compatibility.graph, value.location, value.state.completed)) {
+    return refusal("wrong-graph", "continuation is missing a required compiled predecessor before its boundary");
+  }
+  const variableKeys = /* @__PURE__ */ new Set();
+  for (const variable of value.state.variables) {
+    const address = executionAddressKey(variable.address);
+    const key = `${address}\0${variable.portName}`;
+    const graphNode = graphNodeForAddress(compatibility.graph, variable.address);
+    if (!completed.has(address) || variableKeys.has(key) || graphNode === void 0 || !graphNode.outputPorts.includes(variable.portName)) {
+      return refusal(
+        "wrong-graph",
+        `continuation variable ${variable.address.frames[variable.address.frames.length - 1]?.workflowId}.${variable.address.nodeId}.${variable.portName} is not a unique graph-owned output of a completed address`
+      );
+    }
+    variableKeys.add(key);
+  }
+  const receiptAddresses = /* @__PURE__ */ new Set();
+  for (const receipt of value.receipts) {
+    const address = executionAddressKey(receipt.address);
+    if (receiptAddresses.has(address) || !completed.has(address) || graphNodeForAddress(compatibility.graph, receipt.address)?.durableEffect !== true || receipt.operationKey !== operationKey(value.runId, receipt.address)) {
+      return refusal(
+        "malformed",
+        "continuation effect receipts must be unique, completed, and match their operation identity"
+      );
+    }
+    receiptAddresses.add(address);
+  }
+  if (value.state.completed.some(
+    (address) => graphNodeForAddress(compatibility.graph, address)?.durableEffect === true && !receiptAddresses.has(executionAddressKey(address))
+  )) {
+    return refusal("malformed", "every completed effect requires its exact durable receipt");
+  }
+  if (value.engineVersion !== (compatibility.engineVersion ?? VERSION)) {
+    return refusal("incompatible-engine", "continuation engine version does not match");
+  }
+  if (value.generatorAbi !== (compatibility.generatorAbi ?? GENERATOR_ABI)) {
+    return refusal("incompatible-generator", "continuation generator ABI does not match");
+  }
+  if (value.runId !== compatibility.runId) {
+    return refusal("wrong-run", "continuation belongs to another run");
+  }
+  if (value.workflowId !== compatibility.workflowId) {
+    return refusal("wrong-workflow", "continuation belongs to another workflow");
+  }
+  if (value.bundleDigest !== compatibility.bundleDigest) {
+    return refusal("wrong-bundle", "continuation belongs to another bundle");
+  }
+  if (value.graphFingerprint !== compatibility.graphFingerprint) {
+    return refusal("wrong-graph", "continuation belongs to another workflow graph");
+  }
+  if (compatibility.gateId !== void 0 && value.gateId !== compatibility.gateId) {
+    return refusal("stale-gate", "continuation gate is stale or reordered");
+  }
+  return acceptContinuation(value, {
+    runId: compatibility.runId,
+    workflowId: compatibility.workflowId,
+    ...compatibility.gateId === void 0 ? {} : { gateId: compatibility.gateId }
+  });
+}
+
+// src/runtime/durable-execution.ts
+function acceptGateResolution(resolution) {
+  if (resolution === void 0) return void 0;
+  validateWireValue(resolution);
+  const keys = Object.keys(resolution).sort();
+  if (keys.length !== 2 || keys[0] !== "gateId" || keys[1] !== "value" || !/^[0-9a-f]{64}$/.test(resolution.gateId)) {
+    throw new Error("resolution must contain exactly a canonical gateId and wire value");
+  }
+  return cloneAndFreezeWireValue(resolution);
+}
+function mockedGateAnswer(mocks, boundary) {
+  if (!mocks) return void 0;
+  const { nodeId, nodeType } = boundary;
+  const pick = (section, key) => {
+    if (!section) return void 0;
+    if (key !== void 0 && section[`${nodeId}:${key}`] !== void 0) return section[`${nodeId}:${key}`];
+    if (section[`${nodeId}:*`] !== void 0) return section[`${nodeId}:*`];
+    return key !== void 0 ? section[key] : void 0;
+  };
+  const firstInput = () => {
+    const p = boundary.payload;
+    const v = p?.arguments?.[0]?.value;
+    return v === void 0 || v === null ? void 0 : String(v);
+  };
+  let data = mocks.gates?.[nodeId];
+  if (data === void 0 && nodeType === "waitForAgent") {
+    const v = pick(mocks.agents, firstInput());
+    if (v !== void 0) data = { agentResult: v };
+  }
+  if (data === void 0 && nodeType === "waitForEvent") {
+    const v = pick(mocks.events, firstInput());
+    if (v !== void 0) data = { eventData: v };
+  }
+  if (data === void 0 && nodeType === "sleep" && mocks.fast === true) {
+    data = { wokeAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  if (data === void 0 || typeof data !== "object") return void 0;
+  const value = { onSuccess: true, onFailure: false, ...data };
+  validateWireValue(value);
+  return value;
+}
+var DurableGateYield = class extends Error {
+  constructor(gate, state, receipts, continuation) {
+    super(`Workflow yielded at ${gate.kind} gate "${gate.id}"`);
+    this.gate = gate;
+    this.state = state;
+    this.receipts = receipts;
+    this.continuation = continuation;
+    this.name = "DurableGateYield";
+  }
+  gate;
+  state;
+  receipts;
+  continuation;
+  code = "FLOW_WEAVER_DURABLE_GATE_YIELD";
+};
+var AmbiguousEffectError = class extends Error {
+  constructor(operationKey2, address) {
+    super(`Effect "${operationKey2}" has an ambiguous commit state`);
+    this.operationKey = operationKey2;
+    this.address = address;
+    this.name = "AmbiguousEffectError";
+  }
+  operationKey;
+  address;
+  code = "FLOW_WEAVER_AMBIGUOUS_EFFECT";
+};
+function durableAddressKey(address) {
+  return executionAddressKey(address);
+}
+function durableVariableKey(address, portName) {
+  return `${executionAddressKey(address)}\0${portName}`;
+}
+function cloneExecutionAddress(address) {
+  return {
+    frames: address.frames.map((frame) => ({ ...frame })),
+    scopes: address.scopes.map((scope) => ({ ...scope })),
+    branches: address.branches.map((branch) => ({ ...branch })),
+    nodeId: address.nodeId,
+    nodeType: address.nodeType,
+    executionIndex: address.executionIndex
+  };
+}
+function isCanonicalPrefix(candidate, current) {
+  return candidate.length <= current.length && canonicalWireValue(candidate) === canonicalWireValue(current.slice(0, candidate.length));
+}
+function isCanonicalEqual(left, right) {
+  return left.length === right.length && canonicalWireValue(left) === canonicalWireValue(right);
+}
+function requireEffectRecovery(value, key, address) {
+  try {
+    validateWireValue(value);
+  } catch {
+    throw new AmbiguousEffectError(key, address);
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AmbiguousEffectError(key, address);
+  }
+  const record = value;
+  const kind = record.kind;
+  if ((kind === "not-committed" || kind === "repeatable" || kind === "ambiguous") && Object.keys(record).length === 1) {
+    return { kind };
+  }
+  if (kind === "committed" && Object.keys(record).length === 3 && Object.prototype.hasOwnProperty.call(record, "receipt") && Object.prototype.hasOwnProperty.call(record, "result")) {
+    return {
+      kind,
+      receipt: record.receipt,
+      result: record.result
+    };
+  }
+  throw new AmbiguousEffectError(key, address);
+}
+function requireEffectExecution(value, key, address) {
+  try {
+    validateWireValue(value);
+  } catch {
+    throw new AmbiguousEffectError(key, address);
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AmbiguousEffectError(key, address);
+  }
+  const record = value;
+  if (Object.keys(record).length !== 2 || !Object.prototype.hasOwnProperty.call(record, "result") || !Object.prototype.hasOwnProperty.call(record, "receipt")) {
+    throw new AmbiguousEffectError(key, address);
+  }
+  return {
+    result: record.result,
+    receipt: record.receipt
+  };
+}
+var DurableExecution = class {
+  constructor(runId, workflowId, continuation, resolution, bundleDigest) {
+    this.runId = runId;
+    this.workflowId = workflowId;
+    if (continuation !== void 0) {
+      assertAcceptedContinuation(continuation);
+      if (continuation.runId !== runId) {
+        throw new Error("accepted continuation belongs to another run");
+      }
+      if (continuation.workflowId !== workflowId) {
+        throw new Error("accepted continuation belongs to another workflow");
+      }
+    }
+    if (bundleDigest !== void 0 && !/^sha256:[0-9a-f]{64}$/.test(bundleDigest)) {
+      throw new Error("bundleDigest must use canonical sha256:<64hex> form");
+    }
+    this.givenBundleDigest = bundleDigest;
+    this.resumeEnvelope = continuation;
+    this.resolution = acceptGateResolution(resolution);
+    for (const address of continuation?.state.completed ?? []) {
+      this.completed.set(durableAddressKey(address), cloneExecutionAddress(address));
+    }
+    for (const variable of continuation?.state.variables ?? []) {
+      this.variables.set(durableVariableKey(variable.address, variable.portName), {
+        address: cloneExecutionAddress(variable.address),
+        portName: variable.portName,
+        value: variable.value
+      });
+    }
+    for (const receipt of continuation?.receipts ?? []) {
+      this.receipts.set(durableAddressKey(receipt.address), {
+        address: cloneExecutionAddress(receipt.address),
+        operationKey: receipt.operationKey,
+        receipt: receipt.receipt
+      });
+    }
+  }
+  runId;
+  workflowId;
+  completed = /* @__PURE__ */ new Map();
+  variables = /* @__PURE__ */ new Map();
+  receipts = /* @__PURE__ */ new Map();
+  resumeEnvelope;
+  resolution;
+  givenBundleDigest;
+  graphFingerprint;
+  resolutionConsumed = false;
+  address(runtime, nodeId, nodeType, executionIndex) {
+    return {
+      frames: runtime.frames.map((frame) => ({ ...frame })),
+      scopes: runtime.scopes.map((scope) => ({ ...scope })),
+      branches: runtime.branches.map((branch) => ({ ...branch })),
+      nodeId,
+      nodeType,
+      executionIndex
+    };
+  }
+  /**
+   * The artifact identity this run executes under: the one the coordinator
+   * gave, or one derived from the graph identity the body declared. Known
+   * only after `bind`.
+   */
+  bundleDigest() {
+    if (this.givenBundleDigest !== void 0) return this.givenBundleDigest;
+    if (this.graphFingerprint === void 0) return void 0;
+    return `sha256:${sha256Hex(`flow-weaver-inline\0${this.workflowId}\0${this.graphFingerprint}\0${ENGINE_VERSION}`)}`;
+  }
+  bind(runtime, workflowId, graphFingerprint) {
+    if (runtime.frames.length !== 1) return;
+    if (workflowId !== this.workflowId) {
+      throw new Error(`runtime was created for workflow "${this.workflowId}" but "${workflowId}" is running on it`);
+    }
+    this.graphFingerprint = graphFingerprint;
+    if (this.resumeEnvelope === void 0) return;
+    if (this.resumeEnvelope.graphFingerprint !== graphFingerprint) {
+      const error = new Error("continuation belongs to another workflow graph");
+      error.name = "ContinuationMismatchError";
+      throw error;
+    }
+    const bundleDigest = this.bundleDigest();
+    if (bundleDigest !== void 0 && this.resumeEnvelope.bundleDigest !== bundleDigest) {
+      const error = new Error("continuation belongs to another bundle");
+      error.name = "ContinuationMismatchError";
+      throw error;
+    }
+  }
+  shouldExecute(address) {
+    return !this.completed.has(durableAddressKey(address));
+  }
+  commitNode(address) {
+    this.completed.set(durableAddressKey(address), cloneExecutionAddress(address));
+  }
+  setVariable(address, portName, value) {
+    this.variables.set(durableVariableKey(address, portName), {
+      address: cloneExecutionAddress(address),
+      portName,
+      value
+    });
+  }
+  getVariable(address, portName, allowAncestorLookup = true) {
+    const exact = this.variables.get(durableVariableKey(address, portName));
+    if (exact !== void 0) return exact.value;
+    if (!allowAncestorLookup) return void 0;
+    const candidates = [...this.variables.values()].filter(
+      (variable) => variable.portName === portName && variable.address.nodeId === address.nodeId && variable.address.nodeType === address.nodeType && variable.address.executionIndex === address.executionIndex && isCanonicalPrefix(variable.address.frames, address.frames) && isCanonicalPrefix(variable.address.scopes, address.scopes) && isCanonicalPrefix(variable.address.branches, address.branches)
+    ).sort(
+      (left, right) => right.address.frames.length + right.address.scopes.length + right.address.branches.length - (left.address.frames.length + left.address.scopes.length + left.address.branches.length)
+    );
+    const specificity = (candidate) => candidate.address.frames.length + candidate.address.scopes.length + candidate.address.branches.length;
+    if (candidates.length > 1 && specificity(candidates[0]) === specificity(candidates[1])) {
+      throw new Error(`Ambiguous durable variable address for ${address.nodeId}.${portName}`);
+    }
+    if (candidates[0] !== void 0) return candidates[0].value;
+    const converged = [...this.variables.values()].filter(
+      (variable) => variable.portName === portName && variable.address.nodeId === address.nodeId && variable.address.nodeType === address.nodeType && variable.address.executionIndex === address.executionIndex && isCanonicalEqual(variable.address.frames, address.frames) && isCanonicalEqual(variable.address.scopes, address.scopes) && isCanonicalPrefix(address.branches, variable.address.branches)
+    );
+    if (converged.length > 1) {
+      throw new Error(`Ambiguous durable variable address for ${address.nodeId}.${portName}`);
+    }
+    return converged[0]?.value;
+  }
+  resolveGate(runtime, boundary) {
+    validateWireValue(boundary.payload);
+    const mocked = mockedGateAnswer(runtime.services.mocks, boundary);
+    if (mocked !== void 0) return mocked;
+    const address = this.address(runtime, boundary.nodeId, boundary.nodeType, boundary.executionIndex);
+    const id = durableGateId(this.runId, boundary.kind, address);
+    if (this.resumeEnvelope !== void 0 && !this.resolutionConsumed) {
+      if (durableAddressKey(this.resumeEnvelope.location) !== durableAddressKey(address) || this.resumeEnvelope.gateId !== id || this.resumeEnvelope.gateKind !== boundary.kind || this.resolution === void 0 || this.resolution.gateId !== id) {
+        const error = new Error("Gate resolution is stale, reordered, or does not match the resume boundary");
+        error.name = "StaleGateError";
+        throw error;
+      }
+      validateWireValue(this.resolution.value);
+      this.resolutionConsumed = true;
+      return this.resolution.value;
+    }
+    if (this.resumeEnvelope !== void 0 && durableAddressKey(this.resumeEnvelope.location) === durableAddressKey(address)) {
+      const error = new Error("The consumed resume gate was re-entered");
+      error.name = "StaleGateError";
+      throw error;
+    }
+    const gate = {
+      id,
+      kind: boundary.kind,
+      address,
+      payload: boundary.payload
+    };
+    const state = this.snapshot(address);
+    const receipts = [...this.receipts.values()];
+    const bundleDigest = this.bundleDigest();
+    const continuation = this.graphFingerprint === void 0 || bundleDigest === void 0 ? void 0 : createContinuationEnvelope({
+      runId: this.runId,
+      gateId: id,
+      gateKind: boundary.kind,
+      workflowId: this.workflowId,
+      bundleDigest,
+      graphFingerprint: this.graphFingerprint,
+      location: address,
+      state,
+      receipts
+    });
+    throw new DurableGateYield(gate, state, receipts, continuation);
+  }
+  async executeEffect(runtime, boundary, execute) {
+    const address = this.address(runtime, boundary.nodeId, boundary.nodeType, boundary.executionIndex);
+    const key = operationKey(this.runId, address);
+    const committed = this.receipts.get(durableAddressKey(address));
+    if (committed !== void 0) {
+      throw new Error(`Committed effect "${key}" reached its execution body`);
+    }
+    let recovery;
+    try {
+      recovery = await runtime.services.effectAdapter?.recover(key, address);
+    } catch {
+      throw new AmbiguousEffectError(key, address);
+    }
+    if (recovery === void 0) {
+      throw new AmbiguousEffectError(key, address);
+    }
+    recovery = requireEffectRecovery(recovery, key, address);
+    if (recovery.kind === "ambiguous") throw new AmbiguousEffectError(key, address);
+    if (recovery.kind === "committed") {
+      this.receipts.set(durableAddressKey(address), {
+        address: cloneExecutionAddress(address),
+        operationKey: key,
+        receipt: recovery.receipt
+      });
+      return recovery.result;
+    }
+    let executed;
+    try {
+      executed = requireEffectExecution(await execute(key), key, address);
+    } catch (error) {
+      let afterFailure;
+      try {
+        afterFailure = await runtime.services.effectAdapter?.recover(key, address) ?? { kind: "ambiguous" };
+      } catch {
+        throw new AmbiguousEffectError(key, address);
+      }
+      afterFailure = requireEffectRecovery(afterFailure, key, address);
+      if (afterFailure.kind === "committed") {
+        this.receipts.set(durableAddressKey(address), {
+          address: cloneExecutionAddress(address),
+          operationKey: key,
+          receipt: afterFailure.receipt
+        });
+        return afterFailure.result;
+      }
+      if (afterFailure.kind === "ambiguous") {
+        throw new AmbiguousEffectError(key, address);
+      }
+      throw error;
+    }
+    if (runtime.services.effectAdapter?.commit !== void 0) {
+      try {
+        await runtime.services.effectAdapter.commit(key, address, executed);
+      } catch {
+        let committed2;
+        try {
+          committed2 = requireEffectRecovery(
+            await runtime.services.effectAdapter.recover(key, address),
+            key,
+            address
+          );
+        } catch {
+          throw new AmbiguousEffectError(key, address);
+        }
+        if (committed2.kind !== "committed" || canonicalWireValue(committed2.receipt) !== canonicalWireValue(executed.receipt) || canonicalWireValue(committed2.result) !== canonicalWireValue(executed.result)) throw new AmbiguousEffectError(key, address);
+        this.receipts.set(durableAddressKey(address), {
+          address: cloneExecutionAddress(address),
+          operationKey: key,
+          receipt: committed2.receipt
+        });
+        return committed2.result;
+      }
+    }
+    this.receipts.set(durableAddressKey(address), {
+      address: cloneExecutionAddress(address),
+      operationKey: key,
+      receipt: executed.receipt
+    });
+    return executed.result;
+  }
+  snapshot(nextBoundary) {
+    const completedKeys = new Set(this.completed.keys());
+    return {
+      completed: [...this.completed.values()].map(cloneExecutionAddress),
+      variables: [...this.variables.values()].filter((variable) => completedKeys.has(durableAddressKey(variable.address))).map((variable) => {
+        try {
+          validateWireValue(variable.value);
+        } catch (error) {
+          throw new Error(
+            `Continuation variable ${variable.address.nodeId}.${variable.portName} is not a wire value: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        return {
+          address: cloneExecutionAddress(variable.address),
+          portName: variable.portName,
+          value: variable.value
+        };
+      }),
+      nextBoundary: cloneExecutionAddress(nextBoundary)
+    };
+  }
+  assertResumeResolutionConsumed() {
+    if (this.resumeEnvelope !== void 0 && !this.resolutionConsumed) {
+      const error = new Error("Resumed execution completed or yielded without consuming its exact gate resolution");
+      error.name = "UnconsumedGateResolutionError";
+      throw error;
+    }
+  }
+};
+function createWorkflowRuntime(options) {
+  if (options.runId.trim().length === 0) {
+    throw new Error("runId must be a non-empty coordinator-owned identity");
+  }
+  const rootFrame = {
+    workflowId: options.workflowId,
+    invocation: 0
+  };
+  return {
+    runId: options.runId,
+    abortSignal: options.abortSignal,
+    services: options.services ?? {},
+    durable: new DurableExecution(
+      options.runId,
+      options.workflowId,
+      options.continuation,
+      options.resolution,
+      options.bundleDigest
+    ),
+    frames: [rootFrame],
+    scopes: [],
+    branches: []
+  };
+}
+function isDurableGateYield(error) {
+  return error instanceof DurableGateYield || typeof error === "object" && error !== null && error.code === "FLOW_WEAVER_DURABLE_GATE_YIELD";
+}
+function isAmbiguousEffectError(error) {
+  return error instanceof AmbiguousEffectError || typeof error === "object" && error !== null && error.code === "FLOW_WEAVER_AMBIGUOUS_EFFECT";
+}
+
+// src/mcp/workflow-executor.ts
+var ContinuationRefusalError = class extends Error {
+  constructor(refusal2) {
+    super(refusal2.message);
+    this.refusal = refusal2;
+  }
+  refusal;
+  name = "ContinuationRefusalError";
+};
+async function executeWorkflow(request) {
+  const {
+    runId,
+    bundleDigest,
+    filePath,
+    params,
+    workflowName,
+    production: requestedProduction,
+    includeTrace: requestedIncludeTrace,
+    mocks,
+    debugController,
+    onEvent,
+    externalNodeTypes,
+    abortSignal,
+    continuation,
+    resolution,
+    effectAdapter
+  } = request;
+  if (runId.trim().length === 0) {
+    throw new Error("runId must be a non-empty coordinator-owned identity");
+  }
+  if (bundleDigest !== void 0 && !/^sha256:[0-9a-f]{64}$/.test(bundleDigest)) {
+    throw new Error("bundleDigest must use canonical sha256:<64hex> form");
+  }
+  const acceptedResolution = acceptGateResolution(resolution);
+  if (abortSignal?.aborted) throw new CancellationError();
+  const resolvedPath = path.resolve(filePath);
+  const includeTrace = requestedIncludeTrace !== false;
+  const tmpId = `fw-exec-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const tmpBase = path.join(path.dirname(resolvedPath), tmpId);
+  const tmpTsFile = `${tmpBase}.ts`;
+  const tmpFile = `${tmpBase}.mjs`;
+  try {
+    fs2.copyFileSync(resolvedPath, tmpTsFile);
+    const source = fs2.readFileSync(resolvedPath, "utf8");
+    const allWorkflows = getAvailableWorkflows(source);
+    if (allWorkflows.length === 0) {
+      throw new Error("No workflow definition found in file");
+    }
+    const selectedWorkflow = workflowName ? allWorkflows.find((workflow) => workflow.functionName === workflowName) : allWorkflows[0];
+    if (!selectedWorkflow) {
+      throw new Error(`Workflow "${workflowName}" not found in file. Available: ${allWorkflows.map((w) => w.functionName).join(", ")}`);
+    }
+    const effectiveWorkflowId = selectedWorkflow.functionName;
+    const parsed = await parseWorkflow(resolvedPath, {
+      workflowName: effectiveWorkflowId,
+      projectDir: path.dirname(resolvedPath),
+      externalNodeTypes
+    });
+    if (parsed.errors.length > 0) {
+      throw new Error(`Cannot fingerprint invalid workflow: ${parsed.errors.join("; ")}`);
+    }
+    const { capabilities, graphFingerprint, continuationGraph } = graphIdentity(
+      parsed.ast,
+      parsed.allWorkflows
+    );
+    if (capabilities.gate && bundleDigest === void 0) {
+      throw new ContinuationRefusalError({
+        accepted: false,
+        reason: "wrong-bundle",
+        message: "a workflow graph with durable gates requires coordinator-verified whole-bundle identity before execution"
+      });
+    }
+    if (capabilities.gate && capabilities.effect && effectAdapter === void 0) {
+      throw new ContinuationRefusalError({
+        accepted: false,
+        reason: "ambiguous-effect",
+        message: "a durable-gate graph with effects requires an operation-key recovery adapter before execution"
+      });
+    }
+    validateDurableClosure(parsed.ast, parsed.allWorkflows);
+    let acceptedContinuation;
+    if (continuation !== void 0) {
+      if (bundleDigest === void 0) {
+        throw new ContinuationRefusalError({
+          accepted: false,
+          reason: "wrong-bundle",
+          message: "durable resume requires coordinator-verified whole-bundle identity"
+        });
+      }
+      const decoded = decodeContinuation(continuation, {
+        runId,
+        workflowId: effectiveWorkflowId,
+        bundleDigest,
+        graphFingerprint,
+        gateId: acceptedResolution?.gateId,
+        graph: continuationGraph
+      });
+      if (!decoded.accepted) throw new ContinuationRefusalError(decoded);
+      if (acceptedResolution === void 0) {
+        throw new ContinuationRefusalError({
+          accepted: false,
+          reason: "stale-gate",
+          message: "a continuation resume requires its exact gate resolution"
+        });
+      }
+      acceptedContinuation = decoded.envelope;
+      for (const receipt of acceptedContinuation.receipts) {
+        const receiptWorkflowId = receipt.address.frames.at(-1)?.workflowId;
+        const receiptNode = continuationGraph.nodes.find(
+          (node) => node.workflowId === receiptWorkflowId && node.nodeId === receipt.address.nodeId && node.nodeType === receipt.address.nodeType
+        );
+        let recovery;
+        try {
+          recovery = requireEffectRecovery(
+            await effectAdapter?.recover(receipt.operationKey, receipt.address),
+            receipt.operationKey,
+            receipt.address
+          );
+        } catch {
+          recovery = { kind: "ambiguous" };
+        }
+        const recordedResult = Object.fromEntries(
+          acceptedContinuation.state.variables.filter(
+            (variable) => canonicalWireValue(variable.address) === canonicalWireValue(receipt.address) && receiptNode?.outputPorts.includes(variable.portName) === true
+          ).map((variable) => [variable.portName, variable.value])
+        );
+        if (recovery?.kind !== "committed" || canonicalWireValue(recovery.receipt) !== canonicalWireValue(receipt.receipt) || canonicalWireValue(recovery.result) !== canonicalWireValue(recordedResult)) {
+          throw new ContinuationRefusalError({
+            accepted: false,
+            reason: "ambiguous-effect",
+            message: "a completed effect continuation must be re-attested by its operation-key adapter"
+          });
+        }
+      }
+    } else if (acceptedResolution !== void 0) {
+      throw new ContinuationRefusalError({
+        accepted: false,
+        reason: "stale-gate",
+        message: "a gate resolution cannot be supplied without a continuation"
+      });
+    }
+    const production = debugController ? false : requestedProduction ?? !includeTrace;
+    for (const wf of allWorkflows) {
+      await compileWorkflow(tmpTsFile, {
+        write: true,
+        inPlace: true,
+        // Forward caller-supplied foreign nodeType definitions so a
+        // workflow that references a node from another package (an
+        // `@node <id> <foreignType>` the file doesn't declare, e.g.
+        // pack-core's `waitForApproval`) resolves its real ports during
+        // the executor's own compile. Without this the internal parse
+        // can't see those nodeTypes and falls back to a stub, failing
+        // validation. Callers that resolve foreign defs from a wire
+        // manifest (no node_modules to read a .d.ts) pass them here.
+        parse: { workflowName: wf.functionName, externalNodeTypes },
+        generate: { production }
+      });
+    }
+    const compiledCode = fs2.readFileSync(tmpTsFile, "utf8");
+    const jsOutput = ts.transpileModule(compiledCode, {
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ESNext,
+        esModuleInterop: true
+      }
+    });
+    const transpiledOutput = rewriteSrcImportsToDist(jsOutput.outputText, path.dirname(tmpTsFile));
+    fs2.writeFileSync(tmpFile, transpiledOutput, "utf8");
+    const trace = [];
+    const debugger_ = includeTrace ? {
+      sendEvent: (event) => {
+        const traceEvent = {
+          type: event.type || "UNKNOWN",
+          timestamp: Date.now(),
+          data: event
+        };
+        trace.push(traceEvent);
+        onEvent?.(traceEvent);
+      },
+      innerFlowInvocation: false
+    } : void 0;
+    const mod = await import(pathToFileURL(tmpFile).href);
+    const workflowRegistry = {};
+    for (const workflow of parsed.allWorkflows) {
+      const value = mod[workflow.functionName];
+      if (typeof value === "function") {
+        workflowRegistry[workflow.functionName] = value;
+      }
+    }
+    const services = {
+      debugger: debugger_,
+      debugController,
+      mocks,
+      effectAdapter,
+      workflowRegistry
+    };
+    const runtime = createWorkflowRuntime({
+      runId,
+      workflowId: effectiveWorkflowId,
+      abortSignal,
+      services,
+      continuation: acceptedContinuation,
+      resolution: acceptedResolution,
+      bundleDigest
+    });
+    const exportedFn = findExportedFunction(mod, effectiveWorkflowId);
+    if (!exportedFn) {
+      const available = Object.entries(mod).filter(([k, v]) => k !== "__esModule" && typeof v === "function").map(([k]) => k);
+      const availStr = available.length > 0 ? `. Available: ${available.join(", ")}` : "";
+      throw new Error(
+        workflowName ? `Workflow "${workflowName}" not found in file${availStr}` : `No exported workflow function found in file${availStr}`
+      );
+    }
+    const startTime = Date.now();
+    if (abortSignal?.aborted) throw new CancellationError();
+    try {
+      const result = await exportedFn.fn(true, params ?? {}, runtime);
+      runtime.durable.assertResumeResolutionConsumed();
+      const executionTime = Date.now() - startTime;
+      return {
+        kind: "completed",
+        result,
+        functionName: exportedFn.name,
+        executionTime,
+        ...includeTrace && { trace, summary: computeTraceSummary(trace) }
+      };
+    } catch (error) {
+      if (isDurableGateYield(error)) {
+        if (bundleDigest === void 0) {
+          throw new ContinuationRefusalError({
+            accepted: false,
+            reason: "wrong-bundle",
+            message: "durable yield requires coordinator-verified whole-bundle identity"
+          });
+        }
+        runtime.durable.assertResumeResolutionConsumed();
+        const executionTime = Date.now() - startTime;
+        return {
+          kind: "yielded",
+          gate: error.gate,
+          continuation: createContinuationEnvelope({
+            runId,
+            gateId: error.gate.id,
+            gateKind: error.gate.kind,
+            workflowId: effectiveWorkflowId,
+            bundleDigest,
+            graphFingerprint,
+            location: error.gate.address,
+            state: error.state,
+            receipts: error.receipts
+          }),
+          functionName: exportedFn.name,
+          executionTime,
+          ...includeTrace && { trace, summary: computeTraceSummary(trace) }
+        };
+      }
+      if (isAmbiguousEffectError(error)) {
+        throw new ContinuationRefusalError({
+          accepted: false,
+          reason: "ambiguous-effect",
+          message: error.message
+        });
+      }
+      throw error;
+    }
+  } finally {
+    try {
+      fs2.unlinkSync(tmpFile);
+    } catch {
+    }
+    try {
+      fs2.unlinkSync(tmpTsFile);
+    } catch {
+    }
+  }
+}
+function computeTraceSummary(trace) {
+  if (trace.length === 0) {
+    return { totalNodes: 0, succeeded: 0, failed: 0, cancelled: 0, nodeTimings: [], totalDurationMs: 0 };
+  }
+  const nodeStartTimes = /* @__PURE__ */ new Map();
+  const nodeFinalStatus = /* @__PURE__ */ new Map();
+  const nodeTimings = [];
+  for (const event of trace) {
+    if (event.type !== "STATUS_CHANGED" || !event.data) continue;
+    const id = event.data.id;
+    const status = event.data.status;
+    if (!id || !status) continue;
+    if (status === "RUNNING") {
+      nodeStartTimes.set(id, event.timestamp);
+    }
+    if (status === "SUCCEEDED" || status === "FAILED" || status === "CANCELLED") {
+      nodeFinalStatus.set(id, status);
+      const startTime = nodeStartTimes.get(id);
+      if (startTime !== void 0) {
+        nodeTimings.push({ nodeId: id, durationMs: event.timestamp - startTime });
+      }
+    }
+  }
+  let succeeded = 0;
+  let failed = 0;
+  let cancelled = 0;
+  for (const status of nodeFinalStatus.values()) {
+    if (status === "SUCCEEDED") succeeded++;
+    else if (status === "FAILED") failed++;
+    else if (status === "CANCELLED") cancelled++;
+  }
+  const totalDurationMs = trace[trace.length - 1].timestamp - trace[0].timestamp;
+  return {
+    totalNodes: nodeFinalStatus.size,
+    succeeded,
+    failed,
+    cancelled,
+    nodeTimings,
+    totalDurationMs
+  };
+}
+function findExportedFunction(mod, preferredName) {
+  if (preferredName && typeof mod[preferredName] === "function") {
+    return { name: preferredName, fn: mod[preferredName] };
+  }
+  for (const [key, value] of Object.entries(mod)) {
+    if (key === "__esModule") continue;
+    if (typeof value === "function") {
+      return { name: key, fn: value };
+    }
+  }
+  return null;
+}
+
+export {
+  CancellationError,
+  ContinuationRefusalError,
+  executeWorkflow,
+  computeTraceSummary
+};