yaml-flow 1.0.0 → 2.1.0

package/dist/config/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Variable interpolation for workflow configs.
+ *
+ * Walks any object/array and replaces `${KEY}` patterns with values from
+ * a variables map. Pure function — returns a new object, never mutates.
+ *
+ * Works on both GraphConfig and StepFlowConfig (or any plain object).
+ *
+ * @example
+ * ```ts
+ * const resolved = resolveVariables(config, {
+ *   ENTITY_ID: 'ticket-42',
+ *   TOOLS_DIR: '/opt/tools',
+ * });
+ * ```
+ */
+type Variables = Record<string, string | number | boolean>;
+/**
+ * Resolve `${KEY}` variable references in a workflow config object.
+ *
+ * Pure function: config in → new config out. Works on any shape
+ * (GraphConfig, StepFlowConfig, or arbitrary objects).
+ *
+ * @param config  - The config object to interpolate
+ * @param variables - Key-value pairs to substitute
+ * @returns A new config with all `${KEY}` patterns replaced
+ */
+declare function resolveVariables<T extends Record<string, unknown>>(config: T, variables: Variables): T;
+
+/**
+ * Config template resolution for workflow configs.
+ *
+ * In large graphs, many tasks share the same base config (cmd, timeout, cwd, headers, etc.).
+ * Instead of duplicating, tasks reference a named template via `config-template`.
+ * This function deep-merges the template into each task's config, then removes the reference.
+ *
+ * Pure function — returns a new config, never mutates.
+ *
+ * @example
+ * ```ts
+ * const config = {
+ *   configTemplates: {
+ *     PYTHON_TOOL: { cmd: 'python', timeout: 30000, cwd: '/workdata' }
+ *   },
+ *   tasks: {
+ *     analyze: {
+ *       provides: ['analysis'],
+ *       config: { 'config-template': 'PYTHON_TOOL', 'cmd-args': 'analyze.py' }
+ *     }
+ *   }
+ * };
+ * const resolved = resolveConfigTemplates(config);
+ * // analyze.config → { cmd: 'python', timeout: 30000, cwd: '/workdata', 'cmd-args': 'analyze.py' }
+ * ```
+ */
+/** Shape of a config-templates block */
+type ConfigTemplates = Record<string, Record<string, unknown>>;
+/**
+ * Resolve `config-template` references in task configs against a `configTemplates` map.
+ *
+ * Accepts any config object that may contain:
+ *   - `configTemplates` (camelCase) or `config-templates` (kebab-case) at the top level
+ *   - `tasks` (event-graph) or `steps` (step-machine) containing task/step objects
+ *   - Each task/step may have a `config` sub-object with a `config-template` key
+ *
+ * Returns a new config with templates merged and references removed.
+ * The `configTemplates` / `config-templates` key is also removed from the output.
+ */
+declare function resolveConfigTemplates<T extends Record<string, unknown>>(config: T): T;
+
+export { type ConfigTemplates, type Variables, resolveConfigTemplates, resolveVariables };

package/dist/config/index.js

@@ -0,0 +1,77 @@
+// src/config/resolve-variables.ts
+function interpolateString(template, vars) {
+  return template.replace(/\$\{([^}]+)\}/g, (match, key) => {
+    const value = vars[key.trim()];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+function walkAndInterpolate(value, vars) {
+  if (typeof value === "string") {
+    return interpolateString(value, vars);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => walkAndInterpolate(item, vars));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = walkAndInterpolate(v, vars);
+    }
+    return result;
+  }
+  return value;
+}
+function resolveVariables(config, variables) {
+  return walkAndInterpolate(config, variables);
+}
+
+// src/config/resolve-config-templates.ts
+function mergeConfigs(template, taskConfig) {
+  const merged = { ...template };
+  for (const [key, value] of Object.entries(taskConfig)) {
+    if (key === "config-template") continue;
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && merged[key] !== null && typeof merged[key] === "object" && !Array.isArray(merged[key])) {
+      merged[key] = {
+        ...merged[key],
+        ...value
+      };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function resolveConfigTemplates(config) {
+  const templates = config["configTemplates"] ?? config["config-templates"] ?? {};
+  const tasksKey = "tasks" in config ? "tasks" : "steps" in config ? "steps" : null;
+  if (!tasksKey) return config;
+  const tasks = config[tasksKey];
+  if (!tasks || typeof tasks !== "object") return config;
+  const resolvedTasks = {};
+  for (const [name, task] of Object.entries(tasks)) {
+    const taskConfig = task["config"];
+    const templateName = taskConfig?.["config-template"];
+    if (!templateName || !taskConfig) {
+      resolvedTasks[name] = task;
+      continue;
+    }
+    const template = templates[templateName];
+    if (!template) {
+      const { "config-template": _, ...rest } = taskConfig;
+      resolvedTasks[name] = { ...task, config: rest };
+      continue;
+    }
+    resolvedTasks[name] = {
+      ...task,
+      config: mergeConfigs(template, taskConfig)
+    };
+  }
+  const result = { ...config, [tasksKey]: resolvedTasks };
+  delete result["configTemplates"];
+  delete result["config-templates"];
+  return result;
+}
+
+export { resolveConfigTemplates, resolveVariables };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/resolve-variables.ts","../../src/config/resolve-config-templates.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Variable interpolation for workflow configs.\n *\n * Walks any object/array and replaces `${KEY}` patterns with values from\n * a variables map. Pure function — returns a new object, never mutates.\n *\n * Works on both GraphConfig and StepFlowConfig (or any plain object).\n *\n * @example\n * ```ts\n * const resolved = resolveVariables(config, {\n *   ENTITY_ID: 'ticket-42',\n *   TOOLS_DIR: '/opt/tools',\n * });\n * ```\n */\n\nexport type Variables = Record<string, string | number | boolean>;\n\n/**\n * Replace `${KEY}` patterns in a string with values from the variables map.\n * Unmatched variables are left as-is.\n */\nfunction interpolateString(template: string, vars: Variables): string {\n  return template.replace(/\\$\\{([^}]+)\\}/g, (match, key: string) => {\n    const value = vars[key.trim()];\n    return value !== undefined ? String(value) : match;\n  });\n}\n\n/**\n * Recursively walk a value and interpolate any `${KEY}` patterns found in strings.\n * Returns a new object/array — never mutates the input.\n */\nfunction walkAndInterpolate<T>(value: T, vars: Variables): T {\n  if (typeof value === 'string') {\n    return interpolateString(value, vars) as unknown as T;\n  }\n  if (Array.isArray(value)) {\n    return value.map((item) => walkAndInterpolate(item, vars)) as unknown as T;\n  }\n  if (value !== null && typeof value === 'object') {\n    const result: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(value)) {\n      result[k] = walkAndInterpolate(v, vars);\n    }\n    return result as T;\n  }\n  // numbers, booleans, null, undefined — pass through\n  return value;\n}\n\n/**\n * Resolve `${KEY}` variable references in a workflow config object.\n *\n * Pure function: config in → new config out. Works on any shape\n * (GraphConfig, StepFlowConfig, or arbitrary objects).\n *\n * @param config  - The config object to interpolate\n * @param variables - Key-value pairs to substitute\n * @returns A new config with all `${KEY}` patterns replaced\n */\nexport function resolveVariables<T extends Record<string, unknown>>(\n  config: T,\n  variables: Variables,\n): T {\n  return walkAndInterpolate(config, variables);\n}\n","/**\n * Config template resolution for workflow configs.\n *\n * In large graphs, many tasks share the same base config (cmd, timeout, cwd, headers, etc.).\n * Instead of duplicating, tasks reference a named template via `config-template`.\n * This function deep-merges the template into each task's config, then removes the reference.\n *\n * Pure function — returns a new config, never mutates.\n *\n * @example\n * ```ts\n * const config = {\n *   configTemplates: {\n *     PYTHON_TOOL: { cmd: 'python', timeout: 30000, cwd: '/workdata' }\n *   },\n *   tasks: {\n *     analyze: {\n *       provides: ['analysis'],\n *       config: { 'config-template': 'PYTHON_TOOL', 'cmd-args': 'analyze.py' }\n *     }\n *   }\n * };\n * const resolved = resolveConfigTemplates(config);\n * // analyze.config → { cmd: 'python', timeout: 30000, cwd: '/workdata', 'cmd-args': 'analyze.py' }\n * ```\n */\n\n/** Shape of a config-templates block */\nexport type ConfigTemplates = Record<string, Record<string, unknown>>;\n\n/**\n * Deep-merge template into task config.\n * Task-level values override template values.\n * Nested objects are merged one level deep (like SwarmX's pattern).\n */\nfunction mergeConfigs(\n  template: Record<string, unknown>,\n  taskConfig: Record<string, unknown>,\n): Record<string, unknown> {\n  const merged: Record<string, unknown> = { ...template };\n\n  for (const [key, value] of Object.entries(taskConfig)) {\n    if (key === 'config-template') continue; // strip the reference\n\n    // One-level deep merge for nested objects (both sides must be plain objects)\n    if (\n      value !== null &&\n      typeof value === 'object' &&\n      !Array.isArray(value) &&\n      merged[key] !== null &&\n      typeof merged[key] === 'object' &&\n      !Array.isArray(merged[key])\n    ) {\n      merged[key] = {\n        ...(merged[key] as Record<string, unknown>),\n        ...(value as Record<string, unknown>),\n      };\n    } else {\n      merged[key] = value;\n    }\n  }\n\n  return merged;\n}\n\n/**\n * Resolve `config-template` references in task configs against a `configTemplates` map.\n *\n * Accepts any config object that may contain:\n *   - `configTemplates` (camelCase) or `config-templates` (kebab-case) at the top level\n *   - `tasks` (event-graph) or `steps` (step-machine) containing task/step objects\n *   - Each task/step may have a `config` sub-object with a `config-template` key\n *\n * Returns a new config with templates merged and references removed.\n * The `configTemplates` / `config-templates` key is also removed from the output.\n */\nexport function resolveConfigTemplates<T extends Record<string, unknown>>(config: T): T {\n  // Find templates — support both naming conventions\n  const templates: ConfigTemplates =\n    (config['configTemplates'] as ConfigTemplates) ??\n    (config['config-templates'] as ConfigTemplates) ??\n    {};\n\n  // Find the tasks/steps container\n  const tasksKey = 'tasks' in config ? 'tasks' : 'steps' in config ? 'steps' : null;\n  if (!tasksKey) return config; // nothing to resolve\n\n  const tasks = config[tasksKey] as Record<string, Record<string, unknown>> | undefined;\n  if (!tasks || typeof tasks !== 'object') return config;\n\n  const resolvedTasks: Record<string, Record<string, unknown>> = {};\n\n  for (const [name, task] of Object.entries(tasks)) {\n    const taskConfig = task['config'] as Record<string, unknown> | undefined;\n    const templateName = taskConfig?.['config-template'] as string | undefined;\n\n    if (!templateName || !taskConfig) {\n      resolvedTasks[name] = task;\n      continue;\n    }\n\n    const template = templates[templateName];\n    if (!template) {\n      // Template not found — leave as-is but strip the reference\n      const { 'config-template': _, ...rest } = taskConfig;\n      resolvedTasks[name] = { ...task, config: rest };\n      continue;\n    }\n\n    resolvedTasks[name] = {\n      ...task,\n      config: mergeConfigs(template, taskConfig),\n    };\n  }\n\n  // Build result — remove the templates key from output\n  const result = { ...config, [tasksKey]: resolvedTasks };\n  delete result['configTemplates'];\n  delete result['config-templates'];\n  return result as T;\n}\n"]}

package/dist/constants-D1fTEbbM.d.cts

@@ -0,0 +1,330 @@
+/**
+ * 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;
+}
+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';
+
+/**
+ * Event Graph — Scheduler
+ *
+ * The core pure function: f(graph, state) → { eligibleTasks, isComplete, isStuck }
+ * No I/O, no side effects, deterministic.
+ */
+
+/**
+ * Determine what tasks should be executed next.
+ * Pure function — the heart of the event-graph engine.
+ */
+declare function next(graph: GraphConfig, state: ExecutionState): SchedulerResult;
+/**
+ * Get candidate tasks whose dependencies are all met.
+ * Handles repeatable tasks and circuit breakers.
+ * Pure function.
+ */
+declare function getCandidateTasks(graph: GraphConfig, state: ExecutionState): string[];
+
+/**
+ * Event Graph — Reducer
+ *
+ * The core state transition function: f(state, event, graph) → newState
+ * No I/O, no side effects, deterministic.
+ */
+
+/**
+ * Apply an event to the current execution state, producing a new state.
+ * Pure function — the heart of the event-graph reducer.
+ *
+ * @param state - Current execution state
+ * @param event - Event to apply
+ * @param graph - Graph configuration (needed for task definitions)
+ * @returns New execution state
+ */
+declare function apply(state: ExecutionState, event: GraphEvent, graph: GraphConfig): ExecutionState;
+/**
+ * Apply multiple events sequentially. Pure function.
+ */
+declare function applyAll(state: ExecutionState, events: GraphEvent[], graph: GraphConfig): ExecutionState;
+
+/**
+ * Event Graph — Graph Helpers
+ *
+ * Pure functions for manipulating the requires/provides task dependency graph.
+ * No I/O, no side effects.
+ */
+
+declare function getProvides(task: TaskConfig | undefined): string[];
+declare function getRequires(task: TaskConfig | undefined): string[];
+declare function getAllTasks(graph: GraphConfig): Record<string, TaskConfig>;
+declare function getTask(graph: GraphConfig, taskName: string): TaskConfig | undefined;
+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;
+/**
+ * Dynamically compute available outputs from all completed tasks.
+ * For repeatable tasks, outputs are versioned by epoch.
+ * Pure function.
+ */
+declare function computeAvailableOutputs(graph: GraphConfig, taskStates: Record<string, TaskState>): string[];
+/**
+ * Group candidate tasks by the outputs they provide.
+ * Used to detect conflicts (multiple tasks providing the same output).
+ */
+declare function groupTasksByProvides(candidateTaskNames: string[], tasks: Record<string, TaskConfig>): Record<string, string[]>;
+/**
+ * Check if a task's outputs conflict with other candidates.
+ */
+declare function hasOutputConflict(taskName: string, taskProvides: string[], candidates: string[], tasks: Record<string, TaskConfig>): boolean;
+declare function addKeyToProvides(task: TaskConfig, key: string): TaskConfig;
+declare function removeKeyFromProvides(task: TaskConfig, key: string): TaskConfig;
+declare function addKeyToRequires(task: TaskConfig, key: string): TaskConfig;
+declare function removeKeyFromRequires(task: TaskConfig, key: string): TaskConfig;
+/**
+ * Add a new task to a graph config. Returns a new GraphConfig (immutable).
+ */
+declare function addDynamicTask(graph: GraphConfig, taskName: string, taskConfig: TaskConfig): GraphConfig;
+/**
+ * Create default task state for a new task.
+ */
+declare function createDefaultTaskState(): TaskState;
+/**
+ * Create the initial execution state for a graph.
+ */
+declare function createInitialExecutionState(graph: GraphConfig, executionId: string): ExecutionState;
+
+/**
+ * Event Graph — Completion Detection
+ *
+ * Pure functions to determine if a graph execution is complete.
+ */
+
+interface CompletionResult {
+    isComplete: boolean;
+    expectedCompletion: {
+        taskNames: string[];
+        outputs: string[];
+    };
+}
+/**
+ * Check if graph execution is complete based on the configured strategy.
+ * Pure function.
+ */
+declare function isExecutionComplete(graph: GraphConfig, state: ExecutionState): CompletionResult;
+
+/**
+ * Event Graph — Stuck Detection
+ *
+ * Pure function to detect when a graph execution cannot make progress.
+ */
+
+/**
+ * Detect if the graph execution is stuck.
+ * Stuck = no eligible tasks AND execution is not complete.
+ * Pure function.
+ */
+declare function detectStuckState(params: {
+    graph: GraphConfig;
+    state: ExecutionState;
+    eligibleTasks: string[];
+    completionResult?: CompletionResult;
+}): StuckDetection;
+
+/**
+ * Event Graph — Constants
+ */
+
+declare const TASK_STATUS: Record<string, TaskStatus>;
+declare const EXECUTION_STATUS: Record<string, ExecutionStatus>;
+declare const COMPLETION_STRATEGIES: Record<string, CompletionStrategy>;
+declare const EXECUTION_MODES: Record<string, ExecutionMode>;
+declare const CONFLICT_STRATEGIES: Record<string, ConflictStrategy>;
+declare const DEFAULTS: {
+    readonly EXECUTION_MODE: ExecutionMode;
+    readonly CONFLICT_STRATEGY: ConflictStrategy;
+    readonly COMPLETION_STRATEGY: CompletionStrategy;
+    readonly MAX_ITERATIONS: 1000;
+};
+
+export { getRepeatableMax as $, type AgentActionEvent as A, getAllTasks as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, getCandidateTasks as F, type GraphConfig as G, getProvides as H, type InjectTokensEvent as I, getRequires as J, getTask as K, hasTask as L, isExecutionComplete as M, isNonActiveTask as N, isRepeatableTask as O, isTaskCompleted as P, isTaskRunning as Q, next as R, type SchedulerResult as S, type TaskConfig as T, type RepeatableConfig as U, type TaskCircuitBreakerConfig as V, type TaskMessage as W, type TaskProgressEvent as X, type TaskRetryConfig as Y, addKeyToProvides as Z, addKeyToRequires as _, CONFLICT_STRATEGIES as a, groupTasksByProvides as a0, hasOutputConflict as a1, removeKeyFromProvides as a2, removeKeyFromRequires as a3, type CompletionResult as b, type CompletionStrategy as c, type ConflictStrategy as d, EXECUTION_STATUS as e, type ExecutionConfig as f, type ExecutionMode as g, type ExecutionState as h, type ExecutionStatus as i, type GraphEvent as j, type GraphSettings as k, type StuckDetection as l, TASK_STATUS as m, type TaskCompletedEvent as n, type TaskCreationEvent as o, type TaskFailedEvent as p, type TaskStartedEvent as q, type TaskState as r, type TaskStatus as s, addDynamicTask as t, apply as u, applyAll as v, computeAvailableOutputs as w, createDefaultTaskState as x, createInitialExecutionState as y, detectStuckState as z };