@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/built-in-nodes/mock-types.d.ts

@@ -1,28 +1,54 @@
 /**
- * Type definitions for the mock configuration used during local testing.
- * When present on globalThis.__fw_mocks__, built-in nodes use mock data
- * instead of their default no-op/sleep behavior.
+ * Canned answers for a run under test, carried by the execution-scoped
+ * runtime (`runtime.services.mocks`).
+ *
+ * Who reads them is the point. A compiled workflow never calls the bodies of
+ * `waitForEvent`, `waitForAgent` or `sleep`: the generator emits a durable
+ * gate in their place, and the engine (`mockedGateAnswer` in
+ * `src/runtime/durable-execution.ts`) answers that gate from here before it
+ * yields. The bodies of those three nodes throw if reached. `invokeWorkflow`
+ * and `delay` do run as functions and read `invocations` and `fast`
+ * themselves.
+ *
+ * How a gate is answered, in this order:
+ *
+ * - `gates[nodeId]` answers any gate, built-in or authored, with the gate's
+ *   data outputs; control ports are filled in as for a person's answer.
+ * - `waitForAgent` also reads `agents` and `waitForEvent` reads `events`,
+ *   keyed by the node's first input (the agent id, the event name), by
+ *   `nodeId:key`, or by `nodeId:*` (the lookup `lookupMock` describes).
+ * - `sleep` wakes at once under `fast`, as `delay` returns at once.
+ * - A gate no entry answers yields for a person, whether or not its section
+ *   exists: an `agents` section without this agent's key is a wait, not a
+ *   failure. Nothing takes the failure path on a missing key.
  */
+import type { NodeExecutionRuntime } from '../runtime/durable-execution.js';
 export interface FwMockConfig {
-    /** Mock event data keyed by event name. Used by waitForEvent. */
+    /** Event payloads keyed by event name (or `nodeId:name`, `nodeId:*`). Answers a `waitForEvent` gate. */
     events?: Record<string, object>;
-    /** Mock invocation results keyed by functionId. Used by invokeWorkflow. */
+    /** Invocation results keyed by functionId (or `nodeId:functionId`, `nodeId:*`). Read by `invokeWorkflow` itself. */
     invocations?: Record<string, object>;
-    /** Mock agent results keyed by agentId. Used by waitForAgent. */
+    /** Agent results keyed by agent id (or `nodeId:agentId`, `nodeId:*`). Answers a `waitForAgent` gate. */
     agents?: Record<string, object>;
-    /** When true, delay nodes skip the real sleep (1ms instead of full duration). */
+    /**
+     * An answer for any durable gate, keyed by the node's instance id: the
+     * gate's data outputs as an object (`{ decision: { approved: true } }`).
+     * The run goes through the gate as if a person had answered that.
+     */
+    gates?: Record<string, object>;
+    /** When true, `delay` waits 1ms instead of its duration and a `sleep` gate wakes at once. */
     fast?: boolean;
 }
 /**
- * Read the mock config from globalThis, returning undefined if not set.
+ * Read mock configuration from the execution-scoped runtime.
  */
-export declare function getMockConfig(): FwMockConfig | undefined;
+export declare function getMockConfig(runtime?: NodeExecutionRuntime): FwMockConfig | undefined;
 /**
  * Look up a mock value from a section, supporting instance-qualified keys.
  *
- * Checks "instanceId:key" first (for per-node targeting), then falls back
- * to plain "key". The instance ID comes from __fw_current_node_id__ which
- * the generated code sets before each node invocation.
+ * Checks "instanceId:key" first (for per-node targeting), then
+ * "instanceId:*" (whatever key this node asks for), then falls back to
+ * plain "key".
  *
  * @example
  * ```json
@@ -30,11 +56,16 @@ export declare function getMockConfig(): FwMockConfig | undefined;
  *   "invocations": {
  *     "retryCall:api/process": { "status": "ok" },
  *     "api/process": { "status": "default" }
+ *   },
+ *   "events": {
+ *     "link:*": { "url": "https://figma.com/file/abc" }
  *   }
  * }
  * ```
  * When the node "retryCall" invokes "api/process", it gets `{ status: "ok" }`.
- * Any other node invoking "api/process" gets `{ status: "default" }`.
+ * Any other node invoking "api/process" gets `{ status: "default" }`. The
+ * node "link" gets its event whatever name it waits for -- the name is
+ * often computed at run time, and the console mocks by node, not by name.
  */
-export declare function lookupMock<T>(section: Record<string, T> | undefined, key: string): T | undefined;
+export declare function lookupMock<T>(section: Record<string, T> | undefined, key: string, runtime?: NodeExecutionRuntime): T | undefined;
 //# sourceMappingURL=mock-types.d.ts.map

package/dist/built-in-nodes/sleep.d.ts

@@ -0,0 +1,12 @@
+import type { NodeExecutionRuntime } from '../runtime/durable-execution.js';
+/**
+ * @flowWeaver nodeType
+ * @input duration - How long the run sleeps before it goes on (e.g. "30s", "2h", "3d")
+ * @output wokeAt - When the run went on, as an ISO 8601 time
+ */
+export declare function sleep(execute: boolean, duration: string, runtime?: NodeExecutionRuntime): Promise<{
+    onSuccess: boolean;
+    onFailure: boolean;
+    wokeAt: string;
+}>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/built-in-nodes/wait-for-agent.d.ts

@@ -1,3 +1,4 @@
+import type { NodeExecutionRuntime } from '../runtime/durable-execution.js';
 /**
  * @flowWeaver nodeType
  * @input agentId - Agent/task identifier
@@ -5,7 +6,7 @@
  * @input [prompt] - Message to display when requesting input
  * @output agentResult - Result returned by the agent
  */
-export declare function waitForAgent(execute: boolean, agentId: string, context: object, prompt?: string): Promise<{
+export declare function waitForAgent(execute: boolean, agentId: string, context: object, prompt?: string, _abortSignal?: AbortSignal, runtime?: NodeExecutionRuntime): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     agentResult: object;

package/dist/built-in-nodes/wait-for-event.d.ts

@@ -1,3 +1,4 @@
+import type { NodeExecutionRuntime } from '../runtime/durable-execution.js';
 /**
  * @flowWeaver nodeType
  * @input eventName - Event name to wait for (e.g. "app/approval.received")
@@ -5,7 +6,7 @@
  * @input [timeout] - Max wait time (e.g. "24h", "7d"). Empty = no timeout
  * @output eventData - The received event's data payload
  */
-export declare function waitForEvent(execute: boolean, eventName: string, match?: string, timeout?: string): Promise<{
+export declare function waitForEvent(execute: boolean, eventName: string, match?: string, timeout?: string, runtime?: NodeExecutionRuntime): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     eventData: object;

package/dist/chevrotain-parser/coerce-parser.d.ts

@@ -8,7 +8,7 @@
  *
  * Where targetType is one of: string, number, boolean, json, object
  */
-import type { TCoerceTargetType } from '../ast/types.js';
+import type { TCoerceTargetType } from '../ast/types';
 export interface CoerceParseResult {
     instanceId: string;
     source: {

package/dist/chevrotain-parser/connect-parser.d.ts

@@ -3,7 +3,7 @@
  *
  * Parser for @connect declarations using Chevrotain.
  */
-import type { TCoerceTargetType } from '../ast/types.js';
+import type { TCoerceTargetType } from '../ast/types';
 export interface PortReference {
     nodeId: string;
     portName: string;

package/dist/chevrotain-parser/grammar-diagrams.d.ts

@@ -9,11 +9,11 @@ export interface GrammarCollection {
     port: ISerializedGast[];
     node: ISerializedGast[];
     connect: ISerializedGast[];
-    position: ISerializedGast[];
     scope: ISerializedGast[];
     path: ISerializedGast[];
     map: ISerializedGast[];
     fan: ISerializedGast[];
+    coerce: ISerializedGast[];
     triggerCancel: ISerializedGast[];
 }
 /**

package/dist/chevrotain-parser/index.d.ts

@@ -2,28 +2,25 @@
  * @module chevrotain-parser
  *
  * Chevrotain-based parsers for JSDoc annotations.
- * Provides structured parsing for @input, @output, @node, @connect, and @position.
+ * Provides structured parsing for @input, @output, @node, @connect and the sugar tags.
  */
-export { JSDocLexer, allTokens, InputTag, OutputTag, NodeTag, ConnectTag, PositionTag, ScopeTag, MapTag, PathTag, FanOutTag, FanInTag, CoerceTag, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, } from './tokens.js';
-export { parsePortLine, getPortGrammar } from './port-parser.js';
-export type { PortParseResult } from './port-parser.js';
-export { parseNodeLine, getNodeGrammar } from './node-parser.js';
-export type { NodeParseResult } from './node-parser.js';
-export { parseConnectLine, getConnectGrammar } from './connect-parser.js';
-export type { ConnectParseResult, PortReference } from './connect-parser.js';
-export { parsePositionLine, getPositionGrammar } from './position-parser.js';
-export type { PositionParseResult } from './position-parser.js';
-export { parseScopeLine, getScopeGrammar } from './scope-parser.js';
-export type { ScopeParseResult } from './scope-parser.js';
-export { parseMapLine, getMapGrammar } from './map-parser.js';
-export type { MapParseResult } from './map-parser.js';
-export { parsePathLine, getPathGrammar } from './path-parser.js';
-export type { PathParseResult, PathStep } from './path-parser.js';
-export { parseFanOutLine, parseFanInLine } from './fan-parser.js';
-export type { FanOutParseResult, FanInParseResult, PortRef } from './fan-parser.js';
-export { parseCoerceLine } from './coerce-parser.js';
-export type { CoerceParseResult } from './coerce-parser.js';
-export { parseTriggerLine, parseCancelOnLine, parseRetriesLine, parseTimeoutLine, parseThrottleLine } from './trigger-cancel-parser.js';
-export type { TriggerParseResult, CancelOnParseResult, ThrottleParseResult } from './trigger-cancel-parser.js';
-export { generateGrammarDiagrams, getAllGrammars, serializedToEBNF } from './grammar-diagrams.js';
+export { parsePortLine, getPortGrammar } from './port-parser';
+export type { PortParseResult } from './port-parser';
+export { parseNodeLine, getNodeGrammar } from './node-parser';
+export type { NodeParseResult } from './node-parser';
+export { parseConnectLine, getConnectGrammar } from './connect-parser';
+export type { ConnectParseResult, PortReference } from './connect-parser';
+export { parseScopeLine, getScopeGrammar } from './scope-parser';
+export type { ScopeParseResult } from './scope-parser';
+export { parseMapLine } from './map-parser';
+export type { MapParseResult } from './map-parser';
+export { parsePathLine } from './path-parser';
+export type { PathParseResult, PathStep } from './path-parser';
+export { parseFanOutLine, parseFanInLine } from './fan-parser';
+export type { FanOutParseResult, FanInParseResult, PortRef } from './fan-parser';
+export { parseCoerceLine } from './coerce-parser';
+export type { CoerceParseResult } from './coerce-parser';
+export { parseTriggerLine, parseCancelOnLine, parseRetriesLine, parseTimeoutLine, parseThrottleLine } from './trigger-cancel-parser';
+export type { TriggerParseResult, CancelOnParseResult, ThrottleParseResult } from './trigger-cancel-parser';
+export { generateGrammarDiagrams, getAllGrammars, serializedToEBNF } from './grammar-diagrams';
 //# sourceMappingURL=index.d.ts.map

package/dist/chevrotain-parser/node-parser.d.ts

@@ -17,20 +17,19 @@ export interface NodeParseResult {
         width: number;
         height: number;
     };
-    position?: {
-        x: number;
-        y: number;
-    };
     color?: string;
     icon?: string;
     tags?: Array<{
         label: string;
         tooltip?: string;
     }>;
-    /** CI/CD job group */
-    job?: string;
-    /** CI/CD deployment environment */
-    environment?: string;
+    /**
+     * Generic `[key: "value"]` bracket attributes not claimed by a named
+     * attribute above. Core does not interpret these; a pack reads them from the
+     * node instance and gives them meaning (validation, export, serialization).
+     * This is the extension point for domain vocabularies on `@node`.
+     */
+    attributes?: Record<string, string>;
     /** Warning codes to suppress for this instance */
     suppress?: string[];
 }

package/dist/chevrotain-parser/parse-line.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module chevrotain-parser/parse-line
+ *
+ * The steps every single-line annotation parser shares: lex the line, check
+ * that it starts with the parser's tag, run the entry rule, and word the
+ * warning when the rule fails.
+ */
+import type { CstNode, CstParser, IRecognitionException, IToken, TokenType } from 'chevrotain';
+/** A CST token as the visitors read it: only its source text matters. */
+export interface CstNodeWithImage {
+    image: string;
+}
+export interface LexTaggedLineOptions {
+    /**
+     * Parse the tokens even when the lexer reported errors. Port lines use this
+     * because their free-text description can hold characters the lexer rejects.
+     */
+    ignoreLexErrors?: boolean;
+    /** Called with the first lexer error message before the line is rejected. */
+    onLexError?: (message: string) => void;
+}
+/**
+ * Lex `input` and return its tokens when the first one is one of `tags`.
+ * Returns null for a line that does not lex cleanly, is empty, or belongs to
+ * another tag.
+ */
+export declare function lexTaggedLine(input: string, tags: TokenType | readonly TokenType[], options?: LexTaggedLineOptions): IToken[] | null;
+/** What running an entry rule produced: the tree, and the first error if the rule failed. */
+export interface RuleResult {
+    cst: CstNode;
+    error: IRecognitionException | undefined;
+}
+/** Feed `tokens` to the parser singleton and run one of its entry rules. */
+export declare function runRule(parser: CstParser, tokens: IToken[], rule: () => CstNode): RuleResult;
+export interface LineFailureOptions {
+    /** How many characters of the line to quote. */
+    maxLength?: number;
+    /** The verb in the first line; `tokenize` for lexer failures. */
+    verb?: 'parse' | 'tokenize';
+    /** Text placed right after the quoted line, such as the rule that failed. */
+    context?: string;
+}
+/**
+ * The warning for a line that did not parse:
+ * `Failed to parse <kind> line: "<line>"`, then the error, then the expected format.
+ */
+export declare function lineFailure(kind: string, input: string, error: string, expected: string, options?: LineFailureOptions): string;
+/**
+ * Remove the quotes around a string literal token and undo its escapes: `\"`
+ * becomes `"` and `*\/` becomes `*` followed by `/`, the escape that keeps a
+ * value from closing the JSDoc comment it sits in.
+ */
+export declare function unquoteStringLiteral(raw: string): string;
+//# sourceMappingURL=parse-line.d.ts.map

package/dist/chevrotain-parser/tokens.d.ts

@@ -5,15 +5,12 @@
  * These tokens are used by the lexer to tokenize JSDoc content.
  */
 import { Lexer } from 'chevrotain';
-export declare const WhiteSpace: import("chevrotain").TokenType;
-export declare const Newline: import("chevrotain").TokenType;
 export declare const Asterisk: import("chevrotain").TokenType;
 export declare const InputTag: import("chevrotain").TokenType;
 export declare const OutputTag: import("chevrotain").TokenType;
 export declare const StepTag: import("chevrotain").TokenType;
 export declare const NodeTag: import("chevrotain").TokenType;
 export declare const ConnectTag: import("chevrotain").TokenType;
-export declare const PositionTag: import("chevrotain").TokenType;
 export declare const ScopeTag: import("chevrotain").TokenType;
 export declare const MapTag: import("chevrotain").TokenType;
 export declare const PathTag: import("chevrotain").TokenType;
@@ -27,11 +24,6 @@ export declare const TimeoutTag: import("chevrotain").TokenType;
 export declare const ThrottleTag: import("chevrotain").TokenType;
 export declare const OverKeyword: import("chevrotain").TokenType;
 export declare const AsKeyword: import("chevrotain").TokenType;
-export declare const ParamTag: import("chevrotain").TokenType;
-export declare const ReturnsTag: import("chevrotain").TokenType;
-export declare const FlowWeaverTag: import("chevrotain").TokenType;
-export declare const LabelAttr: import("chevrotain").TokenType;
-export declare const NameAttr: import("chevrotain").TokenType;
 export declare const ScopePrefix: import("chevrotain").TokenType;
 export declare const OrderPrefix: import("chevrotain").TokenType;
 export declare const PlacementPrefix: import("chevrotain").TokenType;
@@ -45,19 +37,10 @@ export declare const PullExecutionPrefix: import("chevrotain").TokenType;
 export declare const MinimizedKeyword: import("chevrotain").TokenType;
 export declare const HiddenKeyword: import("chevrotain").TokenType;
 export declare const SizePrefix: import("chevrotain").TokenType;
-export declare const PositionPrefix: import("chevrotain").TokenType;
 export declare const ColorPrefix: import("chevrotain").TokenType;
 export declare const IconPrefix: import("chevrotain").TokenType;
-export declare const JobPrefix: import("chevrotain").TokenType;
-export declare const EnvironmentAttrPrefix: import("chevrotain").TokenType;
 export declare const TagsPrefix: import("chevrotain").TokenType;
 export declare const SuppressPrefix: import("chevrotain").TokenType;
-export declare const EventEq: import("chevrotain").TokenType;
-export declare const CronEq: import("chevrotain").TokenType;
-export declare const MatchEq: import("chevrotain").TokenType;
-export declare const TimeoutEq: import("chevrotain").TokenType;
-export declare const LimitEq: import("chevrotain").TokenType;
-export declare const PeriodEq: import("chevrotain").TokenType;
 export declare const TopKeyword: import("chevrotain").TokenType;
 export declare const BottomKeyword: import("chevrotain").TokenType;
 export declare const TrueKeyword: import("chevrotain").TokenType;

package/dist/chevrotain-parser/trigger-cancel-parser.d.ts

@@ -2,6 +2,11 @@
  * @module chevrotain-parser/trigger-cancel-parser
  *
  * Shared Chevrotain parser for @trigger, @cancelOn, @retries, @timeout, @throttle annotations.
+ *
+ * The `key=value` options on @trigger, @cancelOn and @throttle are parsed as a
+ * generic list of `Identifier "=" (STRING | INTEGER)` assignments; the visitor
+ * checks the key names. Lexing `event=` or `timeout=` as their own tokens would
+ * shadow a port that happens to carry that name on @input and @node lines.
  */
 export interface TriggerParseResult {
     event?: string;
@@ -46,9 +51,9 @@ export declare function parseTimeoutLine(input: string, warnings: string[]): Tim
  * Parse a @throttle line and return structured result.
  * Returns null if the line is not a throttle declaration.
  */
+export declare function parseThrottleLine(input: string, warnings: string[]): ThrottleParseResult | null;
 /**
  * Get serialized grammar productions for documentation/diagrams.
  */
 export declare function getTriggerCancelGrammar(): import("chevrotain").ISerializedGast[];
-export declare function parseThrottleLine(input: string, warnings: string[]): ThrottleParseResult | null;
 //# sourceMappingURL=trigger-cancel-parser.d.ts.map

package/dist/chunks/chunk-4EUSHAY6.js

@@ -0,0 +1,298 @@
+import {
+  RESERVED_NODE_NAMES,
+  isExitNode,
+  isFailurePort,
+  isStartNode,
+  isSuccessPort
+} from "./chunk-R4QGNK34.js";
+
+// src/generator/control-flow.ts
+function buildControlFlowGraph(workflow, nodeTypes) {
+  const graph = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  graph.set(RESERVED_NODE_NAMES.START, []);
+  inDegree.set(RESERVED_NODE_NAMES.START, 0);
+  graph.set(RESERVED_NODE_NAMES.EXIT, []);
+  inDegree.set(RESERVED_NODE_NAMES.EXIT, 0);
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      return;
+    }
+    graph.set(instance.id, []);
+    inDegree.set(instance.id, 0);
+  });
+  workflow.connections.forEach((conn) => {
+    const fromNode = conn.from.node;
+    const toNode = conn.to.node;
+    if (conn.from.scope || conn.to.scope) {
+      return;
+    }
+    const fromInstance = workflow.instances.find((i) => i.id === fromNode);
+    const toInstance = workflow.instances.find((i) => i.id === toNode);
+    if (fromInstance && isPerPortScopedChild(fromInstance, workflow, nodeTypes) || toInstance && isPerPortScopedChild(toInstance, workflow, nodeTypes)) {
+      return;
+    }
+    if (graph.has(fromNode) && graph.has(toNode)) {
+      const successors = graph.get(fromNode) || [];
+      if (!successors.includes(toNode)) {
+        successors.push(toNode);
+        graph.set(fromNode, successors);
+        inDegree.set(toNode, (inDegree.get(toNode) || 0) + 1);
+      }
+    }
+  });
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      return;
+    }
+    if ((inDegree.get(instance.id) || 0) === 0) {
+      const startSuccessors = graph.get(RESERVED_NODE_NAMES.START) || [];
+      if (!startSuccessors.includes(instance.id)) {
+        startSuccessors.push(instance.id);
+        graph.set(RESERVED_NODE_NAMES.START, startSuccessors);
+        inDegree.set(instance.id, 1);
+      }
+    }
+  });
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      return;
+    }
+    const successors = graph.get(instance.id) || [];
+    if (successors.length === 0) {
+      successors.push(RESERVED_NODE_NAMES.EXIT);
+      graph.set(instance.id, successors);
+      inDegree.set(RESERVED_NODE_NAMES.EXIT, (inDegree.get(RESERVED_NODE_NAMES.EXIT) || 0) + 1);
+    }
+  });
+  return { graph, inDegree };
+}
+function performKahnsTopologicalSort(controlFlowGraph) {
+  const executionOrder = [];
+  const inDegree = new Map(controlFlowGraph.inDegree);
+  const queue = [];
+  inDegree.forEach((degree, node) => {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  });
+  while (queue.length > 0) {
+    const node = queue.shift();
+    executionOrder.push(node);
+    const successors = controlFlowGraph.graph.get(node) || [];
+    successors.forEach((successor) => {
+      const newDegree = (inDegree.get(successor) || 0) - 1;
+      inDegree.set(successor, newDegree);
+      if (newDegree === 0) {
+        queue.push(successor);
+      }
+    });
+  }
+  if (executionOrder.length !== controlFlowGraph.graph.size) {
+    const cycleNodes = [];
+    inDegree.forEach((degree, node) => {
+      if (degree > 0 && !executionOrder.includes(node)) {
+        cycleNodes.push(node);
+      }
+    });
+    throw new Error(
+      `Circular dependency detected in workflow. Nodes in cycle: ${cycleNodes.join(", ")}`
+    );
+  }
+  return executionOrder;
+}
+function findAllBranchingNodes(workflow, nodeTypes) {
+  const branchingNodes = /* @__PURE__ */ new Set();
+  workflow.connections.forEach((conn) => {
+    const nodeName = conn.from.node;
+    const portName = conn.from.port;
+    if (isSuccessPort(portName) || isFailurePort(portName)) {
+      const instance = workflow.instances.find((i) => i.id === nodeName);
+      if (instance && isPerPortScopedChild(instance, workflow, nodeTypes)) {
+        return;
+      }
+      branchingNodes.add(nodeName);
+    }
+  });
+  return branchingNodes;
+}
+function isPerPortScopedChild(instance, workflow, nodeTypes) {
+  if (!instance.parent) return false;
+  const parentInstance = workflow.instances.find((i) => i.id === instance.parent.id);
+  if (!parentInstance) return false;
+  const parentNodeType = nodeTypes.find((nt) => nt.name === parentInstance.nodeType || nt.functionName === parentInstance.nodeType);
+  if (!parentNodeType) return false;
+  const scopeName = instance.parent.scope;
+  const hasOutputWithScope = Object.values(parentNodeType.outputs).some(
+    (port) => port.scope === scopeName
+  );
+  const hasInputWithScope = Object.values(parentNodeType.inputs).some(
+    (port) => port.scope === scopeName
+  );
+  return hasOutputWithScope || hasInputWithScope;
+}
+function findNodesInBranch(branchNode, branchPort, workflow, allNodes, stopAtBranchingNodes) {
+  const reachable = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  workflow.connections.forEach((conn) => {
+    const fromNode = conn.from.node;
+    const fromPort = conn.from.port;
+    const toNode = conn.to.node;
+    if (fromNode === branchNode && fromPort === branchPort) {
+      queue.push(toNode);
+    }
+  });
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current) || isExitNode(current) || isStartNode(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (stopAtBranchingNodes.has(current) && current !== branchNode) {
+      reachable.add(current);
+      continue;
+    }
+    if (allNodes.has(current)) {
+      reachable.add(current);
+      workflow.connections.forEach((conn) => {
+        const fromNode = conn.from.node;
+        const fromPort = conn.from.port;
+        const toNode = conn.to.node;
+        if (fromNode === current && !isSuccessPort(fromPort) && !isFailurePort(fromPort)) {
+          if (!visited.has(toNode)) {
+            queue.push(toNode);
+          }
+        }
+      });
+    }
+  }
+  return reachable;
+}
+function detectBranchingChains(branchingNodes, branchRegions) {
+  const chainSuccessor = /* @__PURE__ */ new Map();
+  for (const nodeId of branchingNodes) {
+    const region = branchRegions.get(nodeId);
+    if (!region) continue;
+    const successBranching = [...region.successNodes].filter((n) => branchingNodes.has(n));
+    const failureBranching = [...region.failureNodes].filter((n) => branchingNodes.has(n));
+    let nextNode = null;
+    if (successBranching.length === 1 && failureBranching.length === 0) {
+      nextNode = successBranching[0];
+    } else if (failureBranching.length === 1 && successBranching.length === 0) {
+      nextNode = failureBranching[0];
+    }
+    if (nextNode) {
+      chainSuccessor.set(nodeId, nextNode);
+    }
+  }
+  const hasChainPredecessor = new Set(chainSuccessor.values());
+  const chains = /* @__PURE__ */ new Map();
+  for (const nodeId of branchingNodes) {
+    if (hasChainPredecessor.has(nodeId)) continue;
+    if (!chainSuccessor.has(nodeId)) continue;
+    const chain = [nodeId];
+    let current = nodeId;
+    while (chainSuccessor.has(current)) {
+      const next = chainSuccessor.get(current);
+      chain.push(next);
+      current = next;
+    }
+    if (chain.length >= 2) {
+      chains.set(nodeId, chain);
+    }
+  }
+  return chains;
+}
+function computeParallelLevels(cfg, branchingNodes, scopedChildren) {
+  const inDegree = new Map(cfg.inDegree);
+  const queue = [];
+  const nodeLevel = /* @__PURE__ */ new Map();
+  inDegree.forEach((degree, node) => {
+    if (degree === 0) {
+      queue.push(node);
+      nodeLevel.set(node, 0);
+    }
+  });
+  while (queue.length > 0) {
+    const node = queue.shift();
+    const level = nodeLevel.get(node);
+    const successors = cfg.graph.get(node) || [];
+    for (const succ of successors) {
+      const newDeg = (inDegree.get(succ) || 0) - 1;
+      inDegree.set(succ, newDeg);
+      const currentLevel = nodeLevel.get(succ) ?? 0;
+      nodeLevel.set(succ, Math.max(currentLevel, level + 1));
+      if (newDeg === 0) {
+        queue.push(succ);
+      }
+    }
+  }
+  const levelGroups = /* @__PURE__ */ new Map();
+  nodeLevel.forEach((level, node) => {
+    if (isStartNode(node) || isExitNode(node)) return;
+    if (!levelGroups.has(level)) {
+      levelGroups.set(level, []);
+    }
+    levelGroups.get(level).push(node);
+  });
+  const sortedLevels = Array.from(levelGroups.keys()).sort((a, b) => a - b);
+  const result = [];
+  for (const level of sortedLevels) {
+    const nodes = levelGroups.get(level);
+    const parallelGroup = [];
+    for (const node of nodes) {
+      if (branchingNodes.has(node) || scopedChildren.has(node)) {
+        if (parallelGroup.length > 0) {
+          result.push([...parallelGroup]);
+          parallelGroup.length = 0;
+        }
+        result.push([node]);
+      } else {
+        parallelGroup.push(node);
+      }
+    }
+    if (parallelGroup.length > 0) {
+      result.push(parallelGroup);
+    }
+  }
+  return result;
+}
+function determineExecutionOrder(workflow, nodes) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => nodeMap.set(node.functionName, node));
+  const executionOrder = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visit(nodeName) {
+    if (visited.has(nodeName)) return;
+    visited.add(nodeName);
+    const outgoingConnections = workflow.connections.filter(
+      (conn) => conn.from.node === nodeName && !isExitNode(conn.to.node)
+    );
+    outgoingConnections.forEach((conn) => {
+      const targetNode = conn.to.node;
+      if (!isExitNode(targetNode)) {
+        visit(targetNode);
+      }
+    });
+    executionOrder.unshift(nodeName);
+  }
+  const startConnections = workflow.connections.filter(
+    (conn) => isStartNode(conn.from.node) && !isExitNode(conn.to.node)
+  );
+  startConnections.forEach((conn) => {
+    visit(conn.to.node);
+  });
+  return executionOrder;
+}
+
+export {
+  buildControlFlowGraph,
+  performKahnsTopologicalSort,
+  findAllBranchingNodes,
+  isPerPortScopedChild,
+  findNodesInBranch,
+  detectBranchingChains,
+  computeParallelLevels,
+  determineExecutionOrder
+};