@tasker-systems/tasker 0.1.3 → 0.1.5

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 { BunRuntime, 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, E as ExecutableHandler, c as StepHandlerClass, T as TaskerEventEmitter, d as EventPoller, e as StepExecutionSubscriber, f as EventSystem } from './index-Bvdub2HH.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-Bvdub2HH.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,7 @@ declare function ffiEventToDomainEvent(ffiEvent: FfiDomainEvent): DomainEvent;
  * poller.start();
  * ```
  */
-declare function createFfiPollAdapter(runtime: TaskerRuntime): () => DomainEvent | null;
+declare function createFfiPollAdapter(module: NapiModule): () => DomainEvent | null;
 
 /**
  * TAS-93: Handler definition type for resolver chain.
@@ -2661,7 +2653,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.
  */
@@ -3756,98 +3760,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 +3962,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 +3986,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 +4104,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, 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, 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, FfiDomainEvent, FfiLayer, FfiLayerConfig, type HandlerDefinition, type HandlerEntry, type HandlerFactory, HandlerRegistry, type HandlerSpec, HandlerSystem, InProcessDomainEventPoller, type ListTasksOptions, type LogFields, MethodDispatchError, MethodDispatchWrapper, NapiModule, 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, 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 };