@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/api/in-place/workflow-jsdoc.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Workflow JSDoc.
+ *
+ * Decides the `@flowWeaver workflow` comment above the workflow function:
+ * workflow options, pack deploy tags, `@fwImport` lines, `@node` instances,
+ * macros (authored ones that still hold, plus `@path` chains detected in the
+ * connections), the `@connect` lines no macro or expression already implies,
+ * `@param`/`@returns` ports, and scopes. Only the comment is replaced; the
+ * function is left alone.
+ */
+import type { TWorkflowAST } from '../../ast/types';
+import { type SourceEdit } from './source-file';
+/**
+ * Replace the workflow function's JSDoc comment with updated annotations
+ */
+export declare function replaceWorkflowJSDoc(source: string, ast: TWorkflowAST, options?: {
+    skipParamReturns?: boolean;
+}): SourceEdit;
+//# sourceMappingURL=workflow-jsdoc.d.ts.map

package/dist/api/index.d.ts

@@ -29,25 +29,22 @@
  * - **Manipulation**: `addNode()`, `removeNode()`, `addConnection()`, etc.
  * - **Builder**: `WorkflowBuilder` for programmatic AST construction
  */
-export type { TWorkflowAST, TNodeTypeDefaultConfig, TNodeTypeAST, TNodeInstanceConfig, TNodeInstanceAST, TConnectionAST, TPortReference, TImportDeclaration, TImportSpecifier, TPortDefinition, TDataType, TSerializableValue, TSerializableObject, TSerializableArray, TExecuteWhen, TBranchingStrategy, TWorkflowMetadata, TNodeMetadata, TConnectionMetadata, TSourceLocation, TControlFlowGraph, TControlFlowEdge, TValidationError, TAnalysisResult, TBranchingNodeInfo, TBranchRegion, TMergeNodeInfo, TASTTransformer, TASTVisitor, TParseOptions, TValidationRule, TGenerateOptions, TCompileResult, TCompilationMetadata, } from '../ast/types.js';
-export { type CompileOptions, compileWorkflow } from './compile.js';
-export { type GenerateResult, generateCode } from './generate.js';
-export { type InPlaceGenerateOptions, type InPlaceGenerateResult, generateInPlace, hasInPlaceMarkers, stripGeneratedSections, MARKERS, } from './generate-in-place.js';
-export { type ParseResult, parseWorkflow } from './parse.js';
-export { transformWorkflow } from './transform.js';
-export { type ValidationResult, validateWorkflow } from './validate.js';
-export { validationRuleRegistry } from './validation-registry.js';
-export * from './manipulation/index.js';
-export { applyModifyOperation, validateModifyParams } from './modify-operation.js';
-export { withValidation, withMinimalValidation, withoutValidation, type RemoveOptions, type NodeFilter, type OperationResult, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeTypeExists, assertNodeExists, assertNodeNotExists, } from './helpers.js';
-export * from './query.js';
-export * from './builder.js';
-export * from './workflow-file-operations.js';
-export * from './templates.js';
-export * from './patterns.js';
-export { type CommandResult, runCommand, getAvailableCommands } from './command-runner.js';
-export { AnnotationParser } from '../parser.js';
-export { compileTargetRegistry, type CompileTarget } from '../generator/compile-target-registry.js';
-export { devModeRegistry, type DevModeProvider, type DevModeOptions } from '../generator/dev-mode-registry.js';
-export { tagHandlerRegistry, type TagHandlerRegistry, type TTagHandlerFn, type TTagHandlerContext } from '../parser/tag-registry.js';
+export type { TWorkflowAST, TNodeTypeDefaultConfig, TNodeTypeAST, TNodeInstanceConfig, TNodeInstanceAST, TConnectionAST, TPortReference, TImportDeclaration, TImportSpecifier, TPortDefinition, TDataType, TSerializableValue, TSerializableObject, TSerializableArray, TExecuteWhen, TBranchingStrategy, TWorkflowMetadata, TNodeMetadata, TConnectionMetadata, TSourceLocation, TControlFlowGraph, TControlFlowEdge, TValidationError, TAnalysisResult, TBranchingNodeInfo, TBranchRegion, TMergeNodeInfo, TASTTransformer, TASTVisitor, TParseOptions, TValidationRule, TGenerateOptions, TCompileResult, TCompilationMetadata, } from '../ast/types';
+export { type CompileOptions, compileWorkflow } from './compile';
+export { type GenerateResult, generateCode } from './generate';
+export { type InPlaceGenerateOptions, type InPlaceGenerateResult, generateInPlace, hasInPlaceMarkers, stripGeneratedSections, MARKERS, } from './generate-in-place';
+export { type ParseResult, parseWorkflow, parseWorkflowSourceAtPath, } from './parse';
+export { transformWorkflow } from './transform';
+export { type ValidationResult, validateWorkflow } from './validate';
+export { validationRuleRegistry } from './validation-registry';
+export * from './manipulation';
+export { applyModifyOperation, validateModifyParams } from './modify-operation';
+export { withValidation, withMinimalValidation, withoutValidation, type RemoveOptions, type NodeFilter, type OperationResult, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeTypeExists, assertNodeExists, assertNodeNotExists, } from './helpers';
+export * from './query';
+export * from './builder';
+export * from './workflow-file-operations';
+export * from './templates';
+export { type CommandResult, runCommand, getAvailableCommands } from './command-runner';
+export { AnnotationParser } from '../parser/annotation-parser.js';
+export { tagHandlerRegistry, type TagHandlerRegistry, type TTagHandlerFn, type TTagHandlerContext, type TTagSerializerFn } from '../parser/tag-registry.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.js

@@ -1,53 +1,259 @@
-/**
- * @module api
- *
- * # Flow Weaver API
- *
- * High-level API for working with Flow Weaver workflows.
- *
- * ## Parse → Validate → Generate Pipeline
- *
- * ```
- * Source File (.ts)
- *       ↓
- *   parseWorkflow()     → TWorkflowAST
- *       ↓
- *   validateWorkflow()  → ValidationResult
- *       ↓
- *   generateCode()      → Executable code
- * ```
- *
- * Or use `compileWorkflow()` for all steps in one call.
- *
- * ## Key Exports
- *
- * - **Parsing**: {@link parseWorkflow}
- * - **Validation**: {@link validateWorkflow}
- * - **Generation**: {@link generateCode}, {@link generateInPlace}
- * - **Compilation**: {@link compileWorkflow}
- * - **Query**: `getNode()`, `getNodeType()`, `findConnections()`
- * - **Manipulation**: `addNode()`, `removeNode()`, `addConnection()`, etc.
- * - **Builder**: `WorkflowBuilder` for programmatic AST construction
- */
-export { compileWorkflow } from './compile.js';
-export { generateCode } from './generate.js';
-export { generateInPlace, hasInPlaceMarkers, stripGeneratedSections, MARKERS, } from './generate-in-place.js';
-export { parseWorkflow } from './parse.js';
-export { transformWorkflow } from './transform.js';
-export { validateWorkflow } from './validate.js';
-export { validationRuleRegistry } from './validation-registry.js';
-export * from './manipulation/index.js';
-export { applyModifyOperation, validateModifyParams } from './modify-operation.js';
-export { withValidation, withMinimalValidation, withoutValidation, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeTypeExists, assertNodeExists, assertNodeNotExists, } from './helpers.js';
-export * from './query.js';
-export * from './builder.js';
-export * from './workflow-file-operations.js';
-export * from './templates.js';
-export * from './patterns.js';
-export { runCommand, getAvailableCommands } from './command-runner.js';
-// Re-exports needed by export target packs
-export { AnnotationParser } from '../parser.js';
-export { compileTargetRegistry } from '../generator/compile-target-registry.js';
-export { devModeRegistry } from '../generator/dev-mode-registry.js';
-export { tagHandlerRegistry } from '../parser/tag-registry.js';
-//# sourceMappingURL=index.js.map
+import {
+  WorkflowBuilder,
+  addConnection,
+  addConnections,
+  addNode,
+  addNodeType,
+  addNodes,
+  addToScope,
+  applyModifyOperation,
+  assertNodeExists,
+  assertNodeNotExists,
+  assertNodeTypeExists,
+  cloneWorkflow,
+  createScope,
+  createWorkflow,
+  fromAST,
+  generateNodeFromTemplate,
+  generateUniqueNodeId,
+  generateWorkflowFromTemplate,
+  getAvailableCommands,
+  getNodeTemplate,
+  getNodeType,
+  getWorkflowTemplate,
+  hasNodeType,
+  listNodeTemplates,
+  listNodeTypes,
+  listWorkflowTemplates,
+  moveToScope,
+  reconnect,
+  removeAllConnections,
+  removeConnection,
+  removeFromScope,
+  removeNode,
+  removeNodeType,
+  removeNodes,
+  removeScope,
+  renameNode,
+  renameNodeType,
+  renameWorkflow,
+  replaceConnections,
+  replaceNodeTypes,
+  runCommand,
+  setInstancePortConfigs,
+  setNodeConfig,
+  setNodeLabel,
+  setNodeMinimized,
+  setNodeSize,
+  setOutputFileType,
+  setStartExitPorts,
+  setWorkflowDescription,
+  setWorkflowMetadata,
+  setWorkflowPorts,
+  swapNodeInstancePortOrder,
+  swapPortOrder,
+  transformWorkflow,
+  updateNode,
+  updateNodeType,
+  validateModifyParams,
+  withMinimalValidation,
+  withValidation,
+  withoutValidation
+} from "../chunks/chunk-7YYKTPJ5.js";
+import {
+  validateWorkflow
+} from "../chunks/chunk-P44RIZ7C.js";
+import "../chunks/chunk-ZKEGXO73.js";
+import {
+  validationRuleRegistry
+} from "../chunks/chunk-A5MBOFVY.js";
+import "../chunks/chunk-CYHYDLV4.js";
+import {
+  compileWorkflow,
+  generateCode
+} from "../chunks/chunk-F3RTZV2A.js";
+import {
+  addWorkflowToSource,
+  getAvailableWorkflows,
+  removeWorkflowFromSource,
+  toggleWorkflowExport
+} from "../chunks/chunk-YSPBPZDV.js";
+import "../chunks/chunk-VQ7H33J4.js";
+import "../chunks/chunk-HKZLQJDV.js";
+import "../chunks/chunk-NQNLUAPO.js";
+import {
+  generateInPlace
+} from "../chunks/chunk-TAIUWKZB.js";
+import {
+  parseWorkflow,
+  parseWorkflowSourceAtPath
+} from "../chunks/chunk-INDEVYEC.js";
+import "../chunks/chunk-KU3CLJI2.js";
+import "../chunks/chunk-5Y3AIUWY.js";
+import "../chunks/chunk-CZBCCK4Y.js";
+import "../chunks/chunk-AXNQRVJB.js";
+import "../chunks/chunk-O2U2LO57.js";
+import "../chunks/chunk-QDE4Z7KW.js";
+import "../chunks/chunk-XAV22WD7.js";
+import {
+  countConnections,
+  countNodeTypes,
+  countNodes,
+  findDeadEndDetails,
+  findDeadEnds,
+  findDisconnectedOutputPorts,
+  findIsolatedNodes,
+  findNodesByName,
+  findPath,
+  findUnusedNodeTypes,
+  findWorkflows,
+  formatPortReference,
+  getConnectedPorts,
+  getConnections,
+  getDataDependencies,
+  getDependencies,
+  getDependents,
+  getExecutionGroups,
+  getIncomingConnections,
+  getNode,
+  getNodes,
+  getNodesByType,
+  getNodesInScope,
+  getOutgoingConnections,
+  getTopologicalOrder,
+  getTransitiveDependencies,
+  getUnconnectedPorts,
+  hasNode,
+  isConnected,
+  portReferencesEqual,
+  validatePortReference
+} from "../chunks/chunk-P2CVDGHR.js";
+import {
+  AnnotationParser,
+  MARKERS,
+  hasInPlaceMarkers,
+  stripGeneratedSections
+} from "../chunks/chunk-ZMGN6F3S.js";
+import "../chunks/chunk-REEYC73I.js";
+import "../chunks/chunk-4EUSHAY6.js";
+import "../chunks/chunk-4KDUEOFD.js";
+import "../chunks/chunk-DUO6H5PR.js";
+import {
+  tagHandlerRegistry
+} from "../chunks/chunk-VP2P3BPA.js";
+import "../chunks/chunk-B6HQ6YS5.js";
+import "../chunks/chunk-E5WN7IGO.js";
+import "../chunks/chunk-NDSTGMKR.js";
+import "../chunks/chunk-KMWCCOUJ.js";
+import "../chunks/chunk-QYPORSLO.js";
+import "../chunks/chunk-R4QGNK34.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+export {
+  AnnotationParser,
+  MARKERS,
+  WorkflowBuilder,
+  addConnection,
+  addConnections,
+  addNode,
+  addNodeType,
+  addNodes,
+  addToScope,
+  addWorkflowToSource,
+  applyModifyOperation,
+  assertNodeExists,
+  assertNodeNotExists,
+  assertNodeTypeExists,
+  cloneWorkflow,
+  compileWorkflow,
+  countConnections,
+  countNodeTypes,
+  countNodes,
+  createScope,
+  createWorkflow,
+  findDeadEndDetails,
+  findDeadEnds,
+  findDisconnectedOutputPorts,
+  findIsolatedNodes,
+  findNodesByName,
+  findPath,
+  findUnusedNodeTypes,
+  findWorkflows,
+  formatPortReference,
+  fromAST,
+  generateCode,
+  generateInPlace,
+  generateNodeFromTemplate,
+  generateUniqueNodeId,
+  generateWorkflowFromTemplate,
+  getAvailableCommands,
+  getAvailableWorkflows,
+  getConnectedPorts,
+  getConnections,
+  getDataDependencies,
+  getDependencies,
+  getDependents,
+  getExecutionGroups,
+  getIncomingConnections,
+  getNode,
+  getNodeTemplate,
+  getNodeType,
+  getNodes,
+  getNodesByType,
+  getNodesInScope,
+  getOutgoingConnections,
+  getTopologicalOrder,
+  getTransitiveDependencies,
+  getUnconnectedPorts,
+  getWorkflowTemplate,
+  hasInPlaceMarkers,
+  hasNode,
+  hasNodeType,
+  isConnected,
+  listNodeTemplates,
+  listNodeTypes,
+  listWorkflowTemplates,
+  moveToScope,
+  parseWorkflow,
+  parseWorkflowSourceAtPath,
+  portReferencesEqual,
+  reconnect,
+  removeAllConnections,
+  removeConnection,
+  removeFromScope,
+  removeNode,
+  removeNodeType,
+  removeNodes,
+  removeScope,
+  removeWorkflowFromSource,
+  renameNode,
+  renameNodeType,
+  renameWorkflow,
+  replaceConnections,
+  replaceNodeTypes,
+  runCommand,
+  setInstancePortConfigs,
+  setNodeConfig,
+  setNodeLabel,
+  setNodeMinimized,
+  setNodeSize,
+  setOutputFileType,
+  setStartExitPorts,
+  setWorkflowDescription,
+  setWorkflowMetadata,
+  setWorkflowPorts,
+  stripGeneratedSections,
+  swapNodeInstancePortOrder,
+  swapPortOrder,
+  tagHandlerRegistry,
+  toggleWorkflowExport,
+  transformWorkflow,
+  updateNode,
+  updateNodeType,
+  validateModifyParams,
+  validatePortReference,
+  validateWorkflow,
+  validationRuleRegistry,
+  withMinimalValidation,
+  withValidation,
+  withoutValidation
+};

package/dist/api/inline-engine.generated.d.ts

@@ -0,0 +1,3 @@
+export declare const 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";
+export declare const 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";
+//# sourceMappingURL=inline-engine.generated.d.ts.map

package/dist/api/inline-runtime.d.ts

@@ -1,4 +1,11 @@
+import type { TModuleFormat } from '../ast/types';
 export type TOutputFormat = 'typescript' | 'javascript';
+/**
+ * What a compiled file exports from its runtime section besides the
+ * workflows: the durable engine's public surface, under the same names the
+ * package exports, so calling code can import them from either.
+ */
+export declare const INLINE_ENGINE_EXPORTS: readonly string[];
 /**
  * Strip TypeScript type syntax from code using esbuild.
  * Removes type declarations, interfaces, declare statements, and type annotations
@@ -15,9 +22,10 @@ export declare function stripTypeScript(code: string): string;
  * @param production - Whether to generate production-optimized code (no debug events)
  * @param exportClasses - Whether to add 'export' keyword to classes (for shared modules)
  * @param outputFormat - Output format: 'typescript' (default) or 'javascript' (strips types)
+ * @param moduleFormat - 'esm' (default) exports the engine's helpers with an `export` statement;
+ *   'cjs' leaves that to the caller's `module.exports` (see `INLINE_ENGINE_EXPORTS`)
  */
-export declare function generateInlineRuntime(production: boolean, exportClasses?: boolean, outputFormat?: TOutputFormat): string;
-import type { TModuleFormat } from '../ast/types.js';
+export declare function generateInlineRuntime(production: boolean, exportClasses?: boolean, outputFormat?: TOutputFormat, moduleFormat?: TModuleFormat): string;
 /**
  * Generates a standalone runtime module file for multi-workflow bundles.
  * This exports all runtime types and classes so individual workflow files can import them.

package/dist/api/manipulation/connections.d.ts

@@ -1,7 +1,7 @@
 /**
  * Connection operations for workflow manipulation
  */
-import type { TWorkflowAST, TConnectionAST, TPortReference } from "../../ast/types.js";
+import type { TWorkflowAST, TConnectionAST, TPortReference } from "../../ast/types";
 /**
  * Add a connection between two ports
  *

package/dist/api/manipulation/index.d.ts

@@ -12,7 +12,7 @@
  * |-------------|-----------|
  * | Workflow    | `cloneWorkflow`, `renameWorkflow`, `setWorkflowPorts` |
  * | Node Types  | `addNodeType`, `removeNodeType`, `updateNodeType` |
- * | Nodes       | `addNode`, `removeNode`, `renameNode`, `setNodePosition` |
+ * | Nodes       | `addNode`, `removeNode`, `renameNode`, `setNodeLabel` |
  * | Connections | `addConnection`, `removeConnection`, `reconnect` |
  * | Ports       | `swapPortOrder`, `swapNodeInstancePortOrder` |
  * | Scopes      | `createScope`, `removeScope`, `addToScope` |
@@ -24,11 +24,11 @@
  * - `withMinimalValidation(workflow)` - Skip expensive checks
  * - `withoutValidation(workflow)` - No validation (use with caution)
  */
-export { withoutValidation, type RemoveOptions, type NodeFilter, type OperationResult, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeExists, assertNodeNotExists, } from "../helpers.js";
-export { cloneWorkflow, setWorkflowDescription, setWorkflowMetadata, setOutputFileType, renameWorkflow, setWorkflowPorts, } from "./workflow.js";
-export { addNodeType, removeNodeType, updateNodeType, getNodeType, hasNodeType, listNodeTypes, renameNodeType, replaceNodeTypes, } from "./node-types.js";
-export { addNode, removeNode, renameNode, updateNode, addNodes, removeNodes, setNodeConfig, setNodePosition, setNodeMinimized, setNodeSize, setNodeLabel, } from "./nodes.js";
-export { addConnection, removeConnection, removeAllConnections, reconnect, addConnections, replaceConnections, } from "./connections.js";
-export { swapPortOrder, swapNodeInstancePortOrder, setStartExitPorts, setInstancePortConfigs, } from "./ports.js";
-export { createScope, removeScope, addToScope, removeFromScope, moveToScope, } from "./scopes.js";
+export { withoutValidation, type RemoveOptions, type NodeFilter, type OperationResult, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeExists, assertNodeNotExists, } from "../helpers";
+export { cloneWorkflow, setWorkflowDescription, setWorkflowMetadata, setOutputFileType, renameWorkflow, setWorkflowPorts, } from "./workflow";
+export { addNodeType, removeNodeType, updateNodeType, getNodeType, hasNodeType, listNodeTypes, renameNodeType, replaceNodeTypes, } from "./node-types";
+export { addNode, removeNode, renameNode, updateNode, addNodes, removeNodes, setNodeConfig, setNodeMinimized, setNodeSize, setNodeLabel, } from "./nodes";
+export { addConnection, removeConnection, removeAllConnections, reconnect, addConnections, replaceConnections, } from "./connections";
+export { swapPortOrder, swapNodeInstancePortOrder, setStartExitPorts, setInstancePortConfigs, } from "./ports";
+export { createScope, removeScope, addToScope, removeFromScope, moveToScope, } from "./scopes";
 //# sourceMappingURL=index.d.ts.map

package/dist/api/manipulation/node-types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Node type operations for workflow manipulation
  */
-import type { TWorkflowAST, TNodeTypeAST } from "../../ast/types.js";
+import type { TWorkflowAST, TNodeTypeAST } from "../../ast/types";
 /**
  * Add a node type definition to the workflow (idempotent).
  * Uses no validation to allow adding even when workflow has other errors.