yaml-flow 2.3.0 → 2.4.0

package/dist/index.js

@@ -2300,6 +2300,733 @@ function resolveConfigTemplates(config) {
   return result;
 }
 
-export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, apply, applyAll, applyStepResult, batch, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createDefaultTaskState, createStepMachine as createEngine, createInitialExecutionState, createInitialState, createStepMachine, detectStuckState, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getProvides, getRequires, getTask, graphToMermaid, hasTask, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, resolveConfigTemplates, resolveVariables, validateGraph, validateGraphConfig, validateStepFlowConfig };
+// src/continuous-event-graph/core.ts
+function createLiveGraph(config, executionId) {
+  const id = executionId ?? `live-${Date.now()}`;
+  const tasks = {};
+  for (const taskName of Object.keys(config.tasks)) {
+    tasks[taskName] = createDefaultTaskState3();
+  }
+  const state = {
+    status: "running",
+    tasks,
+    availableOutputs: [],
+    stuckDetection: { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    executionId: id,
+    executionConfig: {
+      executionMode: config.settings.execution_mode ?? "eligibility-mode",
+      conflictStrategy: config.settings.conflict_strategy ?? "alphabetical",
+      completionStrategy: config.settings.completion
+    }
+  };
+  return { config, state };
+}
+function applyEvent(live, event) {
+  const { config, state } = live;
+  if ("executionId" in event && event.executionId && event.executionId !== state.executionId) {
+    return live;
+  }
+  let newState;
+  switch (event.type) {
+    case "task-started":
+      newState = applyTaskStart(state, event.taskName);
+      break;
+    case "task-completed":
+      newState = applyTaskCompletion(state, config, event.taskName, event.result);
+      break;
+    case "task-failed":
+      newState = applyTaskFailure(state, config, event.taskName, event.error);
+      break;
+    case "task-progress":
+      newState = applyTaskProgress(state, event.taskName, event.message, event.progress);
+      break;
+    case "inject-tokens":
+      newState = {
+        ...state,
+        availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...event.tokens])],
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      break;
+    case "agent-action":
+      newState = applyAgentAction2(state, event.action);
+      break;
+    default:
+      return live;
+  }
+  return { config, state: newState };
+}
+function addNode(live, name, taskConfig) {
+  if (live.config.tasks[name]) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: { ...live.config.tasks, [name]: taskConfig }
+    },
+    state: {
+      ...live.state,
+      tasks: { ...live.state.tasks, [name]: createDefaultTaskState3() },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function removeNode(live, name) {
+  if (!live.config.tasks[name]) return live;
+  const { [name]: _removedConfig, ...remainingTasks } = live.config.tasks;
+  const { [name]: _removedState, ...remainingStates } = live.state.tasks;
+  return {
+    config: {
+      ...live.config,
+      tasks: remainingTasks
+    },
+    state: {
+      ...live.state,
+      tasks: remainingStates,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function addRequires(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getRequires(task);
+  const toAdd = tokens.filter((t) => !current.includes(t));
+  if (toAdd.length === 0) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, requires: [...current, ...toAdd] }
+      }
+    },
+    state: live.state
+  };
+}
+function removeRequires(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getRequires(task);
+  const remaining = current.filter((t) => !tokens.includes(t));
+  if (remaining.length === current.length) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, requires: remaining }
+      }
+    },
+    state: live.state
+  };
+}
+function addProvides(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getProvides(task);
+  const toAdd = tokens.filter((t) => !current.includes(t));
+  if (toAdd.length === 0) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, provides: [...current, ...toAdd] }
+      }
+    },
+    state: live.state
+  };
+}
+function removeProvides(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getProvides(task);
+  const remaining = current.filter((t) => !tokens.includes(t));
+  if (remaining.length === current.length) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, provides: remaining }
+      }
+    },
+    state: live.state
+  };
+}
+function injectTokens(live, tokens) {
+  return applyEvent(live, {
+    type: "inject-tokens",
+    tokens,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function drainTokens(live, tokens) {
+  const toRemove = new Set(tokens);
+  const remaining = live.state.availableOutputs.filter((t) => !toRemove.has(t));
+  if (remaining.length === live.state.availableOutputs.length) return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      availableOutputs: remaining,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function resetNode(live, name) {
+  if (!live.config.tasks[name] || !live.state.tasks[name]) return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      tasks: {
+        ...live.state.tasks,
+        [name]: createDefaultTaskState3()
+      },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function disableNode(live, name) {
+  const taskState = live.state.tasks[name];
+  if (!taskState || taskState.status === "inactivated") return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      tasks: {
+        ...live.state.tasks,
+        [name]: { ...taskState, status: "inactivated", lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function enableNode(live, name) {
+  const taskState = live.state.tasks[name];
+  if (!taskState || taskState.status !== "inactivated") return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      tasks: {
+        ...live.state.tasks,
+        [name]: { ...taskState, status: "not-started", lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function getNode(live, name) {
+  const config = live.config.tasks[name];
+  if (!config) return void 0;
+  const state = live.state.tasks[name] ?? createDefaultTaskState3();
+  return { name, config, state };
+}
+function snapshot(live) {
+  return {
+    version: 1,
+    config: live.config,
+    state: live.state,
+    snapshotAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function restore(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid snapshot: expected an object");
+  }
+  const snap = data;
+  if (!snap.config || typeof snap.config !== "object") {
+    throw new Error('Invalid snapshot: missing or invalid "config"');
+  }
+  if (!snap.state || typeof snap.state !== "object") {
+    throw new Error('Invalid snapshot: missing or invalid "state"');
+  }
+  const config = snap.config;
+  const state = snap.state;
+  if (!config.settings || typeof config.settings !== "object") {
+    throw new Error("Invalid snapshot: config.settings missing");
+  }
+  if (!config.tasks || typeof config.tasks !== "object") {
+    throw new Error("Invalid snapshot: config.tasks missing");
+  }
+  if (!state.tasks || typeof state.tasks !== "object") {
+    throw new Error("Invalid snapshot: state.tasks missing");
+  }
+  if (!Array.isArray(state.availableOutputs)) {
+    throw new Error("Invalid snapshot: state.availableOutputs must be an array");
+  }
+  return { config, state };
+}
+function createDefaultTaskState3() {
+  return {
+    status: "not-started",
+    executionCount: 0,
+    retryCount: 0,
+    lastEpoch: 0,
+    messages: [],
+    progress: null
+  };
+}
+function applyAgentAction2(state, action) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  switch (action) {
+    case "stop":
+      return { ...state, status: "stopped", lastUpdated: now };
+    case "pause":
+      return { ...state, status: "paused", lastUpdated: now };
+    case "resume":
+      return { ...state, status: "running", lastUpdated: now };
+    default:
+      return state;
+  }
+}
+
+// src/continuous-event-graph/schedule.ts
+function schedule(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const taskNames = Object.keys(graphTasks);
+  if (taskNames.length === 0) {
+    return { eligible: [], pending: [], unresolved: [], blocked: [], conflicts: {} };
+  }
+  const producerMap = buildProducerMap3(graphTasks);
+  const computedOutputs = computeAvailableOutputs(config, state.tasks);
+  const availableOutputs = /* @__PURE__ */ new Set([...computedOutputs, ...state.availableOutputs]);
+  const eligible = [];
+  const pending = [];
+  const unresolved = [];
+  const blocked = [];
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const taskState = state.tasks[taskName];
+    if (!isRepeatableTask(taskConfig)) {
+      if (taskState?.status === TASK_STATUS.COMPLETED || taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+        continue;
+      }
+    } else {
+      if (taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+        continue;
+      }
+      const maxExec = getRepeatableMax(taskConfig);
+      if (maxExec !== void 0 && taskState && taskState.executionCount >= maxExec) {
+        continue;
+      }
+      if (taskConfig.circuit_breaker && taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
+        continue;
+      }
+      if (taskState?.status === TASK_STATUS.COMPLETED) {
+        const requires2 = getRequires(taskConfig);
+        if (requires2.length > 0) {
+          const hasRefreshed = requires2.some((req) => {
+            for (const [otherName, otherConfig] of Object.entries(graphTasks)) {
+              if (getProvides(otherConfig).includes(req)) {
+                const otherState = state.tasks[otherName];
+                if (otherState && otherState.executionCount > taskState.lastEpoch) return true;
+              }
+            }
+            return false;
+          });
+          if (!hasRefreshed) continue;
+        } else {
+          continue;
+        }
+      }
+    }
+    const requires = getRequires(taskConfig);
+    if (requires.length === 0) {
+      eligible.push(taskName);
+      continue;
+    }
+    const missingTokens = [];
+    const pendingTokens = [];
+    const failedTokenInfo = [];
+    for (const token of requires) {
+      if (availableOutputs.has(token)) continue;
+      const producers = producerMap[token] || [];
+      if (producers.length === 0) {
+        missingTokens.push(token);
+      } else {
+        const allFailed = producers.every((p) => isNonActiveTask(state.tasks[p]));
+        if (allFailed) {
+          failedTokenInfo.push({ token, failedProducer: producers[0] });
+        } else {
+          pendingTokens.push(token);
+        }
+      }
+    }
+    if (missingTokens.length > 0) {
+      unresolved.push({ taskName, missingTokens });
+    } else if (failedTokenInfo.length > 0) {
+      blocked.push({
+        taskName,
+        failedTokens: failedTokenInfo.map((f) => f.token),
+        failedProducers: [...new Set(failedTokenInfo.map((f) => f.failedProducer))]
+      });
+    } else if (pendingTokens.length > 0) {
+      pending.push({ taskName, waitingOn: pendingTokens });
+    } else {
+      eligible.push(taskName);
+    }
+  }
+  const conflicts = {};
+  if (eligible.length > 1) {
+    const outputGroups = groupTasksByProvides(eligible, graphTasks);
+    for (const [outputKey, groupTasks] of Object.entries(outputGroups)) {
+      if (groupTasks.length > 1) {
+        conflicts[outputKey] = groupTasks;
+      }
+    }
+  }
+  return { eligible, pending, unresolved, blocked, conflicts };
+}
+function buildProducerMap3(tasks) {
+  const map = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!map[token]) map[token] = [];
+      map[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!map[token]) map[token] = [];
+          if (!map[token].includes(name)) map[token].push(name);
+        }
+      }
+    }
+    if (config.on_failure) {
+      for (const token of config.on_failure) {
+        if (!map[token]) map[token] = [];
+        if (!map[token].includes(name)) map[token].push(name);
+      }
+    }
+  }
+  return map;
+}
+
+// src/continuous-event-graph/inspect.ts
+function inspect(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const taskNames = Object.keys(graphTasks);
+  let running = 0, completed = 0, failed = 0, waiting = 0, notStarted = 0, disabled = 0;
+  for (const taskName of taskNames) {
+    const ts = state.tasks[taskName];
+    if (!ts || ts.status === TASK_STATUS.NOT_STARTED) {
+      notStarted++;
+    } else {
+      switch (ts.status) {
+        case TASK_STATUS.RUNNING:
+          running++;
+          break;
+        case TASK_STATUS.COMPLETED:
+          completed++;
+          break;
+        case TASK_STATUS.FAILED:
+          failed++;
+          break;
+        case "inactivated":
+          disabled++;
+          break;
+        default:
+          waiting++;
+      }
+    }
+  }
+  const producerMap = {};
+  for (const [name, taskConfig] of Object.entries(graphTasks)) {
+    for (const token of getProvides(taskConfig)) {
+      if (!producerMap[token]) producerMap[token] = [];
+      producerMap[token].push(name);
+    }
+    if (taskConfig.on) {
+      for (const tokens of Object.values(taskConfig.on)) {
+        for (const token of tokens) {
+          if (!producerMap[token]) producerMap[token] = [];
+          if (!producerMap[token].includes(name)) producerMap[token].push(name);
+        }
+      }
+    }
+    if (taskConfig.on_failure) {
+      for (const token of taskConfig.on_failure) {
+        if (!producerMap[token]) producerMap[token] = [];
+        if (!producerMap[token].includes(name)) producerMap[token].push(name);
+      }
+    }
+  }
+  const openDeps = /* @__PURE__ */ new Set();
+  let unresolvedCount = 0;
+  let blockedCount = 0;
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const ts = state.tasks[taskName];
+    if (ts?.status === TASK_STATUS.COMPLETED || ts?.status === TASK_STATUS.RUNNING) continue;
+    let hasOpen = false;
+    let hasBlocked = false;
+    for (const token of getRequires(taskConfig)) {
+      const producers = producerMap[token] || [];
+      if (producers.length === 0) {
+        openDeps.add(token);
+        hasOpen = true;
+      } else {
+        const allFailed = producers.every((p) => {
+          const ps = state.tasks[p];
+          return ps?.status === TASK_STATUS.FAILED || ps?.status === "inactivated";
+        });
+        if (allFailed) hasBlocked = true;
+      }
+    }
+    if (hasOpen) unresolvedCount++;
+    if (hasBlocked && !hasOpen) blockedCount++;
+  }
+  const conflictTokens = [];
+  for (const [token, producers] of Object.entries(producerMap)) {
+    if (producers.length > 1) conflictTokens.push(token);
+  }
+  const deps = buildTaskDeps2(graphTasks, producerMap);
+  const cycles = detectCycles2(taskNames, deps);
+  return {
+    totalNodes: taskNames.length,
+    running,
+    completed,
+    failed,
+    waiting,
+    notStarted,
+    disabled,
+    unresolvedCount,
+    blockedCount,
+    openDependencies: [...openDeps],
+    cycles,
+    conflictTokens
+  };
+}
+function buildTaskDeps2(tasks, producerMap) {
+  const deps = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    deps[name] = /* @__PURE__ */ new Set();
+    for (const token of getRequires(config)) {
+      for (const producer of producerMap[token] || []) {
+        if (producer !== name) deps[name].add(producer);
+      }
+    }
+  }
+  return deps;
+}
+function detectCycles2(taskNames, deps) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = {};
+  const parent = {};
+  const cycles = [];
+  for (const name of taskNames) {
+    color[name] = WHITE;
+    parent[name] = null;
+  }
+  function dfs(node) {
+    color[node] = GRAY;
+    for (const dep of deps[node] || []) {
+      if (color[dep] === GRAY) {
+        const cycle = [dep];
+        let cur = node;
+        while (cur !== dep) {
+          cycle.push(cur);
+          cur = parent[cur];
+        }
+        cycle.push(dep);
+        cycle.reverse();
+        cycles.push(cycle);
+      } else if (color[dep] === WHITE) {
+        parent[dep] = node;
+        dfs(dep);
+      }
+    }
+    color[node] = BLACK;
+  }
+  for (const name of taskNames) {
+    if (color[name] === WHITE) dfs(name);
+  }
+  return cycles;
+}
+function buildProducerMap4(tasks) {
+  const map = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!map[token]) map[token] = [];
+      map[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!map[token]) map[token] = [];
+          if (!map[token].includes(name)) map[token].push(name);
+        }
+      }
+    }
+    if (config.on_failure) {
+      for (const token of config.on_failure) {
+        if (!map[token]) map[token] = [];
+        if (!map[token].includes(name)) map[token].push(name);
+      }
+    }
+  }
+  return map;
+}
+function getUnreachableTokens(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const producerMap = buildProducerMap4(graphTasks);
+  const available = /* @__PURE__ */ new Set([...state.availableOutputs]);
+  for (const [taskName, taskState] of Object.entries(state.tasks)) {
+    if (taskState.status === "completed") {
+      const tc = graphTasks[taskName];
+      if (tc) getProvides(tc).forEach((t) => available.add(t));
+    }
+  }
+  const allRequired = /* @__PURE__ */ new Set();
+  for (const taskConfig of Object.values(graphTasks)) {
+    for (const token of getRequires(taskConfig)) {
+      allRequired.add(token);
+    }
+  }
+  const unreachable = /* @__PURE__ */ new Set();
+  const unreachableNodes = /* @__PURE__ */ new Set();
+  for (const token of allRequired) {
+    if (available.has(token)) continue;
+    const producers = producerMap[token] || [];
+    if (producers.length === 0) {
+      unreachable.add(token);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name, taskConfig] of Object.entries(graphTasks)) {
+      if (unreachableNodes.has(name)) continue;
+      const ts = state.tasks[name];
+      if (ts?.status === "completed") continue;
+      const isNonActive = isNonActiveTask(ts);
+      const requires = getRequires(taskConfig);
+      const hasUnreachableDep = requires.some((t) => unreachable.has(t));
+      if (isNonActive || hasUnreachableDep) {
+        if (!unreachableNodes.has(name)) {
+          unreachableNodes.add(name);
+          changed = true;
+        }
+      }
+    }
+    for (const token of allRequired) {
+      if (unreachable.has(token) || available.has(token)) continue;
+      const producers = producerMap[token] || [];
+      const allProducersUnreachable = producers.length > 0 && producers.every((p) => unreachableNodes.has(p) || isNonActiveTask(state.tasks[p]));
+      if (producers.length === 0 || allProducersUnreachable) {
+        if (!unreachable.has(token)) {
+          unreachable.add(token);
+          changed = true;
+        }
+      }
+    }
+  }
+  const tokens = [];
+  for (const token of unreachable) {
+    const producers = producerMap[token] || [];
+    let reason;
+    if (producers.length === 0) {
+      reason = "no-producer";
+    } else {
+      const allFailed = producers.every((p) => isNonActiveTask(state.tasks[p]));
+      reason = allFailed ? "all-producers-failed" : "transitive";
+    }
+    tokens.push({ token, reason, producers });
+  }
+  return { tokens };
+}
+function getUnreachableNodes(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const { tokens: unreachableTokens } = getUnreachableTokens(live);
+  const unreachableTokenSet = new Set(unreachableTokens.map((t) => t.token));
+  const nodes = [];
+  for (const [name, taskConfig] of Object.entries(graphTasks)) {
+    const ts = state.tasks[name];
+    if (ts?.status === "completed") continue;
+    const requires = getRequires(taskConfig);
+    const missingTokens = requires.filter((t) => unreachableTokenSet.has(t));
+    if (missingTokens.length > 0) {
+      nodes.push({ nodeName: name, missingTokens });
+    } else if (isNonActiveTask(ts)) {
+      nodes.push({ nodeName: name, missingTokens: [] });
+    }
+  }
+  return { nodes };
+}
+function getUpstream(live, nodeName) {
+  const graphTasks = getAllTasks(live.config);
+  if (!graphTasks[nodeName]) return { nodeName, nodes: [], tokens: [] };
+  const producerMap = buildProducerMap4(graphTasks);
+  const visited = /* @__PURE__ */ new Set();
+  const tokenSet = /* @__PURE__ */ new Set();
+  const nodeEntries = /* @__PURE__ */ new Map();
+  function walk(current) {
+    const taskConfig = graphTasks[current];
+    if (!taskConfig) return;
+    for (const token of getRequires(taskConfig)) {
+      const producers = producerMap[token] || [];
+      for (const producer of producers) {
+        if (producer === nodeName) continue;
+        tokenSet.add(token);
+        if (!nodeEntries.has(producer)) nodeEntries.set(producer, /* @__PURE__ */ new Set());
+        nodeEntries.get(producer).add(token);
+        if (!visited.has(producer)) {
+          visited.add(producer);
+          walk(producer);
+        }
+      }
+    }
+  }
+  walk(nodeName);
+  const nodes = [...nodeEntries.entries()].map(([name, tokens]) => ({
+    nodeName: name,
+    providesTokens: [...tokens]
+  }));
+  return { nodeName, nodes, tokens: [...tokenSet] };
+}
+function getDownstream(live, nodeName) {
+  const graphTasks = getAllTasks(live.config);
+  if (!graphTasks[nodeName]) return { nodeName, nodes: [], tokens: [] };
+  const consumerMap = {};
+  for (const [name, config] of Object.entries(graphTasks)) {
+    for (const token of getRequires(config)) {
+      if (!consumerMap[token]) consumerMap[token] = [];
+      consumerMap[token].push(name);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const tokenSet = /* @__PURE__ */ new Set();
+  const nodeEntries = /* @__PURE__ */ new Map();
+  function walk(current) {
+    const taskConfig = graphTasks[current];
+    if (!taskConfig) return;
+    for (const token of getProvides(taskConfig)) {
+      const consumers = consumerMap[token] || [];
+      for (const consumer of consumers) {
+        if (consumer === nodeName) continue;
+        tokenSet.add(token);
+        if (!nodeEntries.has(consumer)) nodeEntries.set(consumer, /* @__PURE__ */ new Set());
+        nodeEntries.get(consumer).add(token);
+        if (!visited.has(consumer)) {
+          visited.add(consumer);
+          walk(consumer);
+        }
+      }
+    }
+  }
+  walk(nodeName);
+  const nodes = [...nodeEntries.entries()].map(([name, tokens]) => ({
+    nodeName: name,
+    requiresTokens: [...tokens]
+  }));
+  return { nodeName, nodes, tokens: [...tokenSet] };
+}
+
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyStepResult, batch, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createDefaultTaskState, createStepMachine as createEngine, createInitialExecutionState, createInitialState, createLiveGraph, createStepMachine, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getNode, getProvides, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateGraph, validateGraphConfig, validateStepFlowConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map