@tasker-systems/tasker 0.1.0-alpha.1

package/dist/events/index.js

@@ -0,0 +1,1642 @@
+import { EventEmitter } from 'eventemitter3';
+import pino from 'pino';
+
+// src/events/event-emitter.ts
+
+// src/events/event-names.ts
+var StepEventNames = {
+  /** Emitted when a step execution event is received from the FFI layer */
+  STEP_EXECUTION_RECEIVED: "step.execution.received",
+  /** Emitted when a step handler starts executing */
+  STEP_EXECUTION_STARTED: "step.execution.started",
+  /** Emitted when a step handler completes successfully */
+  STEP_EXECUTION_COMPLETED: "step.execution.completed",
+  /** Emitted when a step handler fails */
+  STEP_EXECUTION_FAILED: "step.execution.failed",
+  /** Emitted when a step completion is sent back to Rust */
+  STEP_COMPLETION_SENT: "step.completion.sent",
+  /** Emitted when a step handler times out */
+  STEP_EXECUTION_TIMEOUT: "step.execution.timeout",
+  /** TAS-125: Emitted when a checkpoint yield is sent back to Rust */
+  STEP_CHECKPOINT_YIELD_SENT: "step.checkpoint_yield.sent"
+};
+var WorkerEventNames = {
+  /** Emitted when the worker starts up */
+  WORKER_STARTED: "worker.started",
+  /** Emitted when the worker is ready to process events */
+  WORKER_READY: "worker.ready",
+  /** Emitted when graceful shutdown begins */
+  WORKER_SHUTDOWN_STARTED: "worker.shutdown.started",
+  /** Emitted when the worker has fully stopped */
+  WORKER_STOPPED: "worker.stopped",
+  /** Emitted when the worker encounters an error */
+  WORKER_ERROR: "worker.error"
+};
+var PollerEventNames = {
+  /** Emitted when the poller starts */
+  POLLER_STARTED: "poller.started",
+  /** Emitted when the poller stops */
+  POLLER_STOPPED: "poller.stopped",
+  /** Emitted when a poll cycle completes */
+  POLLER_CYCLE_COMPLETE: "poller.cycle.complete",
+  /** Emitted when starvation is detected */
+  POLLER_STARVATION_DETECTED: "poller.starvation.detected",
+  /** Emitted when the poller encounters an error */
+  POLLER_ERROR: "poller.error"
+};
+var MetricsEventNames = {
+  /** Emitted periodically with FFI dispatch metrics */
+  METRICS_UPDATED: "metrics.updated",
+  /** Emitted when metrics collection fails */
+  METRICS_ERROR: "metrics.error"
+};
+var EventNames = {
+  ...StepEventNames,
+  ...WorkerEventNames,
+  ...PollerEventNames,
+  ...MetricsEventNames
+};
+
+// src/events/event-emitter.ts
+var TaskerEventEmitter = class extends EventEmitter {
+  instanceId;
+  constructor() {
+    super();
+    this.instanceId = crypto.randomUUID();
+  }
+  /**
+   * Get the unique instance ID for this emitter
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
+  /**
+   * Emit a step execution received event
+   */
+  emitStepReceived(event) {
+    this.emit(StepEventNames.STEP_EXECUTION_RECEIVED, {
+      event,
+      receivedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Emit a step execution started event
+   */
+  emitStepStarted(eventId, stepUuid, taskUuid, handlerName) {
+    this.emit(StepEventNames.STEP_EXECUTION_STARTED, {
+      eventId,
+      stepUuid,
+      taskUuid,
+      handlerName,
+      startedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Emit a step execution completed event
+   */
+  emitStepCompleted(eventId, stepUuid, taskUuid, result, executionTimeMs) {
+    this.emit(StepEventNames.STEP_EXECUTION_COMPLETED, {
+      eventId,
+      stepUuid,
+      taskUuid,
+      result,
+      executionTimeMs,
+      completedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Emit a step execution failed event
+   */
+  emitStepFailed(eventId, stepUuid, taskUuid, error) {
+    this.emit(StepEventNames.STEP_EXECUTION_FAILED, {
+      eventId,
+      stepUuid,
+      taskUuid,
+      error,
+      failedAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Emit a step completion sent event
+   */
+  emitCompletionSent(eventId, stepUuid, success) {
+    this.emit(StepEventNames.STEP_COMPLETION_SENT, {
+      eventId,
+      stepUuid,
+      success,
+      sentAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Emit a worker started event
+   */
+  emitWorkerStarted(workerId) {
+    this.emit(WorkerEventNames.WORKER_STARTED, {
+      workerId,
+      timestamp: /* @__PURE__ */ new Date(),
+      message: "Worker started"
+    });
+  }
+  /**
+   * Emit a worker ready event
+   */
+  emitWorkerReady(workerId) {
+    this.emit(WorkerEventNames.WORKER_READY, {
+      workerId,
+      timestamp: /* @__PURE__ */ new Date(),
+      message: "Worker ready to process events"
+    });
+  }
+  /**
+   * Emit a worker shutdown started event
+   */
+  emitWorkerShutdownStarted(workerId) {
+    this.emit(WorkerEventNames.WORKER_SHUTDOWN_STARTED, {
+      workerId,
+      timestamp: /* @__PURE__ */ new Date(),
+      message: "Graceful shutdown initiated"
+    });
+  }
+  /**
+   * Emit a worker stopped event
+   */
+  emitWorkerStopped(workerId) {
+    this.emit(WorkerEventNames.WORKER_STOPPED, {
+      workerId,
+      timestamp: /* @__PURE__ */ new Date(),
+      message: "Worker stopped"
+    });
+  }
+  /**
+   * Emit a worker error event
+   */
+  emitWorkerError(error, context) {
+    this.emit(WorkerEventNames.WORKER_ERROR, {
+      error,
+      timestamp: /* @__PURE__ */ new Date(),
+      context
+    });
+  }
+  /**
+   * Emit a metrics updated event
+   */
+  emitMetricsUpdated(metrics) {
+    this.emit(MetricsEventNames.METRICS_UPDATED, {
+      metrics,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Emit a starvation detected event
+   */
+  emitStarvationDetected(metrics) {
+    this.emit(PollerEventNames.POLLER_STARVATION_DETECTED, {
+      metrics,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+};
+var loggerOptions = {
+  name: "event-poller",
+  level: process.env.RUST_LOG ?? "info"
+};
+if (process.env.TASKER_ENV !== "production") {
+  loggerOptions.transport = {
+    target: "pino-pretty",
+    options: { colorize: true }
+  };
+}
+var log = pino(loggerOptions);
+var EventPoller = class {
+  runtime;
+  config;
+  emitter;
+  state = "stopped";
+  pollCount = 0;
+  cycleCount = 0;
+  intervalId = null;
+  stepEventCallback = null;
+  errorCallback = null;
+  metricsCallback = null;
+  /**
+   * Create a new EventPoller.
+   *
+   * @param runtime - The FFI runtime for polling events
+   * @param emitter - The event emitter to dispatch events to (required, no fallback)
+   * @param config - Optional configuration for polling behavior
+   */
+  constructor(runtime, emitter, config = {}) {
+    this.runtime = runtime;
+    this.emitter = emitter;
+    this.config = {
+      pollIntervalMs: config.pollIntervalMs ?? 10,
+      starvationCheckInterval: config.starvationCheckInterval ?? 100,
+      cleanupInterval: config.cleanupInterval ?? 1e3,
+      metricsInterval: config.metricsInterval ?? 100,
+      maxEventsPerCycle: config.maxEventsPerCycle ?? 100
+    };
+  }
+  /**
+   * Get the current poller state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if the poller is running
+   */
+  isRunning() {
+    return this.state === "running";
+  }
+  /**
+   * Get the total number of polls executed
+   */
+  getPollCount() {
+    return this.pollCount;
+  }
+  /**
+   * Get the total number of cycles completed
+   */
+  getCycleCount() {
+    return this.cycleCount;
+  }
+  /**
+   * Register a callback for step events
+   */
+  onStepEvent(callback) {
+    this.stepEventCallback = callback;
+    return this;
+  }
+  /**
+   * Register a callback for errors
+   */
+  onError(callback) {
+    this.errorCallback = callback;
+    return this;
+  }
+  /**
+   * Register a callback for metrics
+   */
+  onMetrics(callback) {
+    this.metricsCallback = callback;
+    return this;
+  }
+  /**
+   * Start the polling loop
+   */
+  start() {
+    log.info(
+      { component: "event-poller", operation: "start", currentState: this.state },
+      "EventPoller start() called"
+    );
+    if (this.state === "running") {
+      log.debug({ component: "event-poller" }, "Already running, returning early");
+      return;
+    }
+    log.debug(
+      { component: "event-poller", runtimeLoaded: this.runtime.isLoaded },
+      "Checking runtime.isLoaded"
+    );
+    if (!this.runtime.isLoaded) {
+      throw new Error("Runtime not loaded. Call runtime.load() first.");
+    }
+    this.state = "running";
+    this.pollCount = 0;
+    this.cycleCount = 0;
+    this.emitter.emit(PollerEventNames.POLLER_STARTED, {
+      timestamp: /* @__PURE__ */ new Date(),
+      message: "Event poller started"
+    });
+    log.info(
+      { component: "event-poller", intervalMs: this.config.pollIntervalMs },
+      "Setting up setInterval for polling"
+    );
+    this.intervalId = setInterval(() => {
+      this.poll();
+    }, this.config.pollIntervalMs);
+    log.info(
+      { component: "event-poller", intervalId: String(this.intervalId) },
+      "setInterval created, polling active"
+    );
+  }
+  /**
+   * Stop the polling loop
+   */
+  async stop() {
+    if (this.state === "stopped") {
+      return;
+    }
+    this.state = "stopping";
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.state = "stopped";
+    this.emitter.emit(PollerEventNames.POLLER_STOPPED, {
+      timestamp: /* @__PURE__ */ new Date(),
+      message: `Event poller stopped after ${this.pollCount} polls`
+    });
+  }
+  /**
+   * Execute a single poll cycle
+   */
+  poll() {
+    if (this.pollCount === 0) {
+      log.info(
+        { component: "event-poller", state: this.state },
+        "First poll() call - setInterval is working"
+      );
+    }
+    if (this.pollCount % 100 === 0) {
+      log.debug(
+        { component: "event-poller", pollCount: this.pollCount, state: this.state },
+        "poll() cycle"
+      );
+    }
+    if (this.state !== "running") {
+      return;
+    }
+    this.pollCount++;
+    try {
+      let eventsProcessed = 0;
+      for (let i = 0; i < this.config.maxEventsPerCycle; i++) {
+        const event = this.runtime.pollStepEvents();
+        if (event === null) {
+          break;
+        }
+        eventsProcessed++;
+        const handlerCallable = event.step_definition.handler.callable;
+        log.info(
+          {
+            component: "event-poller",
+            operation: "event_received",
+            stepUuid: event.step_uuid,
+            handlerCallable,
+            eventIndex: i
+          },
+          `Received step event for handler: ${handlerCallable}`
+        );
+        this.handleStepEvent(event);
+      }
+      if (this.pollCount % this.config.starvationCheckInterval === 0) {
+        this.checkStarvation();
+      }
+      if (this.pollCount % this.config.cleanupInterval === 0) {
+        this.runtime.cleanupTimeouts();
+      }
+      if (this.pollCount % this.config.metricsInterval === 0) {
+        this.emitMetrics();
+      }
+      this.cycleCount++;
+      if (eventsProcessed > 0) {
+        this.emitter.emit(PollerEventNames.POLLER_CYCLE_COMPLETE, {
+          eventsProcessed,
+          cycleNumber: this.cycleCount,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+    } catch (error) {
+      this.handleError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Handle a step event
+   */
+  handleStepEvent(event) {
+    const handlerCallable = event.step_definition.handler.callable;
+    log.debug(
+      {
+        component: "event-poller",
+        operation: "handle_step_event",
+        stepUuid: event.step_uuid,
+        handlerCallable,
+        hasCallback: !!this.stepEventCallback
+      },
+      "Handling step event"
+    );
+    const listenerCountBefore = this.emitter.listenerCount(StepEventNames.STEP_EXECUTION_RECEIVED);
+    log.info(
+      {
+        component: "event-poller",
+        emitterInstanceId: this.emitter.getInstanceId(),
+        stepUuid: event.step_uuid,
+        listenerCount: listenerCountBefore,
+        eventName: StepEventNames.STEP_EXECUTION_RECEIVED
+      },
+      `About to emit ${StepEventNames.STEP_EXECUTION_RECEIVED} event`
+    );
+    try {
+      const emitResult = this.emitter.emit(StepEventNames.STEP_EXECUTION_RECEIVED, {
+        event,
+        receivedAt: /* @__PURE__ */ new Date()
+      });
+      log.info(
+        {
+          component: "event-poller",
+          stepUuid: event.step_uuid,
+          emitResult,
+          listenerCountAfter: this.emitter.listenerCount(StepEventNames.STEP_EXECUTION_RECEIVED),
+          eventName: StepEventNames.STEP_EXECUTION_RECEIVED
+        },
+        `Emit returned: ${emitResult} (true means listeners were called)`
+      );
+    } catch (emitError) {
+      log.error(
+        {
+          component: "event-poller",
+          stepUuid: event.step_uuid,
+          error: emitError instanceof Error ? emitError.message : String(emitError),
+          stack: emitError instanceof Error ? emitError.stack : void 0
+        },
+        "Error during emit"
+      );
+    }
+    if (this.stepEventCallback) {
+      log.debug(
+        { component: "event-poller", stepUuid: event.step_uuid },
+        "Invoking step event callback"
+      );
+      this.stepEventCallback(event).catch((error) => {
+        this.handleError(error instanceof Error ? error : new Error(String(error)));
+      });
+    } else {
+      log.warn(
+        { component: "event-poller", stepUuid: event.step_uuid },
+        "No step event callback registered!"
+      );
+    }
+  }
+  /**
+   * Check for starvation conditions
+   */
+  checkStarvation() {
+    try {
+      this.runtime.checkStarvationWarnings();
+      const metrics = this.runtime.getFfiDispatchMetrics();
+      if (metrics.starvation_detected) {
+        this.emitter.emitStarvationDetected(metrics);
+      }
+    } catch (error) {
+      this.handleError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Emit current metrics
+   */
+  emitMetrics() {
+    try {
+      const metrics = this.runtime.getFfiDispatchMetrics();
+      this.emitter.emitMetricsUpdated(metrics);
+      if (this.metricsCallback) {
+        this.metricsCallback(metrics);
+      }
+    } catch (error) {
+      this.emitter.emit(MetricsEventNames.METRICS_ERROR, {
+        error: error instanceof Error ? error : new Error(String(error)),
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  /**
+   * Handle an error
+   */
+  handleError(error) {
+    this.emitter.emit(PollerEventNames.POLLER_ERROR, {
+      error,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (this.errorCallback) {
+      this.errorCallback(error);
+    }
+  }
+};
+function createEventPoller(runtime, emitter, config) {
+  return new EventPoller(runtime, emitter, config);
+}
+function getLoggingRuntime() {
+  return null;
+}
+function toFfiFields(fields) {
+  if (!fields) {
+    return {};
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function fallbackLog(level, message, fields) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const fieldsStr = fields ? ` ${JSON.stringify(fields)}` : "";
+  console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}${fieldsStr}`);
+}
+function logError(message, fields) {
+  const runtime = getLoggingRuntime();
+  if (!runtime) {
+    fallbackLog("error", message, fields);
+    return;
+  }
+  try {
+    runtime.logError(message, toFfiFields(fields));
+  } catch {
+    fallbackLog("error", message, fields);
+  }
+}
+function logWarn(message, fields) {
+  const runtime = getLoggingRuntime();
+  if (!runtime) {
+    fallbackLog("warn", message, fields);
+    return;
+  }
+  try {
+    runtime.logWarn(message, toFfiFields(fields));
+  } catch {
+    fallbackLog("warn", message, fields);
+  }
+}
+function logInfo(message, fields) {
+  const runtime = getLoggingRuntime();
+  if (!runtime) {
+    fallbackLog("info", message, fields);
+    return;
+  }
+  try {
+    runtime.logInfo(message, toFfiFields(fields));
+  } catch {
+    fallbackLog("info", message, fields);
+  }
+}
+function logDebug(message, fields) {
+  const runtime = getLoggingRuntime();
+  if (!runtime) {
+    fallbackLog("debug", message, fields);
+    return;
+  }
+  try {
+    runtime.logDebug(message, toFfiFields(fields));
+  } catch {
+    fallbackLog("debug", message, fields);
+  }
+}
+
+// src/types/step-context.ts
+var StepContext = class _StepContext {
+  /** The original FFI step event */
+  event;
+  /** Task UUID */
+  taskUuid;
+  /** Step UUID */
+  stepUuid;
+  /** Correlation ID for tracing */
+  correlationId;
+  /** Name of the handler being executed */
+  handlerName;
+  /** Input data for the handler (from task context) */
+  inputData;
+  /** Results from dependent steps */
+  dependencyResults;
+  /** Handler-specific configuration (from step_definition.handler.initialization) */
+  stepConfig;
+  /** Step-specific inputs (from workflow_step.inputs, used for batch cursor config) */
+  stepInputs;
+  /** Current retry attempt number */
+  retryCount;
+  /** Maximum retry attempts allowed */
+  maxRetries;
+  constructor(params) {
+    this.event = params.event;
+    this.taskUuid = params.taskUuid;
+    this.stepUuid = params.stepUuid;
+    this.correlationId = params.correlationId;
+    this.handlerName = params.handlerName;
+    this.inputData = params.inputData;
+    this.dependencyResults = params.dependencyResults;
+    this.stepConfig = params.stepConfig;
+    this.stepInputs = params.stepInputs;
+    this.retryCount = params.retryCount;
+    this.maxRetries = params.maxRetries;
+  }
+  /**
+   * Create a StepContext from an FFI event.
+   *
+   * Extracts input data, dependency results, and configuration from
+   * the task_sequence_step payload.
+   *
+   * The FFI data structure mirrors the Ruby TaskSequenceStepWrapper:
+   * - task.context -> inputData (task context with user inputs)
+   * - dependency_results -> results from parent steps
+   * - step_definition.handler.initialization -> stepConfig
+   * - workflow_step.attempts -> retryCount
+   * - workflow_step.max_attempts -> maxRetries
+   * - workflow_step.inputs -> stepInputs
+   *
+   * @param event - The FFI step event
+   * @param handlerName - Name of the handler to execute
+   * @returns A StepContext populated from the event
+   */
+  static fromFfiEvent(event, handlerName) {
+    const task = event.task ?? {};
+    const inputData = task.context ?? {};
+    const dependencyResults = event.dependency_results ?? {};
+    const stepDefinition = event.step_definition ?? {};
+    const handlerConfig = stepDefinition.handler ?? {};
+    const stepConfig = handlerConfig.initialization ?? {};
+    const workflowStep = event.workflow_step ?? {};
+    const retryCount = workflowStep.attempts ?? 0;
+    const maxRetries = workflowStep.max_attempts ?? 3;
+    const stepInputs = workflowStep.inputs ?? {};
+    return new _StepContext({
+      event,
+      taskUuid: event.task_uuid,
+      stepUuid: event.step_uuid,
+      correlationId: event.correlation_id,
+      handlerName,
+      inputData,
+      dependencyResults,
+      stepConfig,
+      stepInputs,
+      retryCount,
+      maxRetries
+    });
+  }
+  /**
+   * Get the computed result value from a dependency step.
+   *
+   * This method extracts the actual computed value from a dependency result,
+   * unwrapping any nested structure. Matches Python's get_dependency_result().
+   *
+   * The dependency result structure can be:
+   * - {"result": actual_value} - unwraps to actual_value
+   * - primitive value - returns as-is
+   *
+   * @param stepName - Name of the dependency step
+   * @returns The computed result value, or null if not found
+   *
+   * @example
+   * ```typescript
+   * // Instead of:
+   * const step1Result = context.dependencyResults['step_1'] || {};
+   * const value = step1Result.result;  // Might be nested!
+   *
+   * // Use:
+   * const value = context.getDependencyResult('step_1');  // Unwrapped
+   * ```
+   */
+  getDependencyResult(stepName) {
+    const resultHash = this.dependencyResults[stepName];
+    if (resultHash === void 0 || resultHash === null) {
+      return null;
+    }
+    if (typeof resultHash === "object" && resultHash !== null && "result" in resultHash) {
+      return resultHash.result;
+    }
+    return resultHash;
+  }
+  /**
+   * Get a value from the input data.
+   *
+   * @param key - The key to look up in inputData
+   * @returns The value or undefined if not found
+   */
+  getInput(key) {
+    return this.inputData[key];
+  }
+  /**
+   * Get a value from the step configuration.
+   *
+   * @param key - The key to look up in stepConfig
+   * @returns The value or undefined if not found
+   */
+  getConfig(key) {
+    return this.stepConfig[key];
+  }
+  /**
+   * Check if this is a retry attempt.
+   *
+   * @returns True if retryCount > 0
+   */
+  isRetry() {
+    return this.retryCount > 0;
+  }
+  /**
+   * Check if this is the last allowed retry attempt.
+   *
+   * @returns True if retryCount >= maxRetries - 1
+   */
+  isLastRetry() {
+    return this.retryCount >= this.maxRetries - 1;
+  }
+  /**
+   * Get a value from the input data with a default.
+   *
+   * @param key - The key to look up in inputData
+   * @param defaultValue - Value to return if key not found or undefined
+   * @returns The value or default if not found/undefined
+   *
+   * @example
+   * ```typescript
+   * const batchSize = context.getInputOr('batch_size', 100);
+   * ```
+   */
+  getInputOr(key, defaultValue) {
+    const value = this.inputData[key];
+    return value === void 0 ? defaultValue : value;
+  }
+  /**
+   * Extract a nested field from a dependency result.
+   *
+   * Useful when dependency results are complex objects and you need
+   * to extract a specific nested value without manual object traversal.
+   *
+   * @param stepName - Name of the dependency step
+   * @param path - Path elements to traverse into the result
+   * @returns The nested value, or null if not found
+   *
+   * @example
+   * ```typescript
+   * // Extract nested field from dependency result
+   * const csvPath = context.getDependencyField('analyze_csv', 'csv_file_path');
+   * // Multiple levels deep
+   * const value = context.getDependencyField('step_1', 'data', 'items');
+   * ```
+   */
+  getDependencyField(stepName, ...path) {
+    let result = this.getDependencyResult(stepName);
+    if (result === null || result === void 0) {
+      return null;
+    }
+    for (const key of path) {
+      if (typeof result !== "object" || result === null) {
+        return null;
+      }
+      result = result[key];
+    }
+    return result;
+  }
+  // ===========================================================================
+  // CHECKPOINT ACCESSORS (TAS-125 Batch Processing Support)
+  // ===========================================================================
+  /**
+   * Get the raw checkpoint data from the workflow step.
+   *
+   * @returns The checkpoint data object or null if not set
+   */
+  get checkpoint() {
+    const workflowStep = this.event.workflow_step ?? {};
+    return workflowStep.checkpoint ?? null;
+  }
+  /**
+   * Get the checkpoint cursor position.
+   *
+   * The cursor represents the current position in batch processing,
+   * allowing handlers to resume from where they left off.
+   *
+   * @returns The cursor value (number, string, or object) or null if not set
+   *
+   * @example
+   * ```typescript
+   * const cursor = context.checkpointCursor;
+   * const startFrom = cursor ?? 0;
+   * ```
+   */
+  get checkpointCursor() {
+    return this.checkpoint?.cursor ?? null;
+  }
+  /**
+   * Get the number of items processed in the current batch run.
+   *
+   * @returns Number of items processed (0 if no checkpoint)
+   */
+  get checkpointItemsProcessed() {
+    return this.checkpoint?.items_processed ?? 0;
+  }
+  /**
+   * Get the accumulated results from batch processing.
+   *
+   * Accumulated results allow handlers to maintain running totals
+   * or aggregated state across checkpoint boundaries.
+   *
+   * @returns The accumulated results object or null if not set
+   *
+   * @example
+   * ```typescript
+   * const totals = context.accumulatedResults ?? {};
+   * const currentSum = totals.sum ?? 0;
+   * ```
+   */
+  get accumulatedResults() {
+    return this.checkpoint?.accumulated_results ?? null;
+  }
+  /**
+   * Check if a checkpoint exists for this step.
+   *
+   * @returns True if a checkpoint cursor exists
+   *
+   * @example
+   * ```typescript
+   * if (context.hasCheckpoint()) {
+   *   console.log(`Resuming from cursor: ${context.checkpointCursor}`);
+   * }
+   * ```
+   */
+  hasCheckpoint() {
+    return this.checkpointCursor !== null;
+  }
+  /**
+   * Get all dependency result keys.
+   *
+   * @returns Array of step names that have dependency results
+   */
+  getDependencyResultKeys() {
+    return Object.keys(this.dependencyResults);
+  }
+  /**
+   * Get all dependency results matching a step name prefix.
+   *
+   * This is useful for batch processing where multiple worker steps
+   * share a common prefix (e.g., "process_batch_001", "process_batch_002").
+   *
+   * Returns the unwrapped result values (same as getDependencyResult).
+   *
+   * @param prefix - Step name prefix to match
+   * @returns Array of unwrapped result values from matching steps
+   *
+   * @example
+   * ```typescript
+   * // For batch worker results named: process_batch_001, process_batch_002, etc.
+   * const batchResults = context.getAllDependencyResults('process_batch_');
+   * const total = batchResults.reduce((sum, r) => sum + r.count, 0);
+   * ```
+   */
+  getAllDependencyResults(prefix) {
+    const results = [];
+    for (const key of Object.keys(this.dependencyResults)) {
+      if (key.startsWith(prefix)) {
+        const result = this.getDependencyResult(key);
+        if (result !== null) {
+          results.push(result);
+        }
+      }
+    }
+    return results;
+  }
+};
+
+// src/subscriber/step-execution-subscriber.ts
+var loggerOptions2 = {
+  name: "step-subscriber",
+  level: process.env.RUST_LOG ?? "info"
+};
+if (process.env.TASKER_ENV !== "production") {
+  loggerOptions2.transport = {
+    target: "pino-pretty",
+    options: { colorize: true }
+  };
+}
+var pinoLog = pino(loggerOptions2);
+var StepExecutionSubscriber = class {
+  emitter;
+  registry;
+  runtime;
+  workerId;
+  maxConcurrent;
+  handlerTimeoutMs;
+  running = false;
+  activeHandlers = 0;
+  processedCount = 0;
+  errorCount = 0;
+  /**
+   * Create a new StepExecutionSubscriber.
+   *
+   * @param emitter - The event emitter to subscribe to (required, no fallback)
+   * @param registry - The handler registry for resolving step handlers
+   * @param runtime - The FFI runtime for submitting results (required, no fallback)
+   * @param config - Optional configuration for execution behavior
+   */
+  constructor(emitter, registry, runtime, config = {}) {
+    this.emitter = emitter;
+    this.registry = registry;
+    this.runtime = runtime;
+    this.workerId = config.workerId ?? `typescript-worker-${process.pid}`;
+    this.maxConcurrent = config.maxConcurrent ?? 10;
+    this.handlerTimeoutMs = config.handlerTimeoutMs ?? 3e5;
+  }
+  /**
+   * Start subscribing to step execution events.
+   */
+  start() {
+    pinoLog.info(
+      { component: "subscriber", emitterInstanceId: this.emitter.getInstanceId() },
+      "StepExecutionSubscriber.start() called"
+    );
+    if (this.running) {
+      logWarn("StepExecutionSubscriber already running", {
+        component: "subscriber"
+      });
+      return;
+    }
+    this.running = true;
+    this.processedCount = 0;
+    this.errorCount = 0;
+    pinoLog.info(
+      {
+        component: "subscriber",
+        eventName: StepEventNames.STEP_EXECUTION_RECEIVED,
+        emitterInstanceId: this.emitter.getInstanceId()
+      },
+      "Registering event listener on emitter"
+    );
+    this.emitter.on(
+      StepEventNames.STEP_EXECUTION_RECEIVED,
+      (payload) => {
+        try {
+          pinoLog.info(
+            {
+              component: "subscriber",
+              eventId: payload.event.event_id,
+              stepUuid: payload.event.step_uuid
+            },
+            "Received step event in subscriber callback!"
+          );
+          pinoLog.info({ component: "subscriber" }, "About to call handleEvent from callback");
+          this.handleEvent(payload.event);
+          pinoLog.info({ component: "subscriber" }, "handleEvent returned from callback");
+        } catch (error) {
+          pinoLog.error(
+            {
+              component: "subscriber",
+              error: error instanceof Error ? error.message : String(error),
+              stack: error instanceof Error ? error.stack : void 0
+            },
+            "EXCEPTION in event listener callback!"
+          );
+        }
+      }
+    );
+    pinoLog.info(
+      { component: "subscriber", workerId: this.workerId },
+      "StepExecutionSubscriber started successfully"
+    );
+    logInfo("StepExecutionSubscriber started", {
+      component: "subscriber",
+      operation: "start",
+      worker_id: this.workerId
+    });
+  }
+  /**
+   * Stop subscribing to step execution events.
+   *
+   * Note: Does not wait for in-flight handlers to complete.
+   * Use waitForCompletion() if you need to wait.
+   */
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    this.emitter.removeAllListeners(StepEventNames.STEP_EXECUTION_RECEIVED);
+    logInfo("StepExecutionSubscriber stopped", {
+      component: "subscriber",
+      operation: "stop",
+      processed_count: String(this.processedCount),
+      error_count: String(this.errorCount)
+    });
+  }
+  /**
+   * Check if the subscriber is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get the count of events processed.
+   */
+  getProcessedCount() {
+    return this.processedCount;
+  }
+  /**
+   * Get the count of errors encountered.
+   */
+  getErrorCount() {
+    return this.errorCount;
+  }
+  /**
+   * Get the count of currently active handlers.
+   */
+  getActiveHandlers() {
+    return this.activeHandlers;
+  }
+  /**
+   * Wait for all active handlers to complete.
+   *
+   * @param timeoutMs - Maximum time to wait (default: 30000)
+   * @returns True if all handlers completed, false if timeout
+   */
+  async waitForCompletion(timeoutMs = 3e4) {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    while (this.activeHandlers > 0) {
+      if (Date.now() - startTime > timeoutMs) {
+        logWarn("Timeout waiting for handlers to complete", {
+          component: "subscriber",
+          active_handlers: String(this.activeHandlers)
+        });
+        return false;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+    }
+    return true;
+  }
+  /**
+   * Handle a step execution event.
+   */
+  handleEvent(event) {
+    pinoLog.info(
+      {
+        component: "subscriber",
+        eventId: event.event_id,
+        running: this.running,
+        activeHandlers: this.activeHandlers,
+        maxConcurrent: this.maxConcurrent
+      },
+      "handleEvent() called"
+    );
+    if (!this.running) {
+      pinoLog.warn(
+        { component: "subscriber", eventId: event.event_id },
+        "Received event while stopped, ignoring"
+      );
+      return;
+    }
+    if (this.activeHandlers >= this.maxConcurrent) {
+      pinoLog.warn(
+        {
+          component: "subscriber",
+          activeHandlers: this.activeHandlers,
+          maxConcurrent: this.maxConcurrent
+        },
+        "Max concurrent handlers reached, event will be re-polled"
+      );
+      return;
+    }
+    pinoLog.info(
+      { component: "subscriber", eventId: event.event_id },
+      "About to call processEvent()"
+    );
+    this.processEvent(event).catch((error) => {
+      pinoLog.error(
+        {
+          component: "subscriber",
+          eventId: event.event_id,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        },
+        "Unhandled error in processEvent"
+      );
+    });
+  }
+  /**
+   * Process a step execution event.
+   */
+  async processEvent(event) {
+    pinoLog.info({ component: "subscriber", eventId: event.event_id }, "processEvent() starting");
+    this.activeHandlers++;
+    const startTime = Date.now();
+    try {
+      const handlerName = this.extractHandlerName(event);
+      pinoLog.info(
+        { component: "subscriber", eventId: event.event_id, handlerName },
+        "Extracted handler name"
+      );
+      if (!handlerName) {
+        pinoLog.error(
+          { component: "subscriber", eventId: event.event_id },
+          "No handler name found!"
+        );
+        await this.submitErrorResult(event, "No handler name found in step definition", startTime);
+        return;
+      }
+      pinoLog.info(
+        {
+          component: "subscriber",
+          eventId: event.event_id,
+          stepUuid: event.step_uuid,
+          handlerName
+        },
+        "Processing step event"
+      );
+      this.emitter.emit(StepEventNames.STEP_EXECUTION_STARTED, {
+        eventId: event.event_id,
+        stepUuid: event.step_uuid,
+        handlerName,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      pinoLog.info({ component: "subscriber", handlerName }, "Resolving handler from registry...");
+      const handler = await this.registry.resolve(handlerName);
+      pinoLog.info(
+        { component: "subscriber", handlerName, handlerFound: !!handler },
+        "Handler resolution result"
+      );
+      if (!handler) {
+        pinoLog.error({ component: "subscriber", handlerName }, "Handler not found in registry!");
+        await this.submitErrorResult(event, `Handler not found: ${handlerName}`, startTime);
+        return;
+      }
+      pinoLog.info({ component: "subscriber", handlerName }, "Creating StepContext from FFI event");
+      const context = StepContext.fromFfiEvent(event, handlerName);
+      pinoLog.info(
+        { component: "subscriber", handlerName },
+        "StepContext created, executing handler"
+      );
+      const result = await this.executeWithTimeout(
+        () => handler.call(context),
+        this.handlerTimeoutMs
+      );
+      pinoLog.info(
+        { component: "subscriber", handlerName, success: result.success },
+        "Handler execution completed"
+      );
+      const executionTimeMs = Date.now() - startTime;
+      await this.submitResult(event, result, executionTimeMs);
+      if (result.success) {
+        this.emitter.emit(StepEventNames.STEP_EXECUTION_COMPLETED, {
+          eventId: event.event_id,
+          stepUuid: event.step_uuid,
+          handlerName,
+          executionTimeMs,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      } else {
+        this.emitter.emit(StepEventNames.STEP_EXECUTION_FAILED, {
+          eventId: event.event_id,
+          stepUuid: event.step_uuid,
+          handlerName,
+          error: result.errorMessage,
+          executionTimeMs,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      this.processedCount++;
+    } catch (error) {
+      this.errorCount++;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logError("Handler execution failed", {
+        component: "subscriber",
+        event_id: event.event_id,
+        step_uuid: event.step_uuid,
+        error_message: errorMessage
+      });
+      await this.submitErrorResult(event, errorMessage, startTime);
+      this.emitter.emit(StepEventNames.STEP_EXECUTION_FAILED, {
+        eventId: event.event_id,
+        stepUuid: event.step_uuid,
+        error: errorMessage,
+        executionTimeMs: Date.now() - startTime,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    } finally {
+      this.activeHandlers--;
+    }
+  }
+  /**
+   * Execute a function with a timeout.
+   */
+  async executeWithTimeout(fn, timeoutMs) {
+    return Promise.race([
+      fn(),
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error(`Handler execution timed out after ${timeoutMs}ms`)),
+          timeoutMs
+        )
+      )
+    ]);
+  }
+  /**
+   * Extract handler name from FFI event.
+   *
+   * The handler name is in step_definition.handler.callable
+   */
+  extractHandlerName(event) {
+    const stepDefinition = event.step_definition;
+    if (!stepDefinition) {
+      return null;
+    }
+    const handler = stepDefinition.handler;
+    if (!handler) {
+      return null;
+    }
+    return handler.callable || null;
+  }
+  /**
+   * Submit a handler result via FFI.
+   *
+   * TAS-125: Detects checkpoint yields and routes them to checkpointYieldStepEvent
+   * instead of the normal completion path.
+   */
+  async submitResult(event, result, executionTimeMs) {
+    pinoLog.info(
+      { component: "subscriber", eventId: event.event_id, runtimeLoaded: this.runtime.isLoaded },
+      "submitResult() called"
+    );
+    if (!this.runtime.isLoaded) {
+      pinoLog.error(
+        { component: "subscriber", eventId: event.event_id },
+        "Cannot submit result: runtime not loaded!"
+      );
+      return;
+    }
+    if (result.metadata?.checkpoint_yield === true) {
+      await this.submitCheckpointYield(event, result);
+      return;
+    }
+    const executionResult = this.buildExecutionResult(event, result, executionTimeMs);
+    await this.sendCompletionViaFfi(event, executionResult, result.success);
+  }
+  /**
+   * TAS-125: Submit a checkpoint yield via FFI.
+   *
+   * Called when a handler returns a checkpoint_yield result.
+   * This persists the checkpoint and re-dispatches the step.
+   */
+  async submitCheckpointYield(event, result) {
+    pinoLog.info(
+      { component: "subscriber", eventId: event.event_id },
+      "submitCheckpointYield() called - handler yielded checkpoint"
+    );
+    const resultData = result.result ?? {};
+    const checkpointData = {
+      step_uuid: event.step_uuid,
+      cursor: resultData.cursor ?? 0,
+      items_processed: resultData.items_processed ?? 0
+    };
+    const accumulatedResults = resultData.accumulated_results;
+    if (accumulatedResults !== void 0) {
+      checkpointData.accumulated_results = accumulatedResults;
+    }
+    try {
+      const success = this.runtime.checkpointYieldStepEvent(event.event_id, checkpointData);
+      if (success) {
+        pinoLog.info(
+          {
+            component: "subscriber",
+            eventId: event.event_id,
+            cursor: checkpointData.cursor,
+            itemsProcessed: checkpointData.items_processed
+          },
+          "Checkpoint yield submitted successfully - step will be re-dispatched"
+        );
+        this.emitter.emit(StepEventNames.STEP_CHECKPOINT_YIELD_SENT, {
+          eventId: event.event_id,
+          stepUuid: event.step_uuid,
+          cursor: checkpointData.cursor,
+          itemsProcessed: checkpointData.items_processed,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        logInfo("Checkpoint yield submitted", {
+          component: "subscriber",
+          event_id: event.event_id,
+          step_uuid: event.step_uuid,
+          cursor: String(checkpointData.cursor),
+          items_processed: String(checkpointData.items_processed)
+        });
+      } else {
+        pinoLog.error(
+          { component: "subscriber", eventId: event.event_id },
+          "Checkpoint yield rejected by Rust - event may not be in pending map"
+        );
+        logError("Checkpoint yield rejected", {
+          component: "subscriber",
+          event_id: event.event_id,
+          step_uuid: event.step_uuid
+        });
+      }
+    } catch (error) {
+      pinoLog.error(
+        {
+          component: "subscriber",
+          eventId: event.event_id,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Checkpoint yield failed with error"
+      );
+      logError("Failed to submit checkpoint yield", {
+        component: "subscriber",
+        event_id: event.event_id,
+        error_message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Submit an error result via FFI (for handler resolution/execution failures).
+   */
+  async submitErrorResult(event, errorMessage, startTime) {
+    if (!this.runtime.isLoaded) {
+      logError("Cannot submit error result: runtime not available", {
+        component: "subscriber",
+        event_id: event.event_id
+      });
+      return;
+    }
+    const executionTimeMs = Date.now() - startTime;
+    const executionResult = this.buildErrorExecutionResult(event, errorMessage, executionTimeMs);
+    const accepted = await this.sendCompletionViaFfi(event, executionResult, false);
+    if (accepted) {
+      this.errorCount++;
+    }
+  }
+  /**
+   * Build a StepExecutionResult from a handler result.
+   *
+   * IMPORTANT: metadata.retryable must be set for Rust's is_retryable() to work correctly.
+   */
+  buildExecutionResult(event, result, executionTimeMs) {
+    const executionResult = {
+      step_uuid: event.step_uuid,
+      success: result.success,
+      result: result.result ?? {},
+      metadata: {
+        execution_time_ms: executionTimeMs,
+        worker_id: this.workerId,
+        handler_name: this.extractHandlerName(event) ?? "unknown",
+        attempt_number: event.workflow_step?.attempts ?? 1,
+        retryable: result.retryable ?? false,
+        ...result.metadata
+      },
+      status: result.success ? "completed" : "failed"
+    };
+    if (!result.success) {
+      executionResult.error = {
+        message: result.errorMessage ?? "Unknown error",
+        error_type: result.errorType ?? "handler_error",
+        retryable: result.retryable,
+        status_code: null,
+        backtrace: null
+      };
+    }
+    return executionResult;
+  }
+  /**
+   * Build an error StepExecutionResult for handler resolution/execution failures.
+   *
+   * IMPORTANT: metadata.retryable must be set for Rust's is_retryable() to work correctly.
+   */
+  buildErrorExecutionResult(event, errorMessage, executionTimeMs) {
+    return {
+      step_uuid: event.step_uuid,
+      success: false,
+      result: {},
+      metadata: {
+        execution_time_ms: executionTimeMs,
+        worker_id: this.workerId,
+        retryable: true
+      },
+      status: "error",
+      error: {
+        message: errorMessage,
+        error_type: "handler_error",
+        retryable: true,
+        status_code: null,
+        backtrace: null
+      }
+    };
+  }
+  /**
+   * Send a completion result to Rust via FFI and handle the response.
+   *
+   * @returns true if the completion was accepted by Rust, false otherwise
+   */
+  async sendCompletionViaFfi(event, executionResult, isSuccess) {
+    pinoLog.info(
+      {
+        component: "subscriber",
+        eventId: event.event_id,
+        stepUuid: event.step_uuid,
+        resultJson: JSON.stringify(executionResult)
+      },
+      "About to call runtime.completeStepEvent()"
+    );
+    try {
+      const ffiResult = this.runtime.completeStepEvent(event.event_id, executionResult);
+      if (ffiResult) {
+        this.handleFfiSuccess(event, executionResult, isSuccess);
+        return true;
+      }
+      this.handleFfiRejection(event);
+      return false;
+    } catch (error) {
+      this.handleFfiError(event, error);
+      return false;
+    }
+  }
+  /**
+   * Handle successful FFI completion submission.
+   */
+  handleFfiSuccess(event, executionResult, isSuccess) {
+    pinoLog.info(
+      { component: "subscriber", eventId: event.event_id, success: isSuccess },
+      "completeStepEvent() returned TRUE - completion accepted by Rust"
+    );
+    this.emitter.emit(StepEventNames.STEP_COMPLETION_SENT, {
+      eventId: event.event_id,
+      stepUuid: event.step_uuid,
+      success: isSuccess,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    logDebug("Step result submitted", {
+      component: "subscriber",
+      event_id: event.event_id,
+      step_uuid: event.step_uuid,
+      success: String(isSuccess),
+      execution_time_ms: String(executionResult.metadata.execution_time_ms)
+    });
+  }
+  /**
+   * Handle FFI completion rejection (event not in pending map).
+   */
+  handleFfiRejection(event) {
+    pinoLog.error(
+      {
+        component: "subscriber",
+        eventId: event.event_id,
+        stepUuid: event.step_uuid
+      },
+      "completeStepEvent() returned FALSE - completion REJECTED by Rust! Event may not be in pending map."
+    );
+    logError("FFI completion rejected", {
+      component: "subscriber",
+      event_id: event.event_id,
+      step_uuid: event.step_uuid
+    });
+  }
+  /**
+   * Handle FFI completion error.
+   */
+  handleFfiError(event, error) {
+    pinoLog.error(
+      {
+        component: "subscriber",
+        eventId: event.event_id,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      },
+      "completeStepEvent() THREW AN ERROR!"
+    );
+    logError("Failed to submit step result", {
+      component: "subscriber",
+      event_id: event.event_id,
+      error_message: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+
+// src/events/event-system.ts
+var loggerOptions3 = {
+  name: "event-system",
+  level: process.env.RUST_LOG ?? "info"
+};
+if (process.env.TASKER_ENV !== "production") {
+  loggerOptions3.transport = {
+    target: "pino-pretty",
+    options: { colorize: true }
+  };
+}
+var log2 = pino(loggerOptions3);
+var EventSystem = class {
+  emitter;
+  poller;
+  subscriber;
+  running = false;
+  /**
+   * Create a new EventSystem.
+   *
+   * @param runtime - The FFI runtime for polling events and submitting results
+   * @param registry - The handler registry for resolving step handlers
+   * @param config - Optional configuration for poller and subscriber
+   */
+  constructor(runtime, registry, config = {}) {
+    this.emitter = new TaskerEventEmitter();
+    this.poller = new EventPoller(runtime, this.emitter, config.poller);
+    this.subscriber = new StepExecutionSubscriber(
+      this.emitter,
+      registry,
+      runtime,
+      config.subscriber
+    );
+  }
+  /**
+   * Start the event system.
+   *
+   * Starts the subscriber first (to register listeners), then the poller.
+   * This ensures no events are missed.
+   */
+  start() {
+    log2.info(
+      { component: "event-system", emitterInstanceId: this.emitter.getInstanceId() },
+      "EventSystem.start() called"
+    );
+    if (this.running) {
+      log2.warn({ component: "event-system" }, "EventSystem already running");
+      return;
+    }
+    log2.info(
+      { component: "event-system", eventName: StepEventNames.STEP_EXECUTION_RECEIVED },
+      `Adding debug listener BEFORE subscriber for ${StepEventNames.STEP_EXECUTION_RECEIVED}...`
+    );
+    this.emitter.on(
+      StepEventNames.STEP_EXECUTION_RECEIVED,
+      (payload) => {
+        log2.info(
+          {
+            component: "event-system",
+            debugListener: true,
+            eventId: payload.event?.event_id,
+            stepUuid: payload.event?.step_uuid,
+            eventName: StepEventNames.STEP_EXECUTION_RECEIVED
+          },
+          `\u{1F50D} DEBUG LISTENER: Received ${StepEventNames.STEP_EXECUTION_RECEIVED} event!`
+        );
+      }
+    );
+    log2.info(
+      {
+        component: "event-system",
+        listenerCountAfterDebug: this.emitter.listenerCount(StepEventNames.STEP_EXECUTION_RECEIVED),
+        eventName: StepEventNames.STEP_EXECUTION_RECEIVED
+      },
+      "Debug listener added"
+    );
+    log2.info({ component: "event-system" }, "Starting subscriber first...");
+    this.subscriber.start();
+    log2.info(
+      {
+        component: "event-system",
+        listenerCountAfterSubscriber: this.emitter.listenerCount(
+          StepEventNames.STEP_EXECUTION_RECEIVED
+        ),
+        eventName: StepEventNames.STEP_EXECUTION_RECEIVED
+      },
+      "Subscriber started, checking listener count"
+    );
+    log2.info({ component: "event-system" }, "Starting poller...");
+    this.poller.start();
+    this.running = true;
+    log2.info(
+      {
+        component: "event-system",
+        emitterInstanceId: this.emitter.getInstanceId(),
+        listenerCount: this.emitter.listenerCount(StepEventNames.STEP_EXECUTION_RECEIVED),
+        eventName: StepEventNames.STEP_EXECUTION_RECEIVED
+      },
+      "EventSystem started successfully"
+    );
+  }
+  /**
+   * Stop the event system gracefully.
+   *
+   * Stops ingress first (poller), waits for in-flight handlers,
+   * then stops the subscriber.
+   *
+   * @param drainTimeoutMs - Maximum time to wait for in-flight handlers (default: 30000)
+   */
+  async stop(drainTimeoutMs = 3e4) {
+    if (!this.running) {
+      return;
+    }
+    await this.poller.stop();
+    await this.subscriber.waitForCompletion(drainTimeoutMs);
+    this.subscriber.stop();
+    this.running = false;
+  }
+  /**
+   * Check if the event system is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get the event emitter (for testing or advanced use cases).
+   */
+  getEmitter() {
+    return this.emitter;
+  }
+  /**
+   * Get current statistics about the event system.
+   */
+  getStats() {
+    return {
+      running: this.running,
+      processedCount: this.subscriber.getProcessedCount(),
+      errorCount: this.subscriber.getErrorCount(),
+      activeHandlers: this.subscriber.getActiveHandlers(),
+      pollCount: this.poller.getPollCount()
+    };
+  }
+};
+
+export { EventNames, EventPoller, EventSystem, MetricsEventNames, PollerEventNames, StepEventNames, TaskerEventEmitter, WorkerEventNames, createEventPoller };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map