yaml-flow 2.3.0 → 2.5.0

package/dist/types-C2lOwquM.d.cts

@@ -0,0 +1,135 @@
+import { G as GraphConfig, c as ExecutionState, T as TaskConfig, l as TaskState } from './types-DAI_a2as.cjs';
+
+/**
+ * Continuous Event Graph — Types
+ *
+ * A long-lived, evolving event-graph where both config and state
+ * mutate over time. The single `LiveGraph` type bundles them.
+ *
+ * Events are shared with event-graph (task-started, task-completed, etc.).
+ * Graph mutations (addNode, removeNode, etc.) are unique to this mode.
+ */
+
+/**
+ * The single evolving object for a continuous-mode graph.
+ * Bundles config + state so they can't get out of sync.
+ */
+interface LiveGraph {
+    /** The current graph configuration (evolves as nodes are added/removed) */
+    config: GraphConfig;
+    /** The current execution state (evolves as events arrive) */
+    state: ExecutionState;
+}
+interface ScheduleResult {
+    /** Tasks ready to dispatch now — all requires satisfied */
+    eligible: string[];
+    /** Tasks waiting on tokens that some producer will eventually provide (normal) */
+    pending: PendingTask[];
+    /** Tasks waiting on tokens that NO task can produce (caller's problem) */
+    unresolved: UnresolvedDependency[];
+    /** Tasks waiting on tokens whose producer FAILED (caller's problem) */
+    blocked: BlockedTask[];
+    /** Token conflicts: multiple tasks produce the same token */
+    conflicts: Record<string, string[]>;
+}
+interface PendingTask {
+    taskName: string;
+    /** Tokens this task needs that haven't been produced yet but have a viable producer */
+    waitingOn: string[];
+}
+interface UnresolvedDependency {
+    taskName: string;
+    /** Tokens this task needs that no task in the graph can produce */
+    missingTokens: string[];
+}
+interface BlockedTask {
+    taskName: string;
+    /** Tokens this task needs whose only producer has failed */
+    failedTokens: string[];
+    /** The tasks that failed and would have produced those tokens */
+    failedProducers: string[];
+}
+interface LiveGraphHealth {
+    /** Total number of tasks in the graph */
+    totalNodes: number;
+    /** Task counts by status */
+    running: number;
+    completed: number;
+    failed: number;
+    waiting: number;
+    notStarted: number;
+    /** Number of disabled (inactivated) nodes */
+    disabled: number;
+    /** Number of tasks with unresolvable dependencies */
+    unresolvedCount: number;
+    /** Number of tasks whose producer has failed */
+    blockedCount: number;
+    /** Tokens that no task produces (open dependencies) */
+    openDependencies: string[];
+    /** Cycles detected in the current graph (if any) */
+    cycles: string[][];
+    /** Tokens produced by multiple tasks */
+    conflictTokens: string[];
+}
+interface NodeInfo {
+    /** Node name */
+    name: string;
+    /** The task configuration */
+    config: TaskConfig;
+    /** The current runtime state */
+    state: TaskState;
+}
+interface LiveGraphSnapshot {
+    /** Schema version for forward compatibility */
+    version: number;
+    /** The graph config at snapshot time */
+    config: GraphConfig;
+    /** The execution state at snapshot time */
+    state: ExecutionState;
+    /** ISO timestamp of when the snapshot was taken */
+    snapshotAt: string;
+}
+interface UnreachableTokensResult {
+    tokens: {
+        /** The token that cannot be produced */
+        token: string;
+        /** Why it's unreachable */
+        reason: 'no-producer' | 'all-producers-failed' | 'transitive';
+        /** Tasks that could produce it (but are themselves unreachable/failed) */
+        producers: string[];
+    }[];
+}
+interface UnreachableNodesResult {
+    nodes: {
+        /** The node that can never become eligible */
+        nodeName: string;
+        /** Unreachable tokens this node requires (empty if the node itself is failed/disabled) */
+        missingTokens: string[];
+    }[];
+}
+interface UpstreamResult {
+    /** The target node being inspected */
+    nodeName: string;
+    /** All upstream nodes that transitively feed into the target */
+    nodes: {
+        nodeName: string;
+        /** Tokens this node provides that are in the dependency chain */
+        providesTokens: string[];
+    }[];
+    /** All tokens in the upstream dependency chain */
+    tokens: string[];
+}
+interface DownstreamResult {
+    /** The target node being inspected */
+    nodeName: string;
+    /** All downstream nodes that transitively depend on the target */
+    nodes: {
+        nodeName: string;
+        /** Tokens this node requires that are in the dependency chain */
+        requiresTokens: string[];
+    }[];
+    /** All tokens in the downstream dependency chain */
+    tokens: string[];
+}
+
+export type { BlockedTask as B, DownstreamResult as D, LiveGraph as L, NodeInfo as N, PendingTask as P, ScheduleResult as S, UnreachableNodesResult as U, LiveGraphHealth as a, LiveGraphSnapshot as b, UnreachableTokensResult as c, UnresolvedDependency as d, UpstreamResult as e };

package/dist/types-DAI_a2as.d.cts

@@ -0,0 +1,198 @@
+/**
+ * Event Graph — Core Types
+ *
+ * Type definitions for the stateless event-graph engine.
+ * Pure: f(state, event) → newState
+ */
+interface GraphConfig {
+    id?: string;
+    settings: GraphSettings;
+    tasks: Record<string, TaskConfig>;
+}
+interface GraphSettings {
+    /** Completion strategy */
+    completion: CompletionStrategy;
+    /** Conflict resolution strategy */
+    conflict_strategy?: ConflictStrategy;
+    /** Execution mode */
+    execution_mode?: ExecutionMode;
+    /** Goal outputs — used with 'goal-reached' completion */
+    goal?: string[];
+    /** Max total scheduler iterations (safety limit, default: 1000) */
+    max_iterations?: number;
+    /** Timeout in ms (declared for drivers, not enforced by pure engine) */
+    timeout_ms?: number;
+}
+interface TaskConfig {
+    /** What this task needs to become eligible */
+    requires?: string[];
+    /** What this task produces on successful completion */
+    provides: string[];
+    /** Conditional provides based on handler result */
+    on?: Record<string, string[]>;
+    /** Tokens to inject into available outputs on failure */
+    on_failure?: string[];
+    /** Task execution method (informational — driver concern) */
+    method?: string;
+    /** Arbitrary task configuration (driver concern) */
+    config?: Record<string, unknown>;
+    /** Task priority (higher = preferred in conflict resolution) */
+    priority?: number;
+    /** Estimated duration in ms (used by duration-first strategy) */
+    estimatedDuration?: number;
+    /** Estimated cost (used by cost-optimized strategy) */
+    estimatedCost?: number;
+    /** Resource requirements (used by resource-aware strategy) */
+    estimatedResources?: Record<string, number>;
+    /** Retry configuration */
+    retry?: TaskRetryConfig;
+    /** Repeatable task configuration */
+    repeatable?: boolean | RepeatableConfig;
+    /** Circuit breaker: max executions before breaking */
+    circuit_breaker?: TaskCircuitBreakerConfig;
+    /** Description */
+    description?: string;
+    /** LLM inference hints — opt-in metadata for AI-assisted completion detection */
+    inference?: {
+        /** Human-readable completion criteria */
+        criteria?: string;
+        /** Keywords to help the LLM understand the domain */
+        keywords?: string[];
+        /** Suggested checks for verification */
+        suggestedChecks?: string[];
+        /** Whether the LLM should attempt to auto-detect completion (default: false) */
+        autoDetectable?: boolean;
+    };
+}
+interface TaskRetryConfig {
+    max_attempts: number;
+    delay_ms?: number;
+    backoff_multiplier?: number;
+}
+interface RepeatableConfig {
+    /** Max times this task can repeat (undefined = unlimited) */
+    max?: number;
+}
+interface TaskCircuitBreakerConfig {
+    /** Max executions before injecting break tokens */
+    max_executions: number;
+    /** Tokens to inject when breaker trips */
+    on_break: string[];
+}
+interface ExecutionState {
+    /** Current status of the execution */
+    status: ExecutionStatus;
+    /** Task states keyed by task name */
+    tasks: Record<string, TaskState>;
+    /** Tokens currently available in the system */
+    availableOutputs: string[];
+    /** Stuck detection result */
+    stuckDetection: StuckDetection;
+    /** Last update timestamp */
+    lastUpdated: string;
+    /** Execution ID for this run */
+    executionId: string | null;
+    /** Execution configuration */
+    executionConfig: ExecutionConfig;
+}
+interface ExecutionConfig {
+    executionMode: ExecutionMode;
+    conflictStrategy: ConflictStrategy;
+    completionStrategy: CompletionStrategy;
+}
+interface TaskState {
+    status: TaskStatus;
+    executionCount: number;
+    retryCount: number;
+    lastEpoch: number;
+    startedAt?: string;
+    completedAt?: string;
+    failedAt?: string;
+    lastUpdated?: string;
+    error?: string;
+    messages?: TaskMessage[];
+    progress?: number | null;
+}
+interface TaskMessage {
+    message: string;
+    timestamp: string;
+    status: string;
+}
+interface StuckDetection {
+    is_stuck: boolean;
+    stuck_description: string | null;
+    outputs_unresolvable: string[];
+    tasks_blocked: string[];
+}
+type GraphEvent = TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | TaskProgressEvent | InjectTokensEvent | AgentActionEvent | TaskCreationEvent;
+interface TaskStartedEvent {
+    type: 'task-started';
+    taskName: string;
+    timestamp: string;
+    executionId?: string;
+}
+interface TaskCompletedEvent {
+    type: 'task-completed';
+    taskName: string;
+    /** Handler result key — used for conditional routing via `on` */
+    result?: string;
+    /** Data payload from task execution */
+    data?: Record<string, unknown>;
+    timestamp: string;
+    executionId?: string;
+}
+interface TaskFailedEvent {
+    type: 'task-failed';
+    taskName: string;
+    error: string;
+    timestamp: string;
+    executionId?: string;
+}
+interface TaskProgressEvent {
+    type: 'task-progress';
+    taskName: string;
+    message?: string;
+    progress?: number;
+    timestamp: string;
+    executionId?: string;
+}
+interface InjectTokensEvent {
+    type: 'inject-tokens';
+    tokens: string[];
+    timestamp: string;
+}
+interface AgentActionEvent {
+    type: 'agent-action';
+    action: 'start' | 'stop' | 'pause' | 'resume';
+    timestamp: string;
+    config?: Partial<ExecutionConfig>;
+}
+interface TaskCreationEvent {
+    type: 'task-creation';
+    taskName: string;
+    taskConfig: TaskConfig;
+    timestamp: string;
+}
+interface SchedulerResult {
+    /** Tasks eligible for execution */
+    eligibleTasks: string[];
+    /** Whether the graph execution is complete */
+    isComplete: boolean;
+    /** Stuck detection result */
+    stuckDetection: StuckDetection;
+    /** Whether conflicts were detected */
+    hasConflicts: boolean;
+    /** Conflict groups: output → competing task names */
+    conflicts: Record<string, string[]>;
+    /** Strategy used for conflict resolution */
+    strategy: ConflictStrategy;
+    /** Processing log for diagnostics */
+    processingLog: string[];
+}
+type TaskStatus = 'not-started' | 'running' | 'completed' | 'failed' | 'inactivated';
+type ExecutionStatus = 'created' | 'running' | 'paused' | 'stopped' | 'completed' | 'failed';
+type CompletionStrategy = 'all-tasks-done' | 'all-outputs-done' | 'only-resolved' | 'goal-reached' | 'manual';
+type ExecutionMode = 'dependency-mode' | 'eligibility-mode';
+type ConflictStrategy = 'alphabetical' | 'priority-first' | 'duration-first' | 'cost-optimized' | 'resource-aware' | 'random-select' | 'user-choice' | 'parallel-all' | 'skip-conflicts' | 'round-robin';
+
+export type { AgentActionEvent as A, CompletionStrategy as C, ExecutionConfig as E, GraphConfig as G, InjectTokensEvent as I, RepeatableConfig as R, SchedulerResult as S, TaskConfig as T, ConflictStrategy as a, ExecutionMode as b, ExecutionState as c, ExecutionStatus as d, GraphEvent as e, GraphSettings as f, StuckDetection as g, TaskCompletedEvent as h, TaskCreationEvent as i, TaskFailedEvent as j, TaskStartedEvent as k, TaskState as l, TaskStatus as m, TaskCircuitBreakerConfig as n, TaskMessage as o, TaskProgressEvent as p, TaskRetryConfig as q };

package/dist/types-DAI_a2as.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Event Graph — Core Types
+ *
+ * Type definitions for the stateless event-graph engine.
+ * Pure: f(state, event) → newState
+ */
+interface GraphConfig {
+    id?: string;
+    settings: GraphSettings;
+    tasks: Record<string, TaskConfig>;
+}
+interface GraphSettings {
+    /** Completion strategy */
+    completion: CompletionStrategy;
+    /** Conflict resolution strategy */
+    conflict_strategy?: ConflictStrategy;
+    /** Execution mode */
+    execution_mode?: ExecutionMode;
+    /** Goal outputs — used with 'goal-reached' completion */
+    goal?: string[];
+    /** Max total scheduler iterations (safety limit, default: 1000) */
+    max_iterations?: number;
+    /** Timeout in ms (declared for drivers, not enforced by pure engine) */
+    timeout_ms?: number;
+}
+interface TaskConfig {
+    /** What this task needs to become eligible */
+    requires?: string[];
+    /** What this task produces on successful completion */
+    provides: string[];
+    /** Conditional provides based on handler result */
+    on?: Record<string, string[]>;
+    /** Tokens to inject into available outputs on failure */
+    on_failure?: string[];
+    /** Task execution method (informational — driver concern) */
+    method?: string;
+    /** Arbitrary task configuration (driver concern) */
+    config?: Record<string, unknown>;
+    /** Task priority (higher = preferred in conflict resolution) */
+    priority?: number;
+    /** Estimated duration in ms (used by duration-first strategy) */
+    estimatedDuration?: number;
+    /** Estimated cost (used by cost-optimized strategy) */
+    estimatedCost?: number;
+    /** Resource requirements (used by resource-aware strategy) */
+    estimatedResources?: Record<string, number>;
+    /** Retry configuration */
+    retry?: TaskRetryConfig;
+    /** Repeatable task configuration */
+    repeatable?: boolean | RepeatableConfig;
+    /** Circuit breaker: max executions before breaking */
+    circuit_breaker?: TaskCircuitBreakerConfig;
+    /** Description */
+    description?: string;
+    /** LLM inference hints — opt-in metadata for AI-assisted completion detection */
+    inference?: {
+        /** Human-readable completion criteria */
+        criteria?: string;
+        /** Keywords to help the LLM understand the domain */
+        keywords?: string[];
+        /** Suggested checks for verification */
+        suggestedChecks?: string[];
+        /** Whether the LLM should attempt to auto-detect completion (default: false) */
+        autoDetectable?: boolean;
+    };
+}
+interface TaskRetryConfig {
+    max_attempts: number;
+    delay_ms?: number;
+    backoff_multiplier?: number;
+}
+interface RepeatableConfig {
+    /** Max times this task can repeat (undefined = unlimited) */
+    max?: number;
+}
+interface TaskCircuitBreakerConfig {
+    /** Max executions before injecting break tokens */
+    max_executions: number;
+    /** Tokens to inject when breaker trips */
+    on_break: string[];
+}
+interface ExecutionState {
+    /** Current status of the execution */
+    status: ExecutionStatus;
+    /** Task states keyed by task name */
+    tasks: Record<string, TaskState>;
+    /** Tokens currently available in the system */
+    availableOutputs: string[];
+    /** Stuck detection result */
+    stuckDetection: StuckDetection;
+    /** Last update timestamp */
+    lastUpdated: string;
+    /** Execution ID for this run */
+    executionId: string | null;
+    /** Execution configuration */
+    executionConfig: ExecutionConfig;
+}
+interface ExecutionConfig {
+    executionMode: ExecutionMode;
+    conflictStrategy: ConflictStrategy;
+    completionStrategy: CompletionStrategy;
+}
+interface TaskState {
+    status: TaskStatus;
+    executionCount: number;
+    retryCount: number;
+    lastEpoch: number;
+    startedAt?: string;
+    completedAt?: string;
+    failedAt?: string;
+    lastUpdated?: string;
+    error?: string;
+    messages?: TaskMessage[];
+    progress?: number | null;
+}
+interface TaskMessage {
+    message: string;
+    timestamp: string;
+    status: string;
+}
+interface StuckDetection {
+    is_stuck: boolean;
+    stuck_description: string | null;
+    outputs_unresolvable: string[];
+    tasks_blocked: string[];
+}
+type GraphEvent = TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | TaskProgressEvent | InjectTokensEvent | AgentActionEvent | TaskCreationEvent;
+interface TaskStartedEvent {
+    type: 'task-started';
+    taskName: string;
+    timestamp: string;
+    executionId?: string;
+}
+interface TaskCompletedEvent {
+    type: 'task-completed';
+    taskName: string;
+    /** Handler result key — used for conditional routing via `on` */
+    result?: string;
+    /** Data payload from task execution */
+    data?: Record<string, unknown>;
+    timestamp: string;
+    executionId?: string;
+}
+interface TaskFailedEvent {
+    type: 'task-failed';
+    taskName: string;
+    error: string;
+    timestamp: string;
+    executionId?: string;
+}
+interface TaskProgressEvent {
+    type: 'task-progress';
+    taskName: string;
+    message?: string;
+    progress?: number;
+    timestamp: string;
+    executionId?: string;
+}
+interface InjectTokensEvent {
+    type: 'inject-tokens';
+    tokens: string[];
+    timestamp: string;
+}
+interface AgentActionEvent {
+    type: 'agent-action';
+    action: 'start' | 'stop' | 'pause' | 'resume';
+    timestamp: string;
+    config?: Partial<ExecutionConfig>;
+}
+interface TaskCreationEvent {
+    type: 'task-creation';
+    taskName: string;
+    taskConfig: TaskConfig;
+    timestamp: string;
+}
+interface SchedulerResult {
+    /** Tasks eligible for execution */
+    eligibleTasks: string[];
+    /** Whether the graph execution is complete */
+    isComplete: boolean;
+    /** Stuck detection result */
+    stuckDetection: StuckDetection;
+    /** Whether conflicts were detected */
+    hasConflicts: boolean;
+    /** Conflict groups: output → competing task names */
+    conflicts: Record<string, string[]>;
+    /** Strategy used for conflict resolution */
+    strategy: ConflictStrategy;
+    /** Processing log for diagnostics */
+    processingLog: string[];
+}
+type TaskStatus = 'not-started' | 'running' | 'completed' | 'failed' | 'inactivated';
+type ExecutionStatus = 'created' | 'running' | 'paused' | 'stopped' | 'completed' | 'failed';
+type CompletionStrategy = 'all-tasks-done' | 'all-outputs-done' | 'only-resolved' | 'goal-reached' | 'manual';
+type ExecutionMode = 'dependency-mode' | 'eligibility-mode';
+type ConflictStrategy = 'alphabetical' | 'priority-first' | 'duration-first' | 'cost-optimized' | 'resource-aware' | 'random-select' | 'user-choice' | 'parallel-all' | 'skip-conflicts' | 'round-robin';
+
+export type { AgentActionEvent as A, CompletionStrategy as C, ExecutionConfig as E, GraphConfig as G, InjectTokensEvent as I, RepeatableConfig as R, SchedulerResult as S, TaskConfig as T, ConflictStrategy as a, ExecutionMode as b, ExecutionState as c, ExecutionStatus as d, GraphEvent as e, GraphSettings as f, StuckDetection as g, TaskCompletedEvent as h, TaskCreationEvent as i, TaskFailedEvent as j, TaskStartedEvent as k, TaskState as l, TaskStatus as m, TaskCircuitBreakerConfig as n, TaskMessage as o, TaskProgressEvent as p, TaskRetryConfig as q };

package/dist/types-mS_pPftm.d.ts

@@ -0,0 +1,135 @@
+import { G as GraphConfig, c as ExecutionState, T as TaskConfig, l as TaskState } from './types-DAI_a2as.js';
+
+/**
+ * Continuous Event Graph — Types
+ *
+ * A long-lived, evolving event-graph where both config and state
+ * mutate over time. The single `LiveGraph` type bundles them.
+ *
+ * Events are shared with event-graph (task-started, task-completed, etc.).
+ * Graph mutations (addNode, removeNode, etc.) are unique to this mode.
+ */
+
+/**
+ * The single evolving object for a continuous-mode graph.
+ * Bundles config + state so they can't get out of sync.
+ */
+interface LiveGraph {
+    /** The current graph configuration (evolves as nodes are added/removed) */
+    config: GraphConfig;
+    /** The current execution state (evolves as events arrive) */
+    state: ExecutionState;
+}
+interface ScheduleResult {
+    /** Tasks ready to dispatch now — all requires satisfied */
+    eligible: string[];
+    /** Tasks waiting on tokens that some producer will eventually provide (normal) */
+    pending: PendingTask[];
+    /** Tasks waiting on tokens that NO task can produce (caller's problem) */
+    unresolved: UnresolvedDependency[];
+    /** Tasks waiting on tokens whose producer FAILED (caller's problem) */
+    blocked: BlockedTask[];
+    /** Token conflicts: multiple tasks produce the same token */
+    conflicts: Record<string, string[]>;
+}
+interface PendingTask {
+    taskName: string;
+    /** Tokens this task needs that haven't been produced yet but have a viable producer */
+    waitingOn: string[];
+}
+interface UnresolvedDependency {
+    taskName: string;
+    /** Tokens this task needs that no task in the graph can produce */
+    missingTokens: string[];
+}
+interface BlockedTask {
+    taskName: string;
+    /** Tokens this task needs whose only producer has failed */
+    failedTokens: string[];
+    /** The tasks that failed and would have produced those tokens */
+    failedProducers: string[];
+}
+interface LiveGraphHealth {
+    /** Total number of tasks in the graph */
+    totalNodes: number;
+    /** Task counts by status */
+    running: number;
+    completed: number;
+    failed: number;
+    waiting: number;
+    notStarted: number;
+    /** Number of disabled (inactivated) nodes */
+    disabled: number;
+    /** Number of tasks with unresolvable dependencies */
+    unresolvedCount: number;
+    /** Number of tasks whose producer has failed */
+    blockedCount: number;
+    /** Tokens that no task produces (open dependencies) */
+    openDependencies: string[];
+    /** Cycles detected in the current graph (if any) */
+    cycles: string[][];
+    /** Tokens produced by multiple tasks */
+    conflictTokens: string[];
+}
+interface NodeInfo {
+    /** Node name */
+    name: string;
+    /** The task configuration */
+    config: TaskConfig;
+    /** The current runtime state */
+    state: TaskState;
+}
+interface LiveGraphSnapshot {
+    /** Schema version for forward compatibility */
+    version: number;
+    /** The graph config at snapshot time */
+    config: GraphConfig;
+    /** The execution state at snapshot time */
+    state: ExecutionState;
+    /** ISO timestamp of when the snapshot was taken */
+    snapshotAt: string;
+}
+interface UnreachableTokensResult {
+    tokens: {
+        /** The token that cannot be produced */
+        token: string;
+        /** Why it's unreachable */
+        reason: 'no-producer' | 'all-producers-failed' | 'transitive';
+        /** Tasks that could produce it (but are themselves unreachable/failed) */
+        producers: string[];
+    }[];
+}
+interface UnreachableNodesResult {
+    nodes: {
+        /** The node that can never become eligible */
+        nodeName: string;
+        /** Unreachable tokens this node requires (empty if the node itself is failed/disabled) */
+        missingTokens: string[];
+    }[];
+}
+interface UpstreamResult {
+    /** The target node being inspected */
+    nodeName: string;
+    /** All upstream nodes that transitively feed into the target */
+    nodes: {
+        nodeName: string;
+        /** Tokens this node provides that are in the dependency chain */
+        providesTokens: string[];
+    }[];
+    /** All tokens in the upstream dependency chain */
+    tokens: string[];
+}
+interface DownstreamResult {
+    /** The target node being inspected */
+    nodeName: string;
+    /** All downstream nodes that transitively depend on the target */
+    nodes: {
+        nodeName: string;
+        /** Tokens this node requires that are in the dependency chain */
+        requiresTokens: string[];
+    }[];
+    /** All tokens in the downstream dependency chain */
+    tokens: string[];
+}
+
+export type { BlockedTask as B, DownstreamResult as D, LiveGraph as L, NodeInfo as N, PendingTask as P, ScheduleResult as S, UnreachableNodesResult as U, LiveGraphHealth as a, LiveGraphSnapshot as b, UnreachableTokensResult as c, UnresolvedDependency as d, UpstreamResult as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml-flow",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Unified workflow engine: step-machine (sequential) + event-graph (stateless DAG) with pluggable storage",
   "author": "",
   "license": "MIT",
@@ -53,6 +53,16 @@
       "types": "./dist/config/index.d.ts",
       "import": "./dist/config/index.js",
       "require": "./dist/config/index.cjs"
+    },
+    "./continuous-event-graph": {
+      "types": "./dist/continuous-event-graph/index.d.ts",
+      "import": "./dist/continuous-event-graph/index.js",
+      "require": "./dist/continuous-event-graph/index.cjs"
+    },
+    "./inference": {
+      "types": "./dist/inference/index.d.ts",
+      "import": "./dist/inference/index.js",
+      "require": "./dist/inference/index.cjs"
     }
   },
   "browser": {