@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-CZBCCK4Y.js

@@ -0,0 +1,82 @@
+import {
+  RESERVED_PORT_NAMES,
+  isExitNode,
+  isFailurePort,
+  isStartNode,
+  isSuccessPort
+} from "./chunk-R4QGNK34.js";
+
+// src/ast/workflow-utils.ts
+function extractStartPorts(workflow) {
+  if (workflow.startPorts) {
+    return workflow.startPorts;
+  }
+  const startPorts = {};
+  startPorts[RESERVED_PORT_NAMES.EXECUTE] = {
+    dataType: "STEP",
+    isControlFlow: true
+  };
+  workflow.connections.filter((conn) => isStartNode(conn.from.node)).forEach((conn) => {
+    const portName = conn.from.port;
+    const targetNodeType = workflow.nodeTypes.find((n) => n.name === conn.to.node);
+    if (targetNodeType?.inputs[conn.to.port]) {
+      startPorts[portName] = {
+        ...targetNodeType.inputs[conn.to.port]
+      };
+    } else {
+      startPorts[portName] = {
+        dataType: "ANY"
+      };
+    }
+  });
+  return startPorts;
+}
+function extractExitPorts(workflow) {
+  if (workflow.exitPorts) {
+    return workflow.exitPorts;
+  }
+  const exitPorts = {};
+  workflow.connections.filter((conn) => isExitNode(conn.to.node)).forEach((conn) => {
+    const portName = conn.to.port;
+    const sourceNodeType = workflow.nodeTypes.find((n) => n.name === conn.from.node);
+    if (sourceNodeType?.outputs[conn.from.port]) {
+      exitPorts[portName] = {
+        ...sourceNodeType.outputs[conn.from.port]
+      };
+    } else {
+      exitPorts[portName] = {
+        dataType: "ANY"
+      };
+    }
+  });
+  return exitPorts;
+}
+function getNodeType(workflow, nodeName) {
+  return workflow.nodeTypes.find((n) => n.name === nodeName);
+}
+function getConnectionsFrom(workflow, nodeName) {
+  return workflow.connections.filter((c) => c.from.node === nodeName);
+}
+function getConnectionsTo(workflow, nodeName) {
+  return workflow.connections.filter((c) => c.to.node === nodeName);
+}
+function hasBranching(workflow) {
+  return workflow.nodeTypes.some((nodeType) => {
+    const successConns = workflow.connections.filter(
+      (c) => c.from.node === nodeType.name && isSuccessPort(c.from.port)
+    );
+    const failureConns = workflow.connections.filter(
+      (c) => c.from.node === nodeType.name && isFailurePort(c.from.port)
+    );
+    return successConns.length > 1 || failureConns.length > 0;
+  });
+}
+
+export {
+  extractStartPorts,
+  extractExitPorts,
+  getNodeType,
+  getConnectionsFrom,
+  getConnectionsTo,
+  hasBranching
+};

package/dist/chunks/chunk-DCMGQP5V.js

@@ -0,0 +1,505 @@
+import{createRequire as __fwCreateRequire}from"module";var require=__fwCreateRequire(import.meta.url);import {
+  CONTINUATION_FORMAT_VERSION,
+  GENERATOR_ABI,
+  MAX_CONTINUATION_BYTES,
+  MAX_CONTINUATION_DEPTH,
+  MAX_CONTINUATION_ENTRIES,
+  MAX_CONTINUATION_STRING_BYTES,
+  WireValidationError,
+  acceptContinuation,
+  canonicalWireValue,
+  continuationChecksum,
+  durableGateId,
+  executionAddressKey,
+  hasExactlyTheKeys,
+  isPlainObjectRecord,
+  operationKey,
+  structurallyValidEnvelope,
+  utf8ByteLength,
+  validateWireValue
+} from "./chunk-O2U2LO57.js";
+import {
+  VERSION
+} from "./chunk-QDE4Z7KW.js";
+
+// 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 }
+  });
+}
+
+export {
+  parseStrictJson,
+  StrictJsonError,
+  decodeContinuation
+};

package/dist/chunks/chunk-DIAA66GL.js

@@ -0,0 +1,72 @@
+import {
+  CancellationError
+} from "./chunk-6KMVP6AU.js";
+
+// src/built-in-nodes/mock-types.ts
+function getMockConfig(runtime) {
+  return runtime?.runtime.services.mocks;
+}
+function lookupMock(section, key, runtime) {
+  if (!section) return void 0;
+  const nodeId = runtime?.nodeId;
+  if (nodeId) {
+    const qualified = section[`${nodeId}:${key}`];
+    if (qualified !== void 0) return qualified;
+    const any = section[`${nodeId}:*`];
+    if (any !== void 0) return any;
+  }
+  return section[key];
+}
+
+// src/built-in-nodes/delay.ts
+async function delay(execute, duration, abortSignal, runtime) {
+  if (!execute) return { onSuccess: false, onFailure: false, elapsed: false };
+  const mocks = getMockConfig(runtime);
+  if (mocks?.fast) {
+    await waitForDuration(1, abortSignal);
+  } else {
+    const ms = parseDuration(duration) ?? 0;
+    if (ms > 2147483647) {
+      throw new Error(
+        'delay: "' + duration + '" is longer than setTimeout can wait (24.8 days); use sleep for a wait this long'
+      );
+    }
+    await waitForDuration(ms, abortSignal);
+  }
+  return { onSuccess: true, onFailure: false, elapsed: true };
+}
+function waitForDuration(ms, abortSignal) {
+  if (abortSignal?.aborted) return Promise.reject(new CancellationError());
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      abortSignal?.removeEventListener("abort", onAbort);
+      reject(new CancellationError());
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      abortSignal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal?.aborted) onAbort();
+  });
+}
+function parseDuration(text) {
+  if (typeof text !== "string") return void 0;
+  const match = /^\s*(\d+)\s*(ms|s|m|h|d)\s*$/.exec(text);
+  if (!match) return void 0;
+  const units = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return Number(match[1]) * units[match[2]];
+}
+
+export {
+  getMockConfig,
+  lookupMock,
+  delay,
+  parseDuration
+};

package/dist/chunks/chunk-DUO6H5PR.js

@@ -0,0 +1,20 @@
+// src/utils/error-utils.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function wrapError(error, context) {
+  const message = `${context}: ${getErrorMessage(error)}`;
+  const wrapped = new Error(message);
+  if (error instanceof Error) {
+    wrapped.cause = error;
+  }
+  return wrapped;
+}
+
+export {
+  getErrorMessage,
+  wrapError
+};