@tasker-systems/tasker 0.1.4 → 0.1.5

package/dist/events/index.js

@@ -208,7 +208,7 @@ if (process.env.TASKER_ENV !== "production") {
 }
 var log = pino(loggerOptions);
 var EventPoller = class {
-  runtime;
+  module;
   config;
   emitter;
   state = "stopped";
@@ -221,12 +221,12 @@ var EventPoller = class {
   /**
    * Create a new EventPoller.
    *
-   * @param runtime - The FFI runtime for polling events
+   * @param module - The napi-rs module 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;
+  constructor(module, emitter, config = {}) {
+    this.module = module;
     this.emitter = emitter;
     this.config = {
       pollIntervalMs: config.pollIntervalMs ?? 10,
@@ -293,13 +293,6 @@ var EventPoller = class {
       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;
@@ -360,17 +353,17 @@ var EventPoller = class {
     try {
       let eventsProcessed = 0;
       for (let i = 0; i < this.config.maxEventsPerCycle; i++) {
-        const event = this.runtime.pollStepEvents();
+        const event = this.module.pollStepEvents();
         if (event === null) {
           break;
         }
         eventsProcessed++;
-        const handlerCallable = event.step_definition.handler.callable;
+        const handlerCallable = event.stepDefinition.handlerCallable;
         log.info(
           {
             component: "event-poller",
             operation: "event_received",
-            stepUuid: event.step_uuid,
+            stepUuid: event.stepUuid,
             handlerCallable,
             eventIndex: i
           },
@@ -382,7 +375,7 @@ var EventPoller = class {
         this.checkStarvation();
       }
       if (this.pollCount % this.config.cleanupInterval === 0) {
-        this.runtime.cleanupTimeouts();
+        this.module.cleanupTimeouts();
       }
       if (this.pollCount % this.config.metricsInterval === 0) {
         this.emitMetrics();
@@ -403,12 +396,12 @@ var EventPoller = class {
    * Handle a step event
    */
   handleStepEvent(event) {
-    const handlerCallable = event.step_definition.handler.callable;
+    const handlerCallable = event.stepDefinition.handlerCallable;
     log.debug(
       {
         component: "event-poller",
         operation: "handle_step_event",
-        stepUuid: event.step_uuid,
+        stepUuid: event.stepUuid,
         handlerCallable,
         hasCallback: !!this.stepEventCallback
       },
@@ -419,7 +412,7 @@ var EventPoller = class {
       {
         component: "event-poller",
         emitterInstanceId: this.emitter.getInstanceId(),
-        stepUuid: event.step_uuid,
+        stepUuid: event.stepUuid,
         listenerCount: listenerCountBefore,
         eventName: StepEventNames.STEP_EXECUTION_RECEIVED
       },
@@ -433,7 +426,7 @@ var EventPoller = class {
       log.info(
         {
           component: "event-poller",
-          stepUuid: event.step_uuid,
+          stepUuid: event.stepUuid,
           emitResult,
           listenerCountAfter: this.emitter.listenerCount(StepEventNames.STEP_EXECUTION_RECEIVED),
           eventName: StepEventNames.STEP_EXECUTION_RECEIVED
@@ -444,7 +437,7 @@ var EventPoller = class {
       log.error(
         {
           component: "event-poller",
-          stepUuid: event.step_uuid,
+          stepUuid: event.stepUuid,
           error: emitError instanceof Error ? emitError.message : String(emitError),
           stack: emitError instanceof Error ? emitError.stack : void 0
         },
@@ -453,7 +446,7 @@ var EventPoller = class {
     }
     if (this.stepEventCallback) {
       log.debug(
-        { component: "event-poller", stepUuid: event.step_uuid },
+        { component: "event-poller", stepUuid: event.stepUuid },
         "Invoking step event callback"
       );
       this.stepEventCallback(event).catch((error) => {
@@ -461,7 +454,7 @@ var EventPoller = class {
       });
     } else {
       log.warn(
-        { component: "event-poller", stepUuid: event.step_uuid },
+        { component: "event-poller", stepUuid: event.stepUuid },
         "No step event callback registered!"
       );
     }
@@ -471,9 +464,9 @@ var EventPoller = class {
    */
   checkStarvation() {
     try {
-      this.runtime.checkStarvationWarnings();
-      const metrics = this.runtime.getFfiDispatchMetrics();
-      if (metrics.starvation_detected) {
+      this.module.checkStarvationWarnings();
+      const metrics = this.module.getFfiDispatchMetrics();
+      if (metrics.starvationDetected) {
         this.emitter.emitStarvationDetected(metrics);
       }
     } catch (error) {
@@ -485,7 +478,7 @@ var EventPoller = class {
    */
   emitMetrics() {
     try {
-      const metrics = this.runtime.getFfiDispatchMetrics();
+      const metrics = this.module.getFfiDispatchMetrics();
       this.emitter.emitMetricsUpdated(metrics);
       if (this.metricsCallback) {
         this.metricsCallback(metrics);
@@ -510,23 +503,8 @@ var EventPoller = class {
     }
   }
 };
-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 createEventPoller(module, emitter, config) {
+  return new EventPoller(module, emitter, config);
 }
 function fallbackLog(level, message, fields) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -534,52 +512,28 @@ function fallbackLog(level, message, 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
@@ -598,9 +552,9 @@ var StepContext = class _StepContext {
   inputData;
   /** Results from dependent steps */
   dependencyResults;
-  /** Handler-specific configuration (from step_definition.handler.initialization) */
+  /** Handler-specific configuration (from stepDefinition.handlerInitialization) */
   stepConfig;
-  /** Step-specific inputs (from workflow_step.inputs, used for batch cursor config) */
+  /** Step-specific inputs (from workflowStep.inputs, used for batch cursor config) */
   stepInputs;
   /** Current retry attempt number */
   retryCount;
@@ -622,16 +576,15 @@ var StepContext = class _StepContext {
   /**
    * Create a StepContext from an FFI event.
    *
-   * Extracts input data, dependency results, and configuration from
-   * the task_sequence_step payload.
+   * TAS-290: All field access uses camelCase (napi-rs auto-converts).
    *
    * 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
+   * - dependencyResults -> results from parent steps
+   * - stepDefinition.handlerInitialization -> stepConfig
+   * - workflowStep.attempts -> retryCount
+   * - workflowStep.maxAttempts -> maxRetries
+   * - workflowStep.inputs -> stepInputs
    *
    * @param event - The FFI step event
    * @param handlerName - Name of the handler to execute
@@ -640,19 +593,18 @@ var StepContext = class _StepContext {
   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 dependencyResults = event.dependencyResults ?? {};
+    const stepDefinition = event.stepDefinition ?? {};
+    const stepConfig = stepDefinition.handlerInitialization ?? {};
+    const workflowStep = event.workflowStep ?? {};
     const retryCount = workflowStep.attempts ?? 0;
-    const maxRetries = workflowStep.max_attempts ?? 3;
+    const maxRetries = workflowStep.maxAttempts ?? 3;
     const stepInputs = workflowStep.inputs ?? {};
     return new _StepContext({
       event,
-      taskUuid: event.task_uuid,
-      stepUuid: event.step_uuid,
-      correlationId: event.correlation_id,
+      taskUuid: event.taskUuid,
+      stepUuid: event.stepUuid,
+      correlationId: event.correlationId,
       handlerName,
       inputData,
       dependencyResults,
@@ -782,10 +734,14 @@ var StepContext = class _StepContext {
   /**
    * Get the raw checkpoint data from the workflow step.
    *
+   * Note: Checkpoint data from the database uses snake_case keys
+   * (cursor, items_processed, accumulated_results) because it's stored
+   * as a serde_json::Value that passes through napi-rs as-is.
+   *
    * @returns The checkpoint data object or null if not set
    */
   get checkpoint() {
-    const workflowStep = this.event.workflow_step ?? {};
+    const workflowStep = this.event.workflowStep ?? {};
     return workflowStep.checkpoint ?? null;
   }
   /**
@@ -885,6 +841,130 @@ var StepContext = class _StepContext {
   }
 };
 
+// src/types/step-handler-result.ts
+var StepHandlerResult = class _StepHandlerResult {
+  /** Whether the handler executed successfully */
+  success;
+  /** Handler output data (success case) */
+  result;
+  /** Error message (failure case) */
+  errorMessage;
+  /** Error type/category for classification */
+  errorType;
+  /** Optional application-specific error code */
+  errorCode;
+  /** Whether the error is retryable */
+  retryable;
+  /** Additional execution metadata */
+  metadata;
+  /** Orchestration metadata for workflow coordination hints (e.g., backoff, headers) */
+  orchestrationMetadata;
+  constructor(params) {
+    this.success = params.success;
+    this.result = params.result ?? null;
+    this.errorMessage = params.errorMessage ?? null;
+    this.errorType = params.errorType ?? null;
+    this.errorCode = params.errorCode ?? null;
+    this.retryable = params.retryable ?? true;
+    this.metadata = params.metadata ?? {};
+    this.orchestrationMetadata = params.orchestrationMetadata ?? null;
+  }
+  /**
+   * Create a successful handler result.
+   *
+   * This is the primary factory method for creating success results.
+   * Aligned with Ruby and Python worker APIs.
+   *
+   * @param result - The handler output data
+   * @param metadata - Optional additional metadata
+   * @returns A StepHandlerResult indicating success
+   *
+   * @example
+   * ```typescript
+   * return StepHandlerResult.success(
+   *   { processed: 100, skipped: 5 }
+   * );
+   * ```
+   */
+  static success(result, metadata) {
+    return new _StepHandlerResult({
+      success: true,
+      result,
+      metadata: metadata ?? {}
+    });
+  }
+  /**
+   * Create a failure handler result.
+   *
+   * @param message - Human-readable error message
+   * @param errorType - Error type/category for classification. Use ErrorType enum.
+   * @param retryable - Whether the error is retryable (default: true)
+   * @param metadata - Optional additional metadata
+   * @param errorCode - Optional application-specific error code
+   * @returns A StepHandlerResult indicating failure
+   *
+   * @example
+   * ```typescript
+   * return StepHandlerResult.failure(
+   *   'Invalid input format',
+   *   ErrorType.VALIDATION_ERROR,
+   *   false
+   * );
+   * ```
+   *
+   * @example With error code
+   * ```typescript
+   * return StepHandlerResult.failure(
+   *   'Gateway timeout',
+   *   ErrorType.TIMEOUT,
+   *   true,
+   *   { duration_ms: 30000 },
+   *   'GATEWAY_TIMEOUT'
+   * );
+   * ```
+   */
+  static failure(message, errorType = "handler_error" /* HANDLER_ERROR */, retryable = true, metadata, errorCode) {
+    return new _StepHandlerResult({
+      success: false,
+      errorMessage: message,
+      // ErrorType enum values are already strings, so this works directly
+      errorType,
+      errorCode: errorCode ?? null,
+      retryable,
+      metadata: metadata ?? {}
+    });
+  }
+  /**
+   * Check if this result indicates success.
+   */
+  isSuccess() {
+    return this.success;
+  }
+  /**
+   * Check if this result indicates failure.
+   */
+  isFailure() {
+    return !this.success;
+  }
+  /**
+   * Convert to JSON for serialization.
+   *
+   * Uses snake_case keys to match the Rust FFI contract.
+   */
+  toJSON() {
+    return {
+      success: this.success,
+      result: this.result,
+      error_message: this.errorMessage,
+      error_type: this.errorType,
+      error_code: this.errorCode,
+      retryable: this.retryable,
+      metadata: this.metadata,
+      orchestration_metadata: this.orchestrationMetadata
+    };
+  }
+};
+
 // src/subscriber/step-execution-subscriber.ts
 var loggerOptions2 = {
   name: "step-subscriber",
@@ -900,7 +980,7 @@ var pinoLog = pino(loggerOptions2);
 var StepExecutionSubscriber = class {
   emitter;
   registry;
-  runtime;
+  module;
   workerId;
   maxConcurrent;
   handlerTimeoutMs;
@@ -913,13 +993,13 @@ var StepExecutionSubscriber = class {
    *
    * @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 module - The napi-rs module for submitting results (required, no fallback)
    * @param config - Optional configuration for execution behavior
    */
-  constructor(emitter, registry, runtime, config = {}) {
+  constructor(emitter, registry, module, config = {}) {
     this.emitter = emitter;
     this.registry = registry;
-    this.runtime = runtime;
+    this.module = module;
     this.workerId = config.workerId ?? `typescript-worker-${process.pid}`;
     this.maxConcurrent = config.maxConcurrent ?? 10;
     this.handlerTimeoutMs = config.handlerTimeoutMs ?? 3e5;
@@ -956,8 +1036,8 @@ var StepExecutionSubscriber = class {
           pinoLog.info(
             {
               component: "subscriber",
-              eventId: payload.event.event_id,
-              stepUuid: payload.event.step_uuid
+              eventId: payload.event.eventId,
+              stepUuid: payload.event.stepUuid
             },
             "Received step event in subscriber callback!"
           );
@@ -1057,7 +1137,7 @@ var StepExecutionSubscriber = class {
     pinoLog.info(
       {
         component: "subscriber",
-        eventId: event.event_id,
+        eventId: event.eventId,
         running: this.running,
         activeHandlers: this.activeHandlers,
         maxConcurrent: this.maxConcurrent
@@ -1066,7 +1146,7 @@ var StepExecutionSubscriber = class {
     );
     if (!this.running) {
       pinoLog.warn(
-        { component: "subscriber", eventId: event.event_id },
+        { component: "subscriber", eventId: event.eventId },
         "Received event while stopped, ignoring"
       );
       return;
@@ -1083,14 +1163,14 @@ var StepExecutionSubscriber = class {
       return;
     }
     pinoLog.info(
-      { component: "subscriber", eventId: event.event_id },
+      { component: "subscriber", eventId: event.eventId },
       "About to call processEvent()"
     );
     this.processEvent(event).catch((error) => {
       pinoLog.error(
         {
           component: "subscriber",
-          eventId: event.event_id,
+          eventId: event.eventId,
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : void 0
         },
@@ -1100,37 +1180,65 @@ var StepExecutionSubscriber = class {
   }
   /**
    * Process a step execution event.
+   *
+   * All paths produce a StepHandlerResult — the handler's result or a
+   * system-level failure. This mirrors Python's pattern where system errors
+   * (handler not found, timeout, uncaught exception) become
+   * StepHandlerResult.failure() with appropriate error_type and retryable.
    */
   async processEvent(event) {
-    pinoLog.info({ component: "subscriber", eventId: event.event_id }, "processEvent() starting");
+    pinoLog.info({ component: "subscriber", eventId: event.eventId }, "processEvent() starting");
     this.activeHandlers++;
     const startTime = Date.now();
+    const { handlerResult, handlerName, handlerWasInvoked } = await this.resolveAndExecuteHandler(event);
+    const executionTimeMs = Date.now() - startTime;
+    await this.submitResult(event, handlerResult, executionTimeMs);
+    this.emitCompletionEvents(
+      event,
+      handlerResult,
+      handlerName,
+      executionTimeMs,
+      handlerWasInvoked
+    );
+    this.activeHandlers--;
+  }
+  /**
+   * Resolve handler from registry and execute it, returning a StepHandlerResult.
+   *
+   * System-level failures (no handler name, handler not found, uncaught exception)
+   * are converted to StepHandlerResult.failure() with appropriate error_type and
+   * retryable — the caller always gets a result, never an exception.
+   */
+  async resolveAndExecuteHandler(event) {
+    let handlerName = null;
     try {
-      const handlerName = this.extractHandlerName(event);
+      handlerName = this.extractHandlerName(event);
       pinoLog.info(
-        { component: "subscriber", eventId: event.event_id, handlerName },
+        { component: "subscriber", eventId: event.eventId, handlerName },
         "Extracted handler name"
       );
       if (!handlerName) {
         pinoLog.error(
-          { component: "subscriber", eventId: event.event_id },
+          { component: "subscriber", eventId: event.eventId },
           "No handler name found!"
         );
-        await this.submitErrorResult(event, "No handler name found in step definition", startTime);
-        return;
+        return {
+          handlerResult: StepHandlerResult.failure(
+            "No handler name found in step definition",
+            "permanent_error" /* PERMANENT_ERROR */,
+            false
+          ),
+          handlerName,
+          handlerWasInvoked: false
+        };
       }
       pinoLog.info(
-        {
-          component: "subscriber",
-          eventId: event.event_id,
-          stepUuid: event.step_uuid,
-          handlerName
-        },
+        { component: "subscriber", eventId: event.eventId, stepUuid: event.stepUuid, handlerName },
         "Processing step event"
       );
       this.emitter.emit(StepEventNames.STEP_EXECUTION_STARTED, {
-        eventId: event.event_id,
-        stepUuid: event.step_uuid,
+        eventId: event.eventId,
+        stepUuid: event.stepUuid,
         handlerName,
         timestamp: /* @__PURE__ */ new Date()
       });
@@ -1142,64 +1250,80 @@ var StepExecutionSubscriber = class {
       );
       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,
+        return {
+          handlerResult: StepHandlerResult.failure(
+            `Handler not found: ${handlerName}`,
+            "handler_not_found",
+            false
+          ),
           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()
-        });
+          handlerWasInvoked: false
+        };
       }
-      this.processedCount++;
+      return await this.invokeHandler(event, handler, handlerName);
     } catch (error) {
-      this.errorCount++;
       const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorTypeName = error instanceof Error ? error.constructor.name : "Error";
       logError("Handler execution failed", {
         component: "subscriber",
-        event_id: event.event_id,
-        step_uuid: event.step_uuid,
+        event_id: event.eventId,
+        step_uuid: event.stepUuid,
         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--;
+      return {
+        handlerResult: StepHandlerResult.failure(errorMessage, errorTypeName, true, {
+          traceback: error instanceof Error ? error.stack : void 0
+        }),
+        handlerName,
+        handlerWasInvoked: false
+      };
+    }
+  }
+  /**
+   * Create context and invoke the handler, returning its result.
+   *
+   * handlerWasInvoked is true only if the handler returned (not threw).
+   */
+  async invokeHandler(event, handler, handlerName) {
+    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 handlerResult = await this.executeWithTimeout(
+      () => handler.call(context),
+      this.handlerTimeoutMs
+    );
+    pinoLog.info(
+      { component: "subscriber", handlerName, success: handlerResult.success },
+      "Handler execution completed"
+    );
+    return { handlerResult, handlerName, handlerWasInvoked: true };
+  }
+  /**
+   * Update counters and emit observability events after step completion.
+   *
+   * A handler returning failure() is still "processed" — the handler ran and
+   * gave a definitive answer. Only system-level errors (handler not found,
+   * timeout, uncaught exception) count as "errors".
+   */
+  emitCompletionEvents(event, handlerResult, handlerName, executionTimeMs, handlerWasInvoked) {
+    const name = handlerName ?? "unknown";
+    if (handlerResult.success || handlerWasInvoked) {
+      this.processedCount++;
+    } else {
+      this.errorCount++;
     }
+    const eventName = handlerResult.success ? StepEventNames.STEP_EXECUTION_COMPLETED : StepEventNames.STEP_EXECUTION_FAILED;
+    this.emitter.emit(eventName, {
+      eventId: event.eventId,
+      stepUuid: event.stepUuid,
+      handlerName: name,
+      ...handlerResult.success ? {} : { error: handlerResult.errorMessage },
+      executionTimeMs,
+      timestamp: /* @__PURE__ */ new Date()
+    });
   }
   /**
    * Execute a function with a timeout.
@@ -1218,18 +1342,10 @@ var StepExecutionSubscriber = class {
   /**
    * Extract handler name from FFI event.
    *
-   * The handler name is in step_definition.handler.callable
+   * TAS-290: With napi-rs, handler callable is flattened to stepDefinition.handlerCallable
    */
   extractHandlerName(event) {
-    const stepDefinition = event.step_definition;
-    if (!stepDefinition) {
-      return null;
-    }
-    const handler = stepDefinition.handler;
-    if (!handler) {
-      return null;
-    }
-    return handler.callable || null;
+    return event.stepDefinition?.handlerCallable || null;
   }
   /**
    * Submit a handler result via FFI.
@@ -1238,23 +1354,13 @@ var StepExecutionSubscriber = class {
    * 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;
-    }
+    pinoLog.info({ component: "subscriber", eventId: event.eventId }, "submitResult() called");
     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);
+    const serdeResult = this.buildStepExecutionResult(event, result, executionTimeMs);
+    await this.sendCompletionViaFfi(event, serdeResult, result.success);
   }
   /**
    * TAS-125: Submit a checkpoint yield via FFI.
@@ -1264,165 +1370,139 @@ var StepExecutionSubscriber = class {
    */
   async submitCheckpointYield(event, result) {
     pinoLog.info(
-      { component: "subscriber", eventId: event.event_id },
+      { component: "subscriber", eventId: event.eventId },
       "submitCheckpointYield() called - handler yielded checkpoint"
     );
     const resultData = result.result ?? {};
     const checkpointData = {
-      step_uuid: event.step_uuid,
+      stepUuid: event.stepUuid,
       cursor: resultData.cursor ?? 0,
-      items_processed: resultData.items_processed ?? 0
+      itemsProcessed: resultData.items_processed ?? 0
     };
     const accumulatedResults = resultData.accumulated_results;
     if (accumulatedResults !== void 0) {
-      checkpointData.accumulated_results = accumulatedResults;
+      checkpointData.accumulatedResults = accumulatedResults;
     }
     try {
-      const success = this.runtime.checkpointYieldStepEvent(event.event_id, checkpointData);
+      const success = this.module.checkpointYieldStepEvent(event.eventId, checkpointData);
       if (success) {
         pinoLog.info(
           {
             component: "subscriber",
-            eventId: event.event_id,
+            eventId: event.eventId,
             cursor: checkpointData.cursor,
-            itemsProcessed: checkpointData.items_processed
+            itemsProcessed: checkpointData.itemsProcessed
           },
           "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,
+          eventId: event.eventId,
+          stepUuid: event.stepUuid,
           cursor: checkpointData.cursor,
-          itemsProcessed: checkpointData.items_processed,
+          itemsProcessed: checkpointData.itemsProcessed,
           timestamp: /* @__PURE__ */ new Date()
         });
         logInfo("Checkpoint yield submitted", {
           component: "subscriber",
-          event_id: event.event_id,
-          step_uuid: event.step_uuid,
+          event_id: event.eventId,
+          step_uuid: event.stepUuid,
           cursor: String(checkpointData.cursor),
-          items_processed: String(checkpointData.items_processed)
+          items_processed: String(checkpointData.itemsProcessed)
         });
       } else {
         pinoLog.error(
-          { component: "subscriber", eventId: event.event_id },
+          { component: "subscriber", eventId: event.eventId },
           "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
+          event_id: event.eventId,
+          step_uuid: event.stepUuid
         });
       }
     } catch (error) {
       pinoLog.error(
         {
           component: "subscriber",
-          eventId: event.event_id,
+          eventId: event.eventId,
           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,
+        event_id: event.eventId,
         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.
+   * Build a NapiStepExecutionResult from a StepHandlerResult.
+   *
+   * The subscriber's only job here is to WRAP the handler result with
+   * execution metadata (timing, worker_id, step_uuid). All handler decisions
+   * (success, retryable, errorType, errorCode, orchestrationMetadata) are
+   * passed through faithfully — the subscriber does not re-interpret them.
    *
-   * IMPORTANT: metadata.retryable must be set for Rust's is_retryable() to work correctly.
+   * This mirrors Python's _submit_result() which calls
+   * StepExecutionResult.success_result() or .failure_result() passing
+   * handler fields straight through.
+   *
+   * napi-rs #[napi(object)] maps Option<T> to `?: T`. With
+   * exactOptionalPropertyTypes, optional props must be OMITTED (not null
+   * or undefined) — hence the conditional spread pattern.
    */
-  buildExecutionResult(event, result, executionTimeMs) {
-    const executionResult = {
-      step_uuid: event.step_uuid,
+  buildStepExecutionResult(event, result, executionTimeMs) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadata = {
+      executionTimeMs,
+      completedAt: now,
+      ...this.workerId != null && { workerId: this.workerId },
+      ...Object.keys(result.metadata).length > 0 && { custom: result.metadata },
+      // Pass through handler's classification — subscriber doesn't interpret these
+      ...result.retryable != null && { retryable: result.retryable },
+      ...result.errorType != null && { errorType: result.errorType },
+      ...result.errorCode != null && { errorCode: result.errorCode }
+    };
+    const napiResult = {
+      stepUuid: event.stepUuid,
       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"
+      status: result.success ? "completed" : "failed",
+      metadata
     };
     if (!result.success) {
-      executionResult.error = {
+      napiResult.error = {
         message: result.errorMessage ?? "Unknown error",
-        error_type: result.errorType ?? "handler_error",
-        retryable: result.retryable,
-        status_code: null,
-        backtrace: null
+        ...result.errorType != null && { errorType: result.errorType },
+        ...result.retryable != null && { retryable: result.retryable }
       };
     }
-    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
-      }
-    };
+    if (result.orchestrationMetadata != null) {
+      napiResult.orchestrationMetadata = result.orchestrationMetadata;
+    }
+    return napiResult;
   }
   /**
    * 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) {
+  async sendCompletionViaFfi(event, napiResult, isSuccess) {
     pinoLog.info(
       {
         component: "subscriber",
-        eventId: event.event_id,
-        stepUuid: event.step_uuid,
-        resultJson: JSON.stringify(executionResult)
+        eventId: event.eventId,
+        stepUuid: event.stepUuid,
+        success: napiResult.success,
+        status: napiResult.status
       },
-      "About to call runtime.completeStepEvent()"
+      "About to call module.completeStepEvent()"
     );
     try {
-      const ffiResult = this.runtime.completeStepEvent(event.event_id, executionResult);
+      const ffiResult = this.module.completeStepEvent(event.eventId, napiResult);
       if (ffiResult) {
-        this.handleFfiSuccess(event, executionResult, isSuccess);
+        this.handleFfiSuccess(event, isSuccess);
         return true;
       }
       this.handleFfiRejection(event);
@@ -1435,23 +1515,22 @@ var StepExecutionSubscriber = class {
   /**
    * Handle successful FFI completion submission.
    */
-  handleFfiSuccess(event, executionResult, isSuccess) {
+  handleFfiSuccess(event, isSuccess) {
     pinoLog.info(
-      { component: "subscriber", eventId: event.event_id, success: isSuccess },
+      { component: "subscriber", eventId: event.eventId, success: isSuccess },
       "completeStepEvent() returned TRUE - completion accepted by Rust"
     );
     this.emitter.emit(StepEventNames.STEP_COMPLETION_SENT, {
-      eventId: event.event_id,
-      stepUuid: event.step_uuid,
+      eventId: event.eventId,
+      stepUuid: event.stepUuid,
       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)
+      event_id: event.eventId,
+      step_uuid: event.stepUuid,
+      success: String(isSuccess)
     });
   }
   /**
@@ -1461,15 +1540,15 @@ var StepExecutionSubscriber = class {
     pinoLog.error(
       {
         component: "subscriber",
-        eventId: event.event_id,
-        stepUuid: event.step_uuid
+        eventId: event.eventId,
+        stepUuid: event.stepUuid
       },
       "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
+      event_id: event.eventId,
+      step_uuid: event.stepUuid
     });
   }
   /**
@@ -1479,7 +1558,7 @@ var StepExecutionSubscriber = class {
     pinoLog.error(
       {
         component: "subscriber",
-        eventId: event.event_id,
+        eventId: event.eventId,
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0
       },
@@ -1487,7 +1566,7 @@ var StepExecutionSubscriber = class {
     );
     logError("Failed to submit step result", {
       component: "subscriber",
-      event_id: event.event_id,
+      event_id: event.eventId,
       error_message: error instanceof Error ? error.message : String(error)
     });
   }
@@ -1513,17 +1592,17 @@ var EventSystem = class {
   /**
    * Create a new EventSystem.
    *
-   * @param runtime - The FFI runtime for polling events and submitting results
+   * @param module - The napi-rs module 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 = {}) {
+  constructor(module, registry, config = {}) {
     this.emitter = new TaskerEventEmitter();
-    this.poller = new EventPoller(runtime, this.emitter, config.poller);
+    this.poller = new EventPoller(module, this.emitter, config.poller);
     this.subscriber = new StepExecutionSubscriber(
       this.emitter,
       registry,
-      runtime,
+      module,
       config.subscriber
     );
   }
@@ -1553,11 +1632,11 @@ var EventSystem = class {
           {
             component: "event-system",
             debugListener: true,
-            eventId: payload.event?.event_id,
-            stepUuid: payload.event?.step_uuid,
+            eventId: payload.event?.eventId,
+            stepUuid: payload.event?.stepUuid,
             eventName: StepEventNames.STEP_EXECUTION_RECEIVED
           },
-          `\u{1F50D} DEBUG LISTENER: Received ${StepEventNames.STEP_EXECUTION_RECEIVED} event!`
+          `DEBUG LISTENER: Received ${StepEventNames.STEP_EXECUTION_RECEIVED} event!`
         );
       }
     );