@tasker-systems/tasker 0.1.4 → 0.1.6

package/dist/{index-CTl8lGpU.d.ts → index-CRCYa9Xk.d.ts}

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'eventemitter3';
-import { l as FfiStepEvent, p as StepExecutionResult, k as FfiDispatchMetrics, T as TaskerRuntime } from './runtime-interface-D940vUzy.js';
+import { FfiStepEvent, StepExecutionResult, FfiDispatchMetrics, NapiModule, NapiOrchestrationMetadata } from './ffi/index.js';
 
 /**
  * Event emitter for TypeScript workers.
@@ -288,6 +288,8 @@ type MetricsEventName = (typeof MetricsEventNames)[keyof typeof MetricsEventName
  * Provides a polling loop that retrieves step events from the Rust FFI layer
  * and dispatches them to registered handlers. Uses a 10ms polling interval
  * matching other language workers.
+ *
+ * TAS-290: Uses NapiModule directly instead of TaskerRuntime.
  */
 
 /**
@@ -332,7 +334,7 @@ type PollerState = 'stopped' | 'running' | 'stopping';
  * 5. Emits metrics for monitoring
  */
 declare class EventPoller {
-    private readonly runtime;
+    private readonly module;
     private readonly config;
     private readonly emitter;
     private state;
@@ -345,11 +347,11 @@ declare class EventPoller {
     /**
      * 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: TaskerRuntime, emitter: TaskerEventEmitter, config?: EventPollerConfig$1);
+    constructor(module: NapiModule, emitter: TaskerEventEmitter, config?: EventPollerConfig$1);
     /**
      * Get the current poller state
      */
@@ -408,9 +410,9 @@ declare class EventPoller {
     private handleError;
 }
 /**
- * Create an event poller with the given runtime, emitter, and configuration
+ * Create an event poller with the given module, emitter, and configuration
  */
-declare function createEventPoller(runtime: TaskerRuntime, emitter: TaskerEventEmitter, config?: EventPollerConfig$1): EventPoller;
+declare function createEventPoller(module: NapiModule, emitter: TaskerEventEmitter, config?: EventPollerConfig$1): EventPoller;
 
 /**
  * Standard error types for cross-language consistency.
@@ -521,9 +523,9 @@ declare class StepContext {
     readonly inputData: Record<string, unknown>;
     /** Results from dependent steps */
     readonly dependencyResults: Record<string, unknown>;
-    /** Handler-specific configuration (from step_definition.handler.initialization) */
+    /** Handler-specific configuration (from stepDefinition.handlerInitialization) */
     readonly stepConfig: Record<string, unknown>;
-    /** Step-specific inputs (from workflow_step.inputs, used for batch cursor config) */
+    /** Step-specific inputs (from workflowStep.inputs, used for batch cursor config) */
     readonly stepInputs: Record<string, unknown>;
     /** Current retry attempt number */
     readonly retryCount: number;
@@ -533,16 +535,15 @@ declare 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
@@ -634,6 +635,10 @@ declare 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(): Record<string, unknown> | null;
@@ -745,6 +750,7 @@ interface StepHandlerResultParams {
     errorCode?: string | null;
     retryable?: boolean;
     metadata?: Record<string, unknown>;
+    orchestrationMetadata?: NapiOrchestrationMetadata | null;
 }
 /**
  * Result from a step handler execution.
@@ -794,6 +800,8 @@ declare class StepHandlerResult {
     readonly retryable: boolean;
     /** Additional execution metadata */
     readonly metadata: Record<string, unknown>;
+    /** Orchestration metadata for workflow coordination hints (e.g., backoff, headers) */
+    readonly orchestrationMetadata: NapiOrchestrationMetadata | null;
     constructor(params: StepHandlerResultParams);
     /**
      * Create a successful handler result.
@@ -940,6 +948,10 @@ declare abstract class StepHandler {
     /**
      * Version string for the handler.
      * Default: "1.0.0"
+     *
+     * Currently a no-op — not yet wired through FFI bridges to
+     * StepExecutionMetadata. Reserved for future observability
+     * and compatibility tracking.
      */
     static handlerVersion: string;
     /**
@@ -1046,6 +1058,9 @@ declare abstract class StepHandler {
  * Subscribes to step execution events from the EventPoller and dispatches
  * them to the appropriate handlers via the HandlerRegistry.
  *
+ * TAS-290: Uses NapiModule directly instead of TaskerRuntime.
+ * All field access uses camelCase (napi-rs auto-converts from Rust snake_case).
+ *
  * Matches Python's StepExecutionSubscriber pattern (TAS-92 aligned).
  */
 
@@ -1086,7 +1101,7 @@ interface StepExecutionSubscriberConfig {
  * const subscriber = new StepExecutionSubscriber(
  *   eventEmitter,
  *   handlerRegistry,
- *   runtime,
+ *   module,
  *   { workerId: 'worker-1' }
  * );
  *
@@ -1099,7 +1114,7 @@ interface StepExecutionSubscriberConfig {
 declare class StepExecutionSubscriber {
     private readonly emitter;
     private readonly registry;
-    private readonly runtime;
+    private readonly module;
     private readonly workerId;
     private readonly maxConcurrent;
     private readonly handlerTimeoutMs;
@@ -1112,10 +1127,10 @@ declare class 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 module - The napi-rs module for submitting results (required, no fallback)
      * @param config - Optional configuration for execution behavior
      */
-    constructor(emitter: TaskerEventEmitter, registry: HandlerRegistryInterface, runtime: TaskerRuntime, config?: StepExecutionSubscriberConfig);
+    constructor(emitter: TaskerEventEmitter, registry: HandlerRegistryInterface, module: NapiModule, config?: StepExecutionSubscriberConfig);
     /**
      * Start subscribing to step execution events.
      */
@@ -1156,8 +1171,35 @@ declare class StepExecutionSubscriber {
     private handleEvent;
     /**
      * 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.
      */
     private processEvent;
+    /**
+     * 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.
+     */
+    private resolveAndExecuteHandler;
+    /**
+     * Create context and invoke the handler, returning its result.
+     *
+     * handlerWasInvoked is true only if the handler returned (not threw).
+     */
+    private invokeHandler;
+    /**
+     * 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".
+     */
+    private emitCompletionEvents;
     /**
      * Execute a function with a timeout.
      */
@@ -1165,7 +1207,7 @@ declare class StepExecutionSubscriber {
     /**
      * 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
      */
     private extractHandlerName;
     /**
@@ -1183,21 +1225,22 @@ declare class StepExecutionSubscriber {
      */
     private submitCheckpointYield;
     /**
-     * Submit an error result via FFI (for handler resolution/execution failures).
-     */
-    private submitErrorResult;
-    /**
-     * Build a StepExecutionResult from a handler result.
+     * Build a NapiStepExecutionResult from a StepHandlerResult.
      *
-     * IMPORTANT: metadata.retryable must be set for Rust's is_retryable() to work correctly.
-     */
-    private buildExecutionResult;
-    /**
-     * Build an error StepExecutionResult for handler resolution/execution failures.
+     * 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.
      */
-    private buildErrorExecutionResult;
+    private buildStepExecutionResult;
     /**
      * Send a completion result to Rust via FFI and handle the response.
      *
@@ -1229,6 +1272,8 @@ declare class StepExecutionSubscriber {
  * By owning all three components, EventSystem guarantees they share the
  * same emitter instance, eliminating reference sharing bugs.
  *
+ * TAS-290: Uses NapiModule directly instead of TaskerRuntime.
+ *
  * Design principles:
  * - Explicit construction: All dependencies injected via constructor
  * - Clear ownership: This class owns the emitter lifecycle
@@ -1288,12 +1333,12 @@ interface EventSystemStats {
 /**
  * Unified event processing system.
  *
- * Owns the complete event flow: emitter → poller → subscriber.
+ * Owns the complete event flow: emitter -> poller -> subscriber.
  * Guarantees all components share the same emitter instance.
  *
  * @example
  * ```typescript
- * const eventSystem = new EventSystem(runtime, registry, {
+ * const eventSystem = new EventSystem(module, registry, {
  *   poller: { pollIntervalMs: 10 },
  *   subscriber: { workerId: 'worker-1', maxConcurrent: 10 },
  * });
@@ -1311,11 +1356,11 @@ declare class EventSystem {
     /**
      * 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: TaskerRuntime, registry: HandlerRegistryInterface, config?: EventSystemConfig);
+    constructor(module: NapiModule, registry: HandlerRegistryInterface, config?: EventSystemConfig);
     /**
      * Start the event system.
      *