yaml-flow 2.7.0 → 3.0.0

package/dist/{constants-BEbO2_OK.d.ts → constants-B_ftYTTE.d.ts}

@@ -1,4 +1,4 @@
-import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-DAI_a2as.js';
+import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, R as RefreshStrategy, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-BpWrH1sf.js';
 import { e as StepFlowConfig } from './types-FZ_eyErS.js';
 
 /**
@@ -15,7 +15,7 @@ import { e as StepFlowConfig } from './types-FZ_eyErS.js';
 declare function next(graph: GraphConfig, state: ExecutionState): SchedulerResult;
 /**
  * Get candidate tasks whose dependencies are all met.
- * Handles repeatable tasks and circuit breakers.
+ * Uses refreshStrategy to determine re-execution eligibility.
  * Pure function.
  */
 declare function getCandidateTasks(graph: GraphConfig, state: ExecutionState): string[];
@@ -57,11 +57,16 @@ declare function hasTask(graph: GraphConfig, taskName: string): boolean;
 declare function isNonActiveTask(taskState: TaskState | undefined): boolean;
 declare function isTaskCompleted(taskState: TaskState | undefined): boolean;
 declare function isTaskRunning(taskState: TaskState | undefined): boolean;
-declare function isRepeatableTask(taskConfig: TaskConfig): boolean;
-declare function getRepeatableMax(taskConfig: TaskConfig): number | undefined;
+declare function getRefreshStrategy(taskConfig: TaskConfig, graphSettings?: {
+    refreshStrategy?: RefreshStrategy;
+}): RefreshStrategy;
+declare function isRerunnable(taskConfig: TaskConfig, graphSettings?: {
+    refreshStrategy?: RefreshStrategy;
+}): boolean;
+declare function getMaxExecutions(taskConfig: TaskConfig): number | undefined;
 /**
  * Dynamically compute available outputs from all completed tasks.
- * For repeatable tasks, outputs are versioned by epoch.
+ * Tasks with strategies other than 'once' may have completed and reset.
  * Pure function.
  */
 declare function computeAvailableOutputs(graph: GraphConfig, taskStates: Record<string, TaskState>): string[];
@@ -303,6 +308,31 @@ interface GraphValidationResult {
  */
 declare function validateGraph(graph: GraphConfig): GraphValidationResult;
 
+/**
+ * schema-validator — Full JSON Schema validation for EventGraph configs.
+ *
+ * Uses AJV to validate against the published event-graph.schema.json.
+ * For a lightweight sync check without AJV, use `validateGraphConfig()` instead.
+ *
+ * @example
+ * ```typescript
+ * import { validateGraphSchema } from 'yaml-flow/event-graph';
+ *
+ * const result = validateGraphSchema(config);
+ * if (!result.ok) console.error(result.errors);
+ * ```
+ */
+interface SchemaValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+/**
+ * Validate an event-graph config against the full event-graph.schema.json (draft-07).
+ *
+ * Requires `ajv` and `ajv-formats` to be installed.
+ */
+declare function validateGraphSchema(config: unknown): SchemaValidationResult;
+
 /**
  * Event Graph — Constants
  */
@@ -319,4 +349,4 @@ declare const DEFAULTS: {
     readonly MAX_ITERATIONS: 1000;
 };
 
-export { isTaskCompleted as A, isTaskRunning as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, loadGraphConfig as F, type GraphIssue as G, next as H, type IssueSeverity as I, planExecution as J, validateGraph as K, validateGraphConfig as L, type MermaidOptions as M, addKeyToProvides as N, addKeyToRequires as O, getRepeatableMax as P, groupTasksByProvides as Q, hasOutputConflict as R, removeKeyFromProvides as S, TASK_STATUS as T, removeKeyFromRequires as U, CONFLICT_STRATEGIES as a, type CompletionResult as b, EXECUTION_STATUS as c, type ExecutionPlan as d, type ExportOptions as e, type GraphValidationResult as f, addDynamicTask as g, apply as h, applyAll as i, computeAvailableOutputs as j, createDefaultTaskState as k, createInitialExecutionState as l, detectStuckState as m, exportGraphConfig as n, exportGraphConfigToFile as o, flowToMermaid as p, getAllTasks as q, getCandidateTasks as r, getProvides as s, getRequires as t, getTask as u, graphToMermaid as v, hasTask as w, isExecutionComplete as x, isNonActiveTask as y, isRepeatableTask as z };
+export { isNonActiveTask as A, isRerunnable as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, isTaskCompleted as F, type GraphIssue as G, isTaskRunning as H, type IssueSeverity as I, loadGraphConfig as J, next as K, planExecution as L, type MermaidOptions as M, validateGraph as N, validateGraphConfig as O, validateGraphSchema as P, addKeyToProvides as Q, addKeyToRequires as R, groupTasksByProvides as S, TASK_STATUS as T, hasOutputConflict as U, removeKeyFromProvides as V, removeKeyFromRequires as W, CONFLICT_STRATEGIES as a, type CompletionResult as b, EXECUTION_STATUS as c, type ExecutionPlan as d, type ExportOptions as e, type GraphValidationResult as f, addDynamicTask as g, apply as h, applyAll as i, computeAvailableOutputs as j, createDefaultTaskState as k, createInitialExecutionState as l, detectStuckState as m, exportGraphConfig as n, exportGraphConfigToFile as o, flowToMermaid as p, getAllTasks as q, getCandidateTasks as r, getMaxExecutions as s, getProvides as t, getRefreshStrategy as u, getRequires as v, getTask as w, graphToMermaid as x, hasTask as y, isExecutionComplete as z };

package/dist/{constants-BNjeIlZ8.d.cts → constants-CiyHX8L-.d.cts}

@@ -1,4 +1,4 @@
-import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-DAI_a2as.cjs';
+import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, R as RefreshStrategy, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-BpWrH1sf.cjs';
 import { e as StepFlowConfig } from './types-FZ_eyErS.cjs';
 
 /**
@@ -15,7 +15,7 @@ import { e as StepFlowConfig } from './types-FZ_eyErS.cjs';
 declare function next(graph: GraphConfig, state: ExecutionState): SchedulerResult;
 /**
  * Get candidate tasks whose dependencies are all met.
- * Handles repeatable tasks and circuit breakers.
+ * Uses refreshStrategy to determine re-execution eligibility.
  * Pure function.
  */
 declare function getCandidateTasks(graph: GraphConfig, state: ExecutionState): string[];
@@ -57,11 +57,16 @@ declare function hasTask(graph: GraphConfig, taskName: string): boolean;
 declare function isNonActiveTask(taskState: TaskState | undefined): boolean;
 declare function isTaskCompleted(taskState: TaskState | undefined): boolean;
 declare function isTaskRunning(taskState: TaskState | undefined): boolean;
-declare function isRepeatableTask(taskConfig: TaskConfig): boolean;
-declare function getRepeatableMax(taskConfig: TaskConfig): number | undefined;
+declare function getRefreshStrategy(taskConfig: TaskConfig, graphSettings?: {
+    refreshStrategy?: RefreshStrategy;
+}): RefreshStrategy;
+declare function isRerunnable(taskConfig: TaskConfig, graphSettings?: {
+    refreshStrategy?: RefreshStrategy;
+}): boolean;
+declare function getMaxExecutions(taskConfig: TaskConfig): number | undefined;
 /**
  * Dynamically compute available outputs from all completed tasks.
- * For repeatable tasks, outputs are versioned by epoch.
+ * Tasks with strategies other than 'once' may have completed and reset.
  * Pure function.
  */
 declare function computeAvailableOutputs(graph: GraphConfig, taskStates: Record<string, TaskState>): string[];
@@ -303,6 +308,31 @@ interface GraphValidationResult {
  */
 declare function validateGraph(graph: GraphConfig): GraphValidationResult;
 
+/**
+ * schema-validator — Full JSON Schema validation for EventGraph configs.
+ *
+ * Uses AJV to validate against the published event-graph.schema.json.
+ * For a lightweight sync check without AJV, use `validateGraphConfig()` instead.
+ *
+ * @example
+ * ```typescript
+ * import { validateGraphSchema } from 'yaml-flow/event-graph';
+ *
+ * const result = validateGraphSchema(config);
+ * if (!result.ok) console.error(result.errors);
+ * ```
+ */
+interface SchemaValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+/**
+ * Validate an event-graph config against the full event-graph.schema.json (draft-07).
+ *
+ * Requires `ajv` and `ajv-formats` to be installed.
+ */
+declare function validateGraphSchema(config: unknown): SchemaValidationResult;
+
 /**
  * Event Graph — Constants
  */
@@ -319,4 +349,4 @@ declare const DEFAULTS: {
     readonly MAX_ITERATIONS: 1000;
 };
 
-export { isTaskCompleted as A, isTaskRunning as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, loadGraphConfig as F, type GraphIssue as G, next as H, type IssueSeverity as I, planExecution as J, validateGraph as K, validateGraphConfig as L, type MermaidOptions as M, addKeyToProvides as N, addKeyToRequires as O, getRepeatableMax as P, groupTasksByProvides as Q, hasOutputConflict as R, removeKeyFromProvides as S, TASK_STATUS as T, removeKeyFromRequires as U, CONFLICT_STRATEGIES as a, type CompletionResult as b, EXECUTION_STATUS as c, type ExecutionPlan as d, type ExportOptions as e, type GraphValidationResult as f, addDynamicTask as g, apply as h, applyAll as i, computeAvailableOutputs as j, createDefaultTaskState as k, createInitialExecutionState as l, detectStuckState as m, exportGraphConfig as n, exportGraphConfigToFile as o, flowToMermaid as p, getAllTasks as q, getCandidateTasks as r, getProvides as s, getRequires as t, getTask as u, graphToMermaid as v, hasTask as w, isExecutionComplete as x, isNonActiveTask as y, isRepeatableTask as z };
+export { isNonActiveTask as A, isRerunnable as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, isTaskCompleted as F, type GraphIssue as G, isTaskRunning as H, type IssueSeverity as I, loadGraphConfig as J, next as K, planExecution as L, type MermaidOptions as M, validateGraph as N, validateGraphConfig as O, validateGraphSchema as P, addKeyToProvides as Q, addKeyToRequires as R, groupTasksByProvides as S, TASK_STATUS as T, hasOutputConflict as U, removeKeyFromProvides as V, removeKeyFromRequires as W, CONFLICT_STRATEGIES as a, type CompletionResult as b, EXECUTION_STATUS as c, type ExecutionPlan as d, type ExportOptions as e, type GraphValidationResult as f, addDynamicTask as g, apply as h, applyAll as i, computeAvailableOutputs as j, createDefaultTaskState as k, createInitialExecutionState as l, detectStuckState as m, exportGraphConfig as n, exportGraphConfigToFile as o, flowToMermaid as p, getAllTasks as q, getCandidateTasks as r, getMaxExecutions as s, getProvides as t, getRefreshStrategy as u, getRequires as v, getTask as w, graphToMermaid as x, hasTask as y, isExecutionComplete as z };

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

@@ -1,5 +1,7 @@
 'use strict';
 
+var fs = require('fs');
+
 // src/event-graph/constants.ts
 var TASK_STATUS = {
   NOT_STARTED: "not-started",
@@ -27,15 +29,11 @@ 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 getRefreshStrategy(taskConfig, graphSettings) {
+  return taskConfig.refreshStrategy ?? graphSettings?.refreshStrategy ?? "data-changed";
 }
-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 getMaxExecutions(taskConfig) {
+  return taskConfig.maxExecutions;
 }
 function computeAvailableOutputs(graph, taskStates) {
   const outputs = /* @__PURE__ */ new Set();
@@ -83,7 +81,7 @@ function applyTaskStart(state, taskName) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function applyTaskCompletion(state, graph, taskName, result) {
+function applyTaskCompletion(state, graph, taskName, result, dataHash) {
   const existingTask = state.tasks[taskName] ?? createDefaultTaskState();
   const taskConfig = graph.tasks[taskName];
   if (!taskConfig) {
@@ -95,6 +93,19 @@ function applyTaskCompletion(state, graph, taskName, result) {
   } else {
     outputTokens = getProvides(taskConfig);
   }
+  const lastConsumedHashes = { ...existingTask.lastConsumedHashes };
+  const requires = taskConfig.requires ?? [];
+  for (const token of requires) {
+    for (const [otherName, otherConfig] of Object.entries(graph.tasks)) {
+      if (getProvides(otherConfig).includes(token)) {
+        const otherState = state.tasks[otherName];
+        if (otherState?.lastDataHash) {
+          lastConsumedHashes[token] = otherState.lastDataHash;
+        }
+        break;
+      }
+    }
+  }
   const updatedTask = {
     ...existingTask,
     status: "completed",
@@ -102,11 +113,10 @@ function applyTaskCompletion(state, graph, taskName, result) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
     executionCount: existingTask.executionCount + 1,
     lastEpoch: existingTask.executionCount + 1,
+    lastDataHash: dataHash,
+    lastConsumedHashes,
     error: void 0
   };
-  if (isRepeatableTask(taskConfig)) {
-    updatedTask.status = "not-started";
-  }
   const newOutputs = [.../* @__PURE__ */ new Set([...state.availableOutputs, ...outputTokens])];
   return {
     ...state,
@@ -219,7 +229,7 @@ function applyEvent(live, event) {
       newState = applyTaskStart(state, event.taskName);
       break;
     case "task-completed":
-      newState = applyTaskCompletion(state, config, event.taskName, event.result);
+      newState = applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash);
       break;
     case "task-failed":
       newState = applyTaskFailure(state, config, event.taskName, event.error);
@@ -242,6 +252,9 @@ function applyEvent(live, event) {
   }
   return { config, state: newState };
 }
+function applyEvents(live, events) {
+  return events.reduce((current, event) => applyEvent(current, event), live);
+}
 function addNode(live, name, taskConfig) {
   if (live.config.tasks[name]) return live;
   return {
@@ -486,38 +499,84 @@ function schedule(live) {
   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;
+    const strategy = getRefreshStrategy(taskConfig, config.settings);
+    const rerunnable = strategy !== "once";
+    if (taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+      continue;
+    }
+    const maxExec = getMaxExecutions(taskConfig);
+    if (maxExec !== void 0 && taskState && taskState.executionCount >= maxExec) {
+      continue;
+    }
+    if (taskConfig.circuit_breaker && taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
+      continue;
+    }
+    if (!rerunnable && taskState?.status === TASK_STATUS.COMPLETED) {
+      continue;
+    }
+    if (rerunnable && taskState?.status === TASK_STATUS.COMPLETED) {
+      const requires2 = getRequires(taskConfig);
+      let shouldSkip = false;
+      switch (strategy) {
+        case "data-changed": {
+          if (requires2.length > 0) {
+            const hasChangedData = requires2.some((req) => {
+              for (const [otherName, otherConfig] of Object.entries(graphTasks)) {
+                if (getProvides(otherConfig).includes(req)) {
+                  const otherState = state.tasks[otherName];
+                  if (!otherState) continue;
+                  const consumed = taskState.lastConsumedHashes?.[req];
+                  if (otherState.lastDataHash == null) {
+                    return otherState.executionCount > taskState.lastEpoch;
+                  }
+                  return otherState.lastDataHash !== consumed;
+                }
               }
-            }
-            return false;
-          });
-          if (!hasRefreshed) continue;
-        } else {
-          continue;
+              return false;
+            });
+            if (!hasChangedData) shouldSkip = true;
+          } else {
+            shouldSkip = true;
+          }
+          break;
+        }
+        case "epoch-changed": {
+          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) shouldSkip = true;
+          } else {
+            shouldSkip = true;
+          }
+          break;
+        }
+        case "time-based": {
+          const interval = taskConfig.refreshInterval ?? 0;
+          if (interval <= 0) {
+            shouldSkip = true;
+            break;
+          }
+          const completedAt = taskState.completedAt;
+          if (!completedAt) {
+            shouldSkip = true;
+            break;
+          }
+          const elapsedSec = (Date.now() - Date.parse(completedAt)) / 1e3;
+          if (elapsedSec < interval) shouldSkip = true;
+          break;
         }
+        case "manual":
+          shouldSkip = true;
+          break;
       }
+      if (shouldSkip) continue;
     }
     const requires = getRequires(taskConfig);
     if (requires.length === 0) {
@@ -912,12 +971,310 @@ function getDownstream(live, nodeName) {
   }));
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
+var MemoryJournal = class {
+  buffer = [];
+  append(event) {
+    this.buffer.push(event);
+  }
+  drain() {
+    const events = this.buffer;
+    this.buffer = [];
+    return events;
+  }
+  get size() {
+    return this.buffer.length;
+  }
+};
+var FileJournal = class {
+  constructor(path) {
+    this.path = path;
+    if (!fs.existsSync(path)) {
+      fs.writeFileSync(path, "", "utf-8");
+    }
+  }
+  path;
+  pending = 0;
+  append(event) {
+    fs.appendFileSync(this.path, JSON.stringify(event) + "\n", "utf-8");
+    this.pending++;
+  }
+  drain() {
+    const content = fs.readFileSync(this.path, "utf-8").trim();
+    fs.writeFileSync(this.path, "", "utf-8");
+    this.pending = 0;
+    if (!content) return [];
+    return content.split("\n").map((line) => JSON.parse(line));
+  }
+  get size() {
+    try {
+      const content = fs.readFileSync(this.path, "utf-8").trim();
+      if (!content) return 0;
+      return content.split("\n").length;
+    } catch {
+      return this.pending;
+    }
+  }
+};
+
+// src/continuous-event-graph/reactive.ts
+function createReactiveGraph(config, options, executionId) {
+  const {
+    handlers: initialHandlers,
+    maxDispatchRetries = 3,
+    defaultTimeoutMs = 3e4,
+    journal = new MemoryJournal(),
+    onDispatchFailed,
+    onAbandoned,
+    onDrain
+  } = options;
+  let live = createLiveGraph(config, executionId);
+  let disposed = false;
+  const handlers = new Map(Object.entries(initialHandlers));
+  const dispatched = /* @__PURE__ */ new Map();
+  const timeoutTimers = /* @__PURE__ */ new Map();
+  let draining = false;
+  let drainQueued = false;
+  function drain() {
+    if (disposed) return;
+    if (draining) {
+      drainQueued = true;
+      return;
+    }
+    draining = true;
+    try {
+      do {
+        drainQueued = false;
+        drainOnce();
+      } while (drainQueued);
+    } finally {
+      draining = false;
+    }
+  }
+  function drainOnce() {
+    sweepTimeouts();
+    const events = journal.drain();
+    for (const event of events) {
+      if (event.type === "task-completed" || event.type === "task-failed") {
+        const taskName = event.taskName;
+        dispatched.delete(taskName);
+        clearTimeout(timeoutTimers.get(taskName));
+        timeoutTimers.delete(taskName);
+      }
+    }
+    if (events.length > 0) {
+      live = applyEvents(live, events);
+    }
+    const result = schedule(live);
+    if (onDrain && events.length > 0) {
+      onDrain(events, live, result);
+    }
+    for (const taskName of result.eligible) {
+      if (dispatched.has(taskName)) continue;
+      dispatchTask(taskName);
+    }
+    for (const [taskName, entry] of dispatched) {
+      if (entry.status === "retry-queued") {
+        dispatchTask(taskName);
+      }
+    }
+  }
+  function dispatchTask(taskName) {
+    const handler = handlers.get(taskName);
+    if (!handler) {
+      journal.append({
+        type: "task-failed",
+        taskName,
+        error: `No handler registered for task "${taskName}"`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      drainQueued = true;
+      return;
+    }
+    const existing = dispatched.get(taskName);
+    const attempt = existing ? existing.dispatchAttempts + 1 : 1;
+    if (attempt > maxDispatchRetries) {
+      dispatched.set(taskName, {
+        status: "abandoned",
+        dispatchedAt: existing?.dispatchedAt ?? Date.now(),
+        dispatchAttempts: attempt - 1,
+        lastError: existing?.lastError
+      });
+      onAbandoned?.(taskName);
+      journal.append({
+        type: "task-failed",
+        taskName,
+        error: `dispatch-abandoned: handler unreachable after ${attempt - 1} attempts${existing?.lastError ? ` (${existing.lastError})` : ""}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      drainQueued = true;
+      return;
+    }
+    dispatched.set(taskName, {
+      status: "initiated",
+      dispatchedAt: Date.now(),
+      dispatchAttempts: attempt
+    });
+    journal.append({
+      type: "task-started",
+      taskName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (defaultTimeoutMs > 0) {
+      const timer = setTimeout(() => {
+        if (disposed) return;
+        const entry = dispatched.get(taskName);
+        if (entry?.status === "initiated") {
+          dispatched.set(taskName, {
+            ...entry,
+            status: "timed-out"
+          });
+          dispatched.set(taskName, {
+            ...entry,
+            status: entry.dispatchAttempts >= maxDispatchRetries ? "abandoned" : "retry-queued"
+          });
+          if (entry.dispatchAttempts >= maxDispatchRetries) {
+            onAbandoned?.(taskName);
+            journal.append({
+              type: "task-failed",
+              taskName,
+              error: `dispatch-timeout: no callback after ${defaultTimeoutMs}ms (${entry.dispatchAttempts} attempts)`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          drain();
+        }
+      }, defaultTimeoutMs);
+      timeoutTimers.set(taskName, timer);
+    }
+    const ctx = {
+      taskName,
+      live,
+      config: live.config.tasks[taskName]
+    };
+    try {
+      const promise = handler(ctx);
+      promise.then(
+        (handlerResult) => {
+          if (disposed) return;
+          clearTimeout(timeoutTimers.get(taskName));
+          timeoutTimers.delete(taskName);
+          journal.append({
+            type: "task-completed",
+            taskName,
+            result: handlerResult.result,
+            data: handlerResult.data,
+            dataHash: handlerResult.dataHash,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          drain();
+        },
+        (error) => {
+          if (disposed) return;
+          clearTimeout(timeoutTimers.get(taskName));
+          timeoutTimers.delete(taskName);
+          journal.append({
+            type: "task-failed",
+            taskName,
+            error: error.message ?? String(error),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          drain();
+        }
+      );
+    } catch (syncError) {
+      const err = syncError instanceof Error ? syncError : new Error(String(syncError));
+      dispatched.set(taskName, {
+        status: "dispatch-failed",
+        dispatchedAt: Date.now(),
+        dispatchAttempts: attempt,
+        lastError: err.message
+      });
+      onDispatchFailed?.(taskName, err, attempt);
+      dispatched.set(taskName, {
+        ...dispatched.get(taskName),
+        status: "retry-queued"
+      });
+      drainQueued = true;
+    }
+  }
+  function sweepTimeouts() {
+    const now = Date.now();
+    for (const [taskName, entry] of dispatched) {
+      if (entry.status !== "initiated") continue;
+      if (defaultTimeoutMs <= 0) continue;
+      if (now - entry.dispatchedAt >= defaultTimeoutMs) {
+        dispatched.set(taskName, {
+          ...entry,
+          status: entry.dispatchAttempts >= maxDispatchRetries ? "abandoned" : "retry-queued"
+        });
+        if (entry.dispatchAttempts >= maxDispatchRetries) {
+          onAbandoned?.(taskName);
+          journal.append({
+            type: "task-failed",
+            taskName,
+            error: `dispatch-timeout: no callback after ${defaultTimeoutMs}ms (${entry.dispatchAttempts} attempts)`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        clearTimeout(timeoutTimers.get(taskName));
+        timeoutTimers.delete(taskName);
+      }
+    }
+  }
+  return {
+    push(event) {
+      if (disposed) return;
+      live = applyEvent(live, event);
+      drain();
+    },
+    pushAll(events) {
+      if (disposed) return;
+      if (events.length === 0) return;
+      live = applyEvents(live, events);
+      drain();
+    },
+    addNode(name, taskConfig, handler) {
+      if (disposed) return;
+      live = addNode(live, name, taskConfig);
+      handlers.set(name, handler);
+      drain();
+    },
+    removeNode(name) {
+      if (disposed) return;
+      live = removeNode(live, name);
+      handlers.delete(name);
+      dispatched.delete(name);
+      clearTimeout(timeoutTimers.get(name));
+      timeoutTimers.delete(name);
+    },
+    getState() {
+      return live;
+    },
+    getSchedule() {
+      return schedule(live);
+    },
+    getDispatchState() {
+      return dispatched;
+    },
+    dispose() {
+      disposed = true;
+      for (const timer of timeoutTimers.values()) {
+        clearTimeout(timer);
+      }
+      timeoutTimers.clear();
+    }
+  };
+}
 
+exports.FileJournal = FileJournal;
+exports.MemoryJournal = MemoryJournal;
 exports.addNode = addNode;
 exports.addProvides = addProvides;
 exports.addRequires = addRequires;
 exports.applyEvent = applyEvent;
+exports.applyEvents = applyEvents;
 exports.createLiveGraph = createLiveGraph;
+exports.createReactiveGraph = createReactiveGraph;
 exports.disableNode = disableNode;
 exports.drainTokens = drainTokens;
 exports.enableNode = enableNode;