yaml-flow 2.2.0 → 2.4.0

package/dist/continuous-event-graph/index.js

@@ -0,0 +1,916 @@
+// src/event-graph/constants.ts
+var TASK_STATUS = {
+  NOT_STARTED: "not-started",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  INACTIVATED: "inactivated"
+};
+
+// src/event-graph/graph-helpers.ts
+function getProvides(task) {
+  if (!task) return [];
+  if (Array.isArray(task.provides)) return task.provides;
+  return [];
+}
+function getRequires(task) {
+  if (!task) return [];
+  if (Array.isArray(task.requires)) return task.requires;
+  return [];
+}
+function getAllTasks(graph) {
+  return graph.tasks ?? {};
+}
+function isNonActiveTask(taskState) {
+  if (!taskState) return false;
+  return taskState.status === TASK_STATUS.FAILED || taskState.status === TASK_STATUS.INACTIVATED;
+}
+function isRepeatableTask(taskConfig) {
+  return taskConfig.repeatable === true || typeof taskConfig.repeatable === "object" && taskConfig.repeatable !== null;
+}
+function getRepeatableMax(taskConfig) {
+  if (taskConfig.repeatable === true) return void 0;
+  if (typeof taskConfig.repeatable === "object" && taskConfig.repeatable !== null) {
+    return taskConfig.repeatable.max;
+  }
+  return void 0;
+}
+function computeAvailableOutputs(graph, taskStates) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const [taskName, taskState] of Object.entries(taskStates)) {
+    if (taskState.status === TASK_STATUS.COMPLETED) {
+      const taskConfig = graph.tasks[taskName];
+      if (taskConfig) {
+        const provides = getProvides(taskConfig);
+        provides.forEach((output) => outputs.add(output));
+      }
+    }
+  }
+  return Array.from(outputs);
+}
+function groupTasksByProvides(candidateTaskNames, tasks) {
+  const outputGroups = {};
+  candidateTaskNames.forEach((taskName) => {
+    const task = tasks[taskName];
+    if (!task) return;
+    const provides = getProvides(task);
+    provides.forEach((output) => {
+      if (!outputGroups[output]) {
+        outputGroups[output] = [];
+      }
+      outputGroups[output].push(taskName);
+    });
+  });
+  return outputGroups;
+}
+
+// src/event-graph/task-transitions.ts
+function applyTaskStart(state, taskName) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState();
+  const updatedTask = {
+    ...existingTask,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    progress: 0,
+    error: void 0
+  };
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyTaskCompletion(state, graph, taskName, result) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState();
+  const taskConfig = graph.tasks[taskName];
+  if (!taskConfig) {
+    throw new Error(`Task "${taskName}" not found in graph`);
+  }
+  let outputTokens;
+  if (result && taskConfig.on && taskConfig.on[result]) {
+    outputTokens = taskConfig.on[result];
+  } else {
+    outputTokens = getProvides(taskConfig);
+  }
+  const updatedTask = {
+    ...existingTask,
+    status: "completed",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    executionCount: existingTask.executionCount + 1,
+    lastEpoch: existingTask.executionCount + 1,
+    error: void 0
+  };
+  if (isRepeatableTask(taskConfig)) {
+    updatedTask.status = "not-started";
+  }
+  const newOutputs = [.../* @__PURE__ */ new Set([...state.availableOutputs, ...outputTokens])];
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    availableOutputs: newOutputs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyTaskFailure(state, graph, taskName, error) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState();
+  const taskConfig = graph.tasks[taskName];
+  if (taskConfig?.retry) {
+    const retryCount = existingTask.retryCount + 1;
+    if (retryCount <= taskConfig.retry.max_attempts) {
+      const updatedTask2 = {
+        ...existingTask,
+        status: "not-started",
+        retryCount,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        error
+      };
+      return {
+        ...state,
+        tasks: { ...state.tasks, [taskName]: updatedTask2 },
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  const updatedTask = {
+    ...existingTask,
+    status: "failed",
+    failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    error,
+    executionCount: existingTask.executionCount + 1
+  };
+  let newOutputs = state.availableOutputs;
+  if (taskConfig?.on_failure && taskConfig.on_failure.length > 0) {
+    newOutputs = [.../* @__PURE__ */ new Set([...state.availableOutputs, ...taskConfig.on_failure])];
+  }
+  if (taskConfig?.circuit_breaker && updatedTask.executionCount >= taskConfig.circuit_breaker.max_executions) {
+    const breakTokens = taskConfig.circuit_breaker.on_break;
+    newOutputs = [.../* @__PURE__ */ new Set([...newOutputs, ...breakTokens])];
+  }
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    availableOutputs: newOutputs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyTaskProgress(state, taskName, message, progress) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState();
+  const updatedTask = {
+    ...existingTask,
+    progress: typeof progress === "number" ? progress : existingTask.progress,
+    messages: [
+      ...existingTask.messages ?? [],
+      ...message ? [{ message, timestamp: (/* @__PURE__ */ new Date()).toISOString(), status: existingTask.status }] : []
+    ],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createDefaultTaskState() {
+  return {
+    status: "not-started",
+    executionCount: 0,
+    retryCount: 0,
+    lastEpoch: 0,
+    messages: [],
+    progress: null
+  };
+}
+
+// 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] = createDefaultTaskState2();
+  }
+  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 = applyAgentAction(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]: createDefaultTaskState2() },
+      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]: createDefaultTaskState2()
+      },
+      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] ?? createDefaultTaskState2();
+  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 createDefaultTaskState2() {
+  return {
+    status: "not-started",
+    executionCount: 0,
+    retryCount: 0,
+    lastEpoch: 0,
+    messages: [],
+    progress: null
+  };
+}
+function applyAgentAction(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 = buildProducerMap(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 buildProducerMap(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 = buildTaskDeps(graphTasks, producerMap);
+  const cycles = detectCycles(taskNames, deps);
+  return {
+    totalNodes: taskNames.length,
+    running,
+    completed,
+    failed,
+    waiting,
+    notStarted,
+    disabled,
+    unresolvedCount,
+    blockedCount,
+    openDependencies: [...openDeps],
+    cycles,
+    conflictTokens
+  };
+}
+function buildTaskDeps(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 detectCycles(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 buildProducerMap2(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 = buildProducerMap2(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 = buildProducerMap2(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 { addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map