@tasker-systems/tasker 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -1,17 +1,15 @@
-import { T as TaskerRuntime, C as ClientTaskResponse, a as ClientTaskListResponse, b as ClientStepResponse, c as ClientStepAuditResponse, d as ClientHealthResponse, F as FfiDomainEvent, H as HandlerDefinitionDto } from './runtime-interface-D940vUzy.js';
-export { B as BaseTaskerRuntime, g as ClientPaginationInfo, h as ClientResult, i as ClientStepReadiness, j as ClientTaskRequest, D as DependencyResult, e as FfiBootstrapConfig, f as FfiBootstrapResult, k as FfiDispatchMetrics, L as FfiLogFields, l as FfiStepEvent, q as FfiStopResult, W as FfiWorkerStatus, m as HandlerDefinition, O as OrchestrationMetadata, R as RetryConfiguration, S as StepDefinition, n as StepExecutionError, o as StepExecutionMetadata, p as StepExecutionResult, r as Task, s as WorkflowStep } from './runtime-interface-D940vUzy.js';
-import { FfiLayer, FfiLayerConfig } from './ffi/index.js';
-export { DenoRuntime, NodeRuntime, RuntimeInfo, RuntimeType, detectRuntime, getLibraryPath, getRuntimeInfo, isBun, isDeno, isNode } from './ffi/index.js';
-import { S as StepHandlerResult, a as StepHandler, B as BatchWorkerConfig, b as StepContext, E as ExecutableHandler, c as StepHandlerClass, T as TaskerEventEmitter, d as EventPoller, e as StepExecutionSubscriber, f as EventSystem } from './index-CTl8lGpU.js';
-export { y as ErrorCallback, I as ErrorType, n as EventName, o as EventNames, z as EventPollerConfig, F as EventSystemConfig, G as EventSystemStats, A as MetricsCallback, p as MetricsEventName, q as MetricsEventNames, M as MetricsPayload, P as PollerCyclePayload, r as PollerEventName, s as PollerEventNames, C as PollerState, g as StepCompletionSentPayload, L as StepContextParams, D as StepEventCallback, t as StepEventName, u as StepEventNames, h as StepExecutionCompletedPayload, i as StepExecutionFailedPayload, j as StepExecutionReceivedPayload, k as StepExecutionStartedPayload, H as StepExecutionSubscriberConfig, N as StepHandlerResultParams, l as TaskerEventMap, W as WorkerErrorPayload, v as WorkerEventName, w as WorkerEventNames, m as WorkerEventPayload, x as createEventPoller, J as isStandardErrorType, K as isTypicallyRetryable } from './index-CTl8lGpU.js';
+import { NapiModule, FfiLayer, FfiDomainEvent, FfiLayerConfig } from './ffi/index.js';
+export { BootstrapConfig as FfiBootstrapConfig, BootstrapResult as FfiBootstrapResult, FfiDispatchMetrics, LogFields as FfiLogFields, FfiStepEvent, StopResult as FfiStopResult, WorkerStatus as FfiWorkerStatus, NapiBackoffHint, NapiCheckpointYieldData, NapiClientResult, NapiDependencyResult, NapiDispatchMetrics, NapiDomainEvent, NapiDomainEventMetadata, NapiListTasksParams, NapiOrchestrationMetadata, NapiStepDefinition, NapiStepEvent, NapiStepExecutionError, NapiStepExecutionMetadata, NapiStepExecutionResult, NapiTaskInfo, NapiTaskRequest, NapiWorkflowStep, StepExecutionResult } from './ffi/index.js';
+import { S as StepHandlerResult, a as StepHandler, B as BatchWorkerConfig, b as StepContext, c as StepHandlerClass, E as ExecutableHandler, T as TaskerEventEmitter, d as EventPoller, e as StepExecutionSubscriber, f as EventSystem } from './index-CRCYa9Xk.js';
+export { y as ErrorCallback, I as ErrorType, n as EventName, o as EventNames, z as EventPollerConfig, F as EventSystemConfig, G as EventSystemStats, A as MetricsCallback, p as MetricsEventName, q as MetricsEventNames, M as MetricsPayload, P as PollerCyclePayload, r as PollerEventName, s as PollerEventNames, C as PollerState, g as StepCompletionSentPayload, L as StepContextParams, D as StepEventCallback, t as StepEventName, u as StepEventNames, h as StepExecutionCompletedPayload, i as StepExecutionFailedPayload, j as StepExecutionReceivedPayload, k as StepExecutionStartedPayload, H as StepExecutionSubscriberConfig, N as StepHandlerResultParams, l as TaskerEventMap, W as WorkerErrorPayload, v as WorkerEventName, w as WorkerEventNames, m as WorkerEventPayload, x as createEventPoller, J as isStandardErrorType, K as isTypicallyRetryable } from './index-CRCYa9Xk.js';
 import { Logger } from 'pino';
 import 'eventemitter3';
 
 /**
  * Bootstrap configuration and result types.
  *
- * These types extend the FFI types with TypeScript-friendly interfaces
- * for worker lifecycle management.
+ * TAS-290: With napi-rs, FFI types are already camelCase, so conversion
+ * functions are simplified (mostly pass-through).
  */
 
 /**
@@ -33,8 +31,6 @@ interface BootstrapConfig {
 }
 /**
  * Result from worker bootstrap.
- *
- * Contains information about the bootstrapped worker instance.
  */
 interface BootstrapResult {
     /** Whether bootstrap was successful. */
@@ -50,8 +46,6 @@ interface BootstrapResult {
 }
 /**
  * Current worker status.
- *
- * Contains detailed information about the worker's state and resources.
  */
 interface WorkerStatus {
     /** Whether the status query succeeded. */
@@ -99,8 +93,9 @@ interface StopResult {
  *
  * Matches Python's bootstrap.py and Ruby's bootstrap.rb (TAS-92 aligned).
  *
- * All functions require an explicit runtime parameter. Use FfiLayer to load
- * the runtime before calling these functions.
+ * TAS-290: Uses NapiModule directly instead of TaskerRuntime abstraction.
+ * All functions require an explicit module parameter. Use FfiLayer to load
+ * the module before calling these functions.
  */
 
 /**
@@ -113,7 +108,7 @@ interface StopResult {
  * - Subscribing to domain events
  *
  * @param config - Optional bootstrap configuration
- * @param runtime - The loaded FFI runtime (required)
+ * @param module - The loaded napi-rs module (required)
  * @returns BootstrapResult with worker details and status
  * @throws Error if bootstrap fails critically
  *
@@ -121,41 +116,41 @@ interface StopResult {
  * ```typescript
  * const ffiLayer = new FfiLayer();
  * await ffiLayer.load();
- * const result = await bootstrapWorker({ namespace: 'payments' }, ffiLayer.getRuntime());
+ * const result = await bootstrapWorker({ namespace: 'payments' }, ffiLayer.getModule());
  * console.log(`Worker ${result.workerId} started`);
  * ```
  */
-declare function bootstrapWorker(config: BootstrapConfig | undefined, runtime: TaskerRuntime): Promise<BootstrapResult>;
+declare function bootstrapWorker(config: BootstrapConfig | undefined, module: NapiModule): Promise<BootstrapResult>;
 /**
  * Stop the worker system gracefully.
  *
  * This function stops the worker system and releases all resources.
  * Safe to call even if the worker is not running.
  *
- * @param runtime - The loaded FFI runtime (optional - returns success if not loaded)
+ * @param module - The loaded napi-rs module (optional - returns success if not loaded)
  * @returns StopResult indicating the outcome
  *
  * @example
  * ```typescript
- * const result = stopWorker(runtime);
+ * const result = stopWorker(module);
  * if (result.success) {
  *   console.log('Worker stopped successfully');
  * }
  * ```
  */
-declare function stopWorker(runtime?: TaskerRuntime): StopResult;
+declare function stopWorker(module?: NapiModule): StopResult;
 /**
  * Get the current worker system status.
  *
  * Returns detailed information about the worker's current state,
  * including resource usage and operational status.
  *
- * @param runtime - The loaded FFI runtime (optional - returns stopped if not loaded)
+ * @param module - The loaded napi-rs module (optional - returns stopped if not loaded)
  * @returns WorkerStatus with current state and metrics
  *
  * @example
  * ```typescript
- * const status = getWorkerStatus(runtime);
+ * const status = getWorkerStatus(module);
  * if (status.running) {
  *   console.log(`Pool size: ${status.databasePoolSize}`);
  * } else {
@@ -163,7 +158,7 @@ declare function stopWorker(runtime?: TaskerRuntime): StopResult;
  * }
  * ```
  */
-declare function getWorkerStatus(runtime?: TaskerRuntime): WorkerStatus;
+declare function getWorkerStatus(module?: NapiModule): WorkerStatus;
 /**
  * Initiate graceful shutdown of the worker system.
  *
@@ -171,69 +166,66 @@ declare function getWorkerStatus(runtime?: TaskerRuntime): WorkerStatus;
  * in-flight operations to complete before fully stopping.
  * Call stopWorker() after this to fully stop the worker.
  *
- * @param runtime - The loaded FFI runtime (optional - returns success if not loaded)
+ * @param module - The loaded napi-rs module (optional - returns success if not loaded)
  * @returns StopResult indicating the transition status
  *
  * @example
  * ```typescript
  * // Start graceful shutdown
- * transitionToGracefulShutdown(runtime);
+ * transitionToGracefulShutdown(module);
  *
  * // Wait for in-flight operations...
  * await new Promise(resolve => setTimeout(resolve, 5000));
  *
  * // Fully stop
- * stopWorker(runtime);
+ * stopWorker(module);
  * ```
  */
-declare function transitionToGracefulShutdown(runtime?: TaskerRuntime): StopResult;
+declare function transitionToGracefulShutdown(module?: NapiModule): StopResult;
 /**
  * Check if the worker system is currently running.
  *
  * Lightweight check that doesn't query the full status.
  *
- * @param runtime - The loaded FFI runtime (optional - returns false if not loaded)
+ * @param module - The loaded napi-rs module (optional - returns false if not loaded)
  * @returns True if the worker is running
  *
  * @example
  * ```typescript
- * if (!isWorkerRunning(runtime)) {
- *   await bootstrapWorker(config, runtime);
+ * if (!isWorkerRunning(module)) {
+ *   await bootstrapWorker(config, module);
  * }
  * ```
  */
-declare function isWorkerRunning(runtime?: TaskerRuntime): boolean;
+declare function isWorkerRunning(module?: NapiModule): boolean;
 /**
  * Get version information for the worker system.
  *
- * @param runtime - The loaded FFI runtime (optional)
+ * @param module - The loaded napi-rs module (optional)
  * @returns Version string from the Rust library
  */
-declare function getVersion(runtime?: TaskerRuntime): string;
+declare function getVersion(module?: NapiModule): string;
 /**
  * Get detailed Rust library version.
  *
- * @param runtime - The loaded FFI runtime (optional)
+ * @param module - The loaded napi-rs module (optional)
  * @returns Detailed version information
  */
-declare function getRustVersion(runtime?: TaskerRuntime): string;
+declare function getRustVersion(module?: NapiModule): string;
 /**
  * Perform a health check on the FFI module.
  *
- * @param runtime - The loaded FFI runtime (optional - returns false if not loaded)
+ * @param module - The loaded napi-rs module (optional - returns false if not loaded)
  * @returns True if the FFI module is functional
  */
-declare function healthCheck(runtime?: TaskerRuntime): boolean;
+declare function healthCheck(module?: NapiModule): boolean;
 
 /**
  * High-level client wrapper for orchestration API operations.
  *
- * The raw FFI exposes `runtime.clientCreateTask(json)` and similar methods
- * that require callers to construct complete JSON request strings with all
- * required fields and return untyped `ClientResult` envelopes.
- *
- * This module provides a `TaskerClient` class with typed methods, sensible
- * defaults, and proper error handling.
+ * TAS-290: With napi-rs, requests are passed as typed objects directly —
+ * no JSON.stringify() at the boundary. This eliminates TAS-283 trailing
+ * input bugs.
  *
  * @example
  * ```typescript
@@ -244,7 +236,7 @@ declare function healthCheck(runtime?: TaskerRuntime): boolean;
  * const client = new TaskerClient(ffiLayer);
  *
  * const task = client.createTask({ name: 'process_order', namespace: 'ecommerce' });
- * console.log(task.task_uuid);
+ * console.log(task.taskUuid);
  * ```
  *
  * @packageDocumentation
@@ -273,13 +265,13 @@ interface CreateTaskOptions {
     /** Optional tags */
     tags?: string[];
     /** Optional priority */
-    priority?: number | null;
+    priority?: number;
     /** Optional correlation ID (auto-generated if not provided) */
     correlationId?: string;
     /** Optional parent correlation ID */
-    parentCorrelationId?: string | null;
+    parentCorrelationId?: string;
     /** Optional idempotency key */
-    idempotencyKey?: string | null;
+    idempotencyKey?: string;
 }
 /**
  * Options for listing tasks.
@@ -315,26 +307,26 @@ declare class TaskerClient {
      * Create a task via the orchestration API.
      *
      * @param options - Task creation options (only `name` is required)
-     * @returns Typed task response
+     * @returns Typed task response data
      * @throws TaskerClientError if the operation fails
      */
-    createTask(options: CreateTaskOptions): ClientTaskResponse;
+    createTask(options: CreateTaskOptions): unknown;
     /**
      * Get a task by UUID.
      *
      * @param taskUuid - The task UUID
-     * @returns Typed task response
+     * @returns Typed task response data
      * @throws TaskerClientError if the operation fails
      */
-    getTask(taskUuid: string): ClientTaskResponse;
+    getTask(taskUuid: string): unknown;
     /**
      * List tasks with optional filtering and pagination.
      *
      * @param options - Filtering and pagination options
-     * @returns Typed task list response with pagination
+     * @returns Typed task list response data
      * @throws TaskerClientError if the operation fails
      */
-    listTasks(options?: ListTasksOptions): ClientTaskListResponse;
+    listTasks(options?: ListTasksOptions): unknown;
     /**
      * Cancel a task by UUID.
      *
@@ -346,43 +338,43 @@ declare class TaskerClient {
      * List workflow steps for a task.
      *
      * @param taskUuid - The task UUID
-     * @returns Array of typed step responses
+     * @returns Array of step data
      * @throws TaskerClientError if the operation fails
      */
-    listTaskSteps(taskUuid: string): ClientStepResponse[];
+    listTaskSteps(taskUuid: string): unknown;
     /**
      * Get a specific workflow step.
      *
      * @param taskUuid - The task UUID
      * @param stepUuid - The step UUID
-     * @returns Typed step response
+     * @returns Typed step response data
      * @throws TaskerClientError if the operation fails
      */
-    getStep(taskUuid: string, stepUuid: string): ClientStepResponse;
+    getStep(taskUuid: string, stepUuid: string): unknown;
     /**
      * Get audit history for a workflow step.
      *
      * @param taskUuid - The task UUID
      * @param stepUuid - The step UUID
-     * @returns Array of typed audit history entries
+     * @returns Array of audit history entries
      * @throws TaskerClientError if the operation fails
      */
-    getStepAuditHistory(taskUuid: string, stepUuid: string): ClientStepAuditResponse[];
+    getStepAuditHistory(taskUuid: string, stepUuid: string): unknown;
     /**
      * Check orchestration API health.
      *
-     * @returns Typed health response
+     * @returns Typed health response data
      * @throws TaskerClientError if the operation fails
      */
-    healthCheck(): ClientHealthResponse;
+    healthCheck(): unknown;
     /**
-     * Unwrap a ClientResult envelope, throwing on error.
+     * Unwrap a NapiClientResult envelope, throwing on error.
      */
     private unwrap;
     /**
-     * Get the FFI runtime from the layer.
+     * Get the napi-rs module from the layer.
      */
-    private getRuntime;
+    private getModule;
 }
 
 /**
@@ -2635,7 +2627,258 @@ declare function ffiEventToDomainEvent(ffiEvent: FfiDomainEvent): DomainEvent;
  * poller.start();
  * ```
  */
-declare function createFfiPollAdapter(runtime: TaskerRuntime): () => DomainEvent | null;
+declare function createFfiPollAdapter(module: NapiModule): () => DomainEvent | null;
+
+/**
+ * Functional/factory API for step handlers (TAS-294).
+ *
+ * This module provides factory-function alternatives to the class-based handler API.
+ * It reduces boilerplate for common handler patterns while preserving full access
+ * to the underlying StepContext for advanced use cases.
+ *
+ * Factory functions auto-wrap return values and classify exceptions:
+ * - Record return → StepHandlerResult.success(record)
+ * - StepHandlerResult return → pass through unchanged
+ * - PermanentError thrown → StepHandlerResult.failure(retryable=false)
+ * - RetryableError thrown → StepHandlerResult.failure(retryable=true)
+ * - Other errors → StepHandlerResult.failure(retryable=true)
+ *
+ * @example
+ * ```typescript
+ * import { defineHandler, PermanentError } from 'tasker-core';
+ *
+ * const ProcessPayment = defineHandler('process_payment', {
+ *   depends: { cart: 'validate_cart' },
+ *   inputs: { paymentInfo: 'payment_info' },
+ * }, async ({ cart, paymentInfo, context }) => {
+ *   if (!paymentInfo) throw new PermanentError('Payment info required');
+ *   const result = await chargeCard(paymentInfo, cart.total);
+ *   return { paymentId: result.id, amount: cart.total };
+ * });
+ * ```
+ *
+ * @module handler/functional
+ */
+
+/**
+ * Base error for permanent, non-retryable failures.
+ *
+ * Throw this in functional handlers when the error will not succeed on retry.
+ *
+ * @example
+ * ```typescript
+ * throw new PermanentError('Invalid account number');
+ * ```
+ */
+declare class PermanentError extends Error {
+    readonly retryable = false;
+    readonly metadata: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Base error for transient, retryable failures.
+ *
+ * Throw this in functional handlers when a retry might succeed.
+ *
+ * @example
+ * ```typescript
+ * throw new RetryableError('Service temporarily unavailable');
+ * ```
+ */
+declare class RetryableError extends Error {
+    readonly retryable = true;
+    readonly metadata: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Options for defineHandler and related factory functions.
+ */
+interface HandlerOptions {
+    /** Mapping of parameter names to dependency step names */
+    depends?: Record<string, string>;
+    /** Mapping of parameter names to input data keys */
+    inputs?: Record<string, string>;
+    /** Handler version (default: "1.0.0") */
+    version?: string;
+}
+/**
+ * The injected arguments object passed to functional handlers.
+ *
+ * Contains declared dependencies, inputs, and always includes `context`.
+ */
+type HandlerArgs = Record<string, unknown> & {
+    context: StepContext;
+};
+/**
+ * Handler function signature.
+ */
+type HandlerFn = (args: HandlerArgs) => Promise<Record<string, unknown> | StepHandlerResult | undefined>;
+/**
+ * Helper for decision handler return values.
+ *
+ * @example
+ * ```typescript
+ * const RouteOrder = defineDecisionHandler('route_order', {
+ *   depends: { order: 'validate_order' },
+ * }, async ({ order }) => {
+ *   if (order.tier === 'premium') {
+ *     return Decision.route(['process_premium'], { tier: 'premium' });
+ *   }
+ *   return Decision.route(['process_standard']);
+ * });
+ * ```
+ */
+declare class Decision {
+    readonly type: 'create_steps' | 'no_branches';
+    readonly steps: string[];
+    readonly reason?: string | undefined;
+    readonly routingContext: Record<string, unknown>;
+    private constructor();
+    /**
+     * Route to the specified steps.
+     */
+    static route(steps: string[], routingContext?: Record<string, unknown>): Decision;
+    /**
+     * Skip all branches.
+     */
+    static skip(reason: string, routingContext?: Record<string, unknown>): Decision;
+}
+/**
+ * Configuration returned by batch analyzer handlers.
+ */
+interface BatchConfig {
+    totalItems: number;
+    batchSize: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Define a step handler from a function.
+ *
+ * Returns a StepHandler subclass that can be registered with HandlerRegistry.
+ * The function receives injected dependencies, inputs, and context.
+ * Return values are auto-wrapped as success results, and exceptions are
+ * auto-classified as failure results.
+ *
+ * @param name - Handler name (must match step definition)
+ * @param options - Dependencies, inputs, and version
+ * @param fn - Handler function
+ * @returns StepHandler subclass
+ *
+ * @example
+ * ```typescript
+ * const ProcessPayment = defineHandler('process_payment', {
+ *   depends: { cart: 'validate_cart' },
+ *   inputs: { paymentInfo: 'payment_info' },
+ * }, async ({ cart, paymentInfo, context }) => {
+ *   if (!paymentInfo) throw new PermanentError('Payment info required');
+ *   const result = await chargeCard(paymentInfo, cart.total);
+ *   return { paymentId: result.id, amount: cart.total };
+ * });
+ *
+ * // Register:
+ * registry.register(ProcessPayment);
+ * ```
+ */
+declare function defineHandler(name: string, options: HandlerOptions, fn: HandlerFn): StepHandlerClass;
+/**
+ * Define a decision handler from a function.
+ *
+ * The function should return a `Decision.route(...)` or `Decision.skip(...)`.
+ *
+ * @param name - Handler name
+ * @param options - Dependencies, inputs, and version
+ * @param fn - Handler function returning a Decision
+ * @returns StepHandler subclass
+ *
+ * @example
+ * ```typescript
+ * const RouteOrder = defineDecisionHandler('route_order', {
+ *   depends: { order: 'validate_order' },
+ * }, async ({ order }) => {
+ *   if (order.tier === 'premium') {
+ *     return Decision.route(['process_premium'], { tier: 'premium' });
+ *   }
+ *   return Decision.route(['process_standard']);
+ * });
+ * ```
+ */
+declare function defineDecisionHandler(name: string, options: HandlerOptions, fn: (args: HandlerArgs) => Promise<Decision | StepHandlerResult>): StepHandlerClass;
+/**
+ * Define a batch analyzer handler.
+ *
+ * The function should return a `BatchConfig` with `totalItems` and `batchSize`.
+ * Cursor configs are generated automatically.
+ *
+ * @param name - Handler name
+ * @param options - Handler options plus `workerTemplate`
+ * @param fn - Handler function returning a BatchConfig
+ * @returns StepHandler subclass
+ */
+declare function defineBatchAnalyzer(name: string, options: HandlerOptions & {
+    workerTemplate: string;
+}, fn: (args: HandlerArgs) => Promise<BatchConfig | StepHandlerResult>): StepHandlerClass;
+/**
+ * Define a batch worker handler.
+ *
+ * The function receives a `batchContext` parameter extracted from the step
+ * context, containing cursor configuration for this worker's partition.
+ *
+ * @param name - Handler name
+ * @param options - Dependencies, inputs, and version
+ * @param fn - Handler function receiving batch context
+ * @returns StepHandler subclass
+ */
+declare function defineBatchWorker(name: string, options: HandlerOptions, fn: (args: HandlerArgs & {
+    batchContext: BatchWorkerContext | null;
+}) => Promise<Record<string, unknown> | StepHandlerResult | undefined>): StepHandlerClass;
+/**
+ * Options for defineApiHandler.
+ */
+interface ApiHandlerOptions extends HandlerOptions {
+    /** Base URL for API calls */
+    baseUrl: string;
+    /** Default request timeout in milliseconds (default: 30000) */
+    defaultTimeout?: number;
+    /** Default headers to include in all requests */
+    defaultHeaders?: Record<string, string>;
+}
+/**
+ * The injected arguments for API handlers, including the `api` object
+ * with pre-configured HTTP methods and result helpers.
+ *
+ * `api` is the handler instance itself with API methods applied (matching
+ * the Python/Ruby pattern where `api=self`).
+ */
+type ApiHandlerArgs = HandlerArgs & {
+    api: APICapable;
+};
+/**
+ * Define an API handler with HTTP client functionality.
+ *
+ * The function receives an `api` object providing pre-configured HTTP methods
+ * (get, post, put, patch, delete, request) and result helpers (apiSuccess,
+ * apiFailure, connectionError, timeoutError) from the APIMixin.
+ *
+ * @param name - Handler name (must match step definition)
+ * @param options - Dependencies, inputs, version, and API configuration
+ * @param fn - Handler function receiving api and other injected args
+ * @returns StepHandler subclass
+ *
+ * @example
+ * ```typescript
+ * const FetchUser = defineApiHandler('fetch_user', {
+ *   baseUrl: 'https://api.example.com',
+ *   depends: { userId: 'validate_user' },
+ * }, async ({ userId, api }) => {
+ *   const response = await api.get(`/users/${userId}`);
+ *   if (response.ok) {
+ *     return api.apiSuccess(response);
+ *   }
+ *   return api.apiFailure(response);
+ * });
+ * ```
+ */
+declare function defineApiHandler(name: string, options: ApiHandlerOptions, fn: (args: ApiHandlerArgs) => Promise<Record<string, unknown> | StepHandlerResult | undefined>): StepHandlerClass;
 
 /**
  * TAS-93: Handler definition type for resolver chain.
@@ -2661,7 +2904,19 @@ declare function createFfiPollAdapter(runtime: TaskerRuntime): () => DomainEvent
  * }
  * ```
  */
-
+/**
+ * Handler definition DTO from napi-rs (flattened from step definition).
+ *
+ * TAS-290: With napi-rs, handler fields are flattened into NapiStepDefinition
+ * (handlerCallable, handlerMethod, handlerResolver, handlerInitialization).
+ * This interface provides a compatible shape for fromDto().
+ */
+interface HandlerDefinitionDto {
+    callable?: string;
+    method?: string | null;
+    resolver?: string | null;
+    initialization?: Record<string, unknown>;
+}
 /**
  * Handler definition with resolution metadata.
  */
@@ -3687,12 +3942,18 @@ declare class HandlerSystem {
      * Try to import an index file from the handler path.
      */
     private tryImportIndexFile;
+    /**
+     * TAS-294: Try to import the dsl_examples index file.
+     * This is separate from tryImportIndexFile because dsl_examples/ is a sibling
+     * directory to examples/, and both need to be loaded.
+     */
+    private tryImportDslExamplesIndex;
     /**
      * Register handlers from a module's exports.
      */
     private registerHandlersFromModule;
     /**
-     * Register handlers from ALL_EXAMPLE_HANDLERS array.
+     * Register handlers from a named handler array.
      */
     private registerFromHandlerArray;
     /**
@@ -3756,98 +4017,26 @@ interface LogFields {
 }
 /**
  * Log an ERROR level message with structured fields.
- *
- * Use this for unrecoverable failures that require intervention.
- *
- * @param message - The log message
- * @param fields - Optional structured fields for context
- *
- * @example
- * logError('Database connection failed', {
- *   component: 'database',
- *   operation: 'connect',
- *   error_message: 'Connection timeout',
- * });
  */
 declare function logError(message: string, fields?: LogFields): void;
 /**
  * Log a WARN level message with structured fields.
- *
- * Use this for degraded operation or retryable failures.
- *
- * @param message - The log message
- * @param fields - Optional structured fields for context
- *
- * @example
- * logWarn('Retry attempt 3 of 5', {
- *   component: 'handler',
- *   operation: 'retry',
- *   attempt: 3,
- * });
  */
 declare function logWarn(message: string, fields?: LogFields): void;
 /**
  * Log an INFO level message with structured fields.
- *
- * Use this for lifecycle events and state transitions.
- *
- * @param message - The log message
- * @param fields - Optional structured fields for context
- *
- * @example
- * logInfo('Task processing started', {
- *   component: 'handler',
- *   operation: 'process_payment',
- *   correlation_id: 'abc-123',
- *   task_uuid: 'task-456',
- * });
  */
 declare function logInfo(message: string, fields?: LogFields): void;
 /**
  * Log a DEBUG level message with structured fields.
- *
- * Use this for detailed diagnostic information during development.
- *
- * @param message - The log message
- * @param fields - Optional structured fields for context
- *
- * @example
- * logDebug('Parsed request payload', {
- *   component: 'handler',
- *   payload_size: 1024,
- *   content_type: 'application/json',
- * });
  */
 declare function logDebug(message: string, fields?: LogFields): void;
 /**
  * Log a TRACE level message with structured fields.
- *
- * Use this for very verbose logging, like function entry/exit.
- * This level is typically disabled in production.
- *
- * @param message - The log message
- * @param fields - Optional structured fields for context
- *
- * @example
- * logTrace('Entering process_step', {
- *   component: 'handler',
- *   step_uuid: 'step-789',
- * });
  */
 declare function logTrace(message: string, fields?: LogFields): void;
 /**
  * Create a logger with preset fields.
- *
- * Useful for creating component-specific loggers that automatically
- * include common fields in every log message.
- *
- * @param defaultFields - Fields to include in every log message
- * @returns Logger object with log methods
- *
- * @example
- * const logger = createLogger({ component: 'payment_handler' });
- * logger.info('Processing payment', { amount: 100 });
- * // Logs: { component: 'payment_handler', amount: 100 }
  */
 declare function createLogger(defaultFields: LogFields): {
     error: (message: string, fields?: LogFields) => void;
@@ -4030,8 +4219,8 @@ interface ServerStatus {
  * Used by WorkerServer to manage lifecycle of all components.
  */
 interface ServerComponents {
-    /** FFI runtime instance */
-    runtime: TaskerRuntime;
+    /** napi-rs FFI module instance */
+    module: NapiModule;
     /** Event emitter for step events */
     emitter: TaskerEventEmitter;
     /** Handler registry */
@@ -4054,6 +4243,8 @@ interface ServerComponents {
  * - Event processing (via EventSystem)
  * - Graceful shutdown
  *
+ * TAS-290: Uses NapiModule directly instead of TaskerRuntime.
+ *
  * Design principles:
  * - Explicit construction: No singleton pattern - caller creates and manages
  * - Clear ownership: Owns FfiLayer, HandlerSystem, EventSystem
@@ -4170,4 +4361,4 @@ declare class WorkerServer {
     private cleanupOnError;
 }
 
-export { type APICapable, APIMixin, ApiHandler, ApiResponse, BasePublisher, type BaseResolver, BaseSubscriber, type BatchAggregationResult, type BatchAnalyzerOutcome, type BatchMetadata, type BatchProcessingOutcome, type BatchWorkerContext, type BatchWorkerOutcome, type Batchable, BatchableMixin, type BootstrapConfig, type BootstrapResult, ClassLookupResolver, ClientHealthResponse, ClientStepAuditResponse, ClientStepResponse, ClientTaskListResponse, ClientTaskResponse, type CreateBatchesOutcome, type CreateTaskOptions, type CursorConfig, type DecisionCapable, DecisionHandler, DecisionMixin, type DecisionPointOutcome, DecisionType, DefaultPublisher, type DomainEvent, type DomainEventCallback, type DomainEventErrorCallback, type DomainEventMetadata, type DomainEventPollerConfig, DuplicatePublisherError, type EventDeclaration, EventPoller, EventSystem, ExecutableHandler, ExplicitMappingResolver, type FailureStrategy, FfiLayer, FfiLayerConfig, type HandlerEntry, type HandlerFactory, HandlerRegistry, type HandlerSpec, HandlerSystem, InProcessDomainEventPoller, type ListTasksOptions, type LogFields, MethodDispatchError, MethodDispatchWrapper, type NoBatchesOutcome, NoResolverMatchError, type PollerStats, type PublishContext, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, type RegistryResolverStatic, ResolutionError, ResolverChain, type ResolverConfig, ResolverNotFoundError, type RustBatchWorkerInputs, type RustCursorConfig, type ServerComponents, type HealthCheckResult as ServerHealthCheckResult, type ServerState, type ServerStatus, ShutdownController, type ShutdownHandler, StepContext, type StepEventContext, StepExecutionSubscriber, StepHandler, StepHandlerClass, StepHandlerResult, type StepResult, type StopResult, type SubscriberClass, SubscriberRegistry, type SubscriberStats, TaskerClient, TaskerClientError, TaskerEventEmitter, TaskerRuntime, WorkerServer, type WorkerServerConfig, type WorkerStatus, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createFfiPollAdapter, createLogger, createStepEventContext, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isCreateBatches, isNoBatches, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };
+export { type APICapable, APIMixin, ApiHandler, type ApiHandlerArgs, type ApiHandlerOptions, ApiResponse, BasePublisher, type BaseResolver, BaseSubscriber, type BatchAggregationResult, type BatchAnalyzerOutcome, type BatchConfig, type BatchMetadata, type BatchProcessingOutcome, type BatchWorkerContext, type BatchWorkerOutcome, type Batchable, BatchableMixin, type BootstrapConfig, type BootstrapResult, ClassLookupResolver, type CreateBatchesOutcome, type CreateTaskOptions, type CursorConfig, Decision, type DecisionCapable, DecisionHandler, DecisionMixin, type DecisionPointOutcome, DecisionType, DefaultPublisher, type DomainEvent, type DomainEventCallback, type DomainEventErrorCallback, type DomainEventMetadata, type DomainEventPollerConfig, DuplicatePublisherError, type EventDeclaration, EventPoller, EventSystem, ExecutableHandler, ExplicitMappingResolver, type FailureStrategy, FfiDomainEvent, FfiLayer, FfiLayerConfig, type HandlerArgs, type HandlerDefinition, type HandlerEntry, type HandlerFactory, type HandlerFn, type HandlerOptions, HandlerRegistry, type HandlerSpec, HandlerSystem, InProcessDomainEventPoller, type ListTasksOptions, type LogFields, MethodDispatchError, MethodDispatchWrapper, NapiModule, type NoBatchesOutcome, NoResolverMatchError, PermanentError, type PollerStats, type PublishContext, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, type RegistryResolverStatic, ResolutionError, ResolverChain, type ResolverConfig, ResolverNotFoundError, RetryableError, type RustBatchWorkerInputs, type RustCursorConfig, type ServerComponents, type HealthCheckResult as ServerHealthCheckResult, type ServerState, type ServerStatus, ShutdownController, type ShutdownHandler, StepContext, type StepEventContext, StepExecutionSubscriber, StepHandler, StepHandlerClass, StepHandlerResult, type StepResult, type StopResult, type SubscriberClass, SubscriberRegistry, type SubscriberStats, TaskerClient, TaskerClientError, TaskerEventEmitter, WorkerServer, type WorkerServerConfig, type WorkerStatus, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createFfiPollAdapter, createLogger, createStepEventContext, defineApiHandler, defineBatchAnalyzer, defineBatchWorker, defineDecisionHandler, defineHandler, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isCreateBatches, isNoBatches, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };