@tasker-systems/tasker 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,4013 @@
+import { T as TaskerRuntime, F as FfiDomainEvent, H as HandlerDefinitionDto } from './runtime-interface-CE4viUt7.js';
+export { B as BaseTaskerRuntime, C as ClientHealthResponse, c as ClientPaginationInfo, d as ClientResult, e as ClientStepAuditResponse, f as ClientStepReadiness, g as ClientStepResponse, h as ClientTaskListResponse, i as ClientTaskRequest, j as ClientTaskResponse, D as DependencyResult, a as FfiBootstrapConfig, b 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-CE4viUt7.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-B3BcknlZ.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-B3BcknlZ.js';
+import { FfiLayerConfig } from './ffi/index.js';
+export { BunRuntime, DenoRuntime, FfiLayer, NodeRuntime, RuntimeInfo, RuntimeType, detectRuntime, getLibraryPath, getRuntimeInfo, isBun, isDeno, isNode } from './ffi/index.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.
+ */
+
+/**
+ * Configuration for worker bootstrap.
+ *
+ * Matches Python's BootstrapConfig and Ruby's bootstrap options.
+ */
+interface BootstrapConfig {
+    /** Optional worker ID. Auto-generated if not provided. */
+    workerId?: string;
+    /** Task namespace this worker handles (default: "default"). */
+    namespace?: string;
+    /** Path to custom configuration file (TOML). */
+    configPath?: string;
+    /** Log level: trace, debug, info, warn, error (default: "info"). */
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    /** Database URL override. */
+    databaseUrl?: string;
+}
+/**
+ * Result from worker bootstrap.
+ *
+ * Contains information about the bootstrapped worker instance.
+ */
+interface BootstrapResult {
+    /** Whether bootstrap was successful. */
+    success: boolean;
+    /** Current status (started, already_running, error). */
+    status: 'started' | 'already_running' | 'error';
+    /** Human-readable status message. */
+    message: string;
+    /** Unique identifier for this worker instance. */
+    workerId?: string;
+    /** Error message if bootstrap failed. */
+    error?: string;
+}
+/**
+ * Current worker status.
+ *
+ * Contains detailed information about the worker's state and resources.
+ */
+interface WorkerStatus {
+    /** Whether the status query succeeded. */
+    success: boolean;
+    /** Whether the worker is currently running. */
+    running: boolean;
+    /** Current status string. */
+    status?: string;
+    /** Worker ID if running. */
+    workerId?: string;
+    /** Current environment (test, development, production). */
+    environment?: string;
+    /** Internal worker core status. */
+    workerCoreStatus?: string;
+    /** Whether the web API is enabled. */
+    webApiEnabled?: boolean;
+    /** List of task namespaces this worker handles. */
+    supportedNamespaces?: string[];
+    /** Total database connection pool size. */
+    databasePoolSize?: number;
+    /** Number of idle database connections. */
+    databasePoolIdle?: number;
+}
+/**
+ * Result from stopping the worker.
+ */
+interface StopResult {
+    /** Whether the stop was successful. */
+    success: boolean;
+    /** Current status (stopped, not_running, error). */
+    status: 'stopped' | 'not_running' | 'error';
+    /** Human-readable status message. */
+    message: string;
+    /** Worker ID that was stopped. */
+    workerId?: string;
+    /** Error message if stop failed. */
+    error?: string;
+}
+
+/**
+ * Bootstrap API for TypeScript workers.
+ *
+ * High-level TypeScript API for worker lifecycle management.
+ * Wraps FFI calls with type-safe interfaces and error handling.
+ *
+ * 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.
+ */
+
+/**
+ * Initialize the worker system.
+ *
+ * This function bootstraps the full tasker-worker system, including:
+ * - Creating a Tokio runtime for async operations
+ * - Connecting to the database
+ * - Setting up the FFI dispatch channel for step events
+ * - Subscribing to domain events
+ *
+ * @param config - Optional bootstrap configuration
+ * @param runtime - The loaded FFI runtime (required)
+ * @returns BootstrapResult with worker details and status
+ * @throws Error if bootstrap fails critically
+ *
+ * @example
+ * ```typescript
+ * const ffiLayer = new FfiLayer();
+ * await ffiLayer.load();
+ * const result = await bootstrapWorker({ namespace: 'payments' }, ffiLayer.getRuntime());
+ * console.log(`Worker ${result.workerId} started`);
+ * ```
+ */
+declare function bootstrapWorker(config: BootstrapConfig | undefined, runtime: TaskerRuntime): 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)
+ * @returns StopResult indicating the outcome
+ *
+ * @example
+ * ```typescript
+ * const result = stopWorker(runtime);
+ * if (result.success) {
+ *   console.log('Worker stopped successfully');
+ * }
+ * ```
+ */
+declare function stopWorker(runtime?: TaskerRuntime): 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)
+ * @returns WorkerStatus with current state and metrics
+ *
+ * @example
+ * ```typescript
+ * const status = getWorkerStatus(runtime);
+ * if (status.running) {
+ *   console.log(`Pool size: ${status.databasePoolSize}`);
+ * } else {
+ *   console.log(`Worker not running`);
+ * }
+ * ```
+ */
+declare function getWorkerStatus(runtime?: TaskerRuntime): WorkerStatus;
+/**
+ * Initiate graceful shutdown of the worker system.
+ *
+ * This function begins the graceful shutdown process, allowing
+ * 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)
+ * @returns StopResult indicating the transition status
+ *
+ * @example
+ * ```typescript
+ * // Start graceful shutdown
+ * transitionToGracefulShutdown(runtime);
+ *
+ * // Wait for in-flight operations...
+ * await new Promise(resolve => setTimeout(resolve, 5000));
+ *
+ * // Fully stop
+ * stopWorker(runtime);
+ * ```
+ */
+declare function transitionToGracefulShutdown(runtime?: TaskerRuntime): 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)
+ * @returns True if the worker is running
+ *
+ * @example
+ * ```typescript
+ * if (!isWorkerRunning(runtime)) {
+ *   await bootstrapWorker(config, runtime);
+ * }
+ * ```
+ */
+declare function isWorkerRunning(runtime?: TaskerRuntime): boolean;
+/**
+ * Get version information for the worker system.
+ *
+ * @param runtime - The loaded FFI runtime (optional)
+ * @returns Version string from the Rust library
+ */
+declare function getVersion(runtime?: TaskerRuntime): string;
+/**
+ * Get detailed Rust library version.
+ *
+ * @param runtime - The loaded FFI runtime (optional)
+ * @returns Detailed version information
+ */
+declare function getRustVersion(runtime?: TaskerRuntime): string;
+/**
+ * Perform a health check on the FFI module.
+ *
+ * @param runtime - The loaded FFI runtime (optional - returns false if not loaded)
+ * @returns True if the FFI module is functional
+ */
+declare function healthCheck(runtime?: TaskerRuntime): boolean;
+
+/**
+ * API mixin for HTTP functionality.
+ *
+ * TAS-112: Composition Pattern - API Mixin
+ *
+ * This module provides the APIMixin class for step handlers that need HTTP
+ * functionality. Use via interface implementation with method binding.
+ *
+ * @example
+ * ```typescript
+ * class FetchUserHandler extends StepHandler implements APICapable {
+ *   static handlerName = 'fetch_user';
+ *   static baseUrl = 'https://api.example.com';
+ *
+ *   // Bind APIMixin methods
+ *   get = APIMixin.prototype.get.bind(this);
+ *   apiSuccess = APIMixin.prototype.apiSuccess.bind(this);
+ *   apiFailure = APIMixin.prototype.apiFailure.bind(this);
+ *   // ... other required methods
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const response = await this.get('/users');
+ *     if (response.ok) {
+ *       return this.apiSuccess(response);
+ *     }
+ *     return this.apiFailure(response);
+ *   }
+ * }
+ * ```
+ *
+ * @module handler/mixins/api
+ */
+
+/**
+ * Response wrapper for API calls.
+ *
+ * Provides convenient access to response data and error classification.
+ */
+declare class ApiResponse {
+    readonly statusCode: number;
+    readonly headers: Record<string, string>;
+    readonly body: unknown;
+    readonly rawResponse: Response;
+    constructor(response: Response, body?: unknown);
+    /**
+     * Check if the response indicates success (2xx status).
+     */
+    get ok(): boolean;
+    /**
+     * Check if the response indicates a client error (4xx status).
+     */
+    get isClientError(): boolean;
+    /**
+     * Check if the response indicates a server error (5xx status).
+     */
+    get isServerError(): boolean;
+    /**
+     * Check if the error should be retried.
+     */
+    get isRetryable(): boolean;
+    /**
+     * Get the Retry-After header value in seconds, if present.
+     */
+    get retryAfter(): number | null;
+    /**
+     * Convert the response to a dictionary for result output.
+     */
+    toDict(): Record<string, unknown>;
+}
+/**
+ * Interface for API-capable handlers.
+ *
+ * Implement this interface and bind APIMixin methods to get HTTP functionality.
+ */
+interface APICapable {
+    /** Base URL for API calls */
+    baseUrl: string;
+    /** Default request timeout in milliseconds */
+    timeout: number;
+    /** Default headers to include in all requests */
+    defaultHeaders: Record<string, string>;
+    get(path: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<ApiResponse>;
+    post(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    put(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    patch(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    delete(path: string, headers?: Record<string, string>): Promise<ApiResponse>;
+    request(method: string, path: string, options?: RequestInit): Promise<ApiResponse>;
+    apiSuccess(response: ApiResponse, result?: Record<string, unknown>, includeResponse?: boolean): StepHandlerResult;
+    apiFailure(response: ApiResponse, message?: string): StepHandlerResult;
+    connectionError(error: Error, context?: string): StepHandlerResult;
+    timeoutError(error: Error, context?: string): StepHandlerResult;
+}
+/**
+ * Implementation of API methods.
+ *
+ * TAS-112: Use via interface implementation with method binding.
+ *
+ * Provides HTTP client functionality with automatic error classification,
+ * retry handling, and convenient methods for common HTTP operations.
+ */
+declare class APIMixin implements APICapable {
+    static baseUrl: string;
+    static defaultTimeout: number;
+    static defaultHeaders: Record<string, string>;
+    get baseUrl(): string;
+    get timeout(): number;
+    get defaultHeaders(): Record<string, string>;
+    /**
+     * Make a GET request.
+     */
+    get(path: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<ApiResponse>;
+    /**
+     * Make a POST request.
+     */
+    post(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    /**
+     * Make a PUT request.
+     */
+    put(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    /**
+     * Make a PATCH request.
+     */
+    patch(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    /**
+     * Make a DELETE request.
+     */
+    delete(path: string, headers?: Record<string, string>): Promise<ApiResponse>;
+    /**
+     * Make an arbitrary HTTP request.
+     */
+    request(method: string, path: string, options?: RequestInit): Promise<ApiResponse>;
+    /**
+     * Create a success result from an API response.
+     */
+    apiSuccess(response: ApiResponse, result?: Record<string, unknown>, includeResponse?: boolean): StepHandlerResult;
+    /**
+     * Create a failure result from an API response.
+     */
+    apiFailure(response: ApiResponse, message?: string): StepHandlerResult;
+    /**
+     * Create a failure result from a connection error.
+     */
+    connectionError(error: Error, context?: string): StepHandlerResult;
+    /**
+     * Create a failure result from a timeout error.
+     */
+    timeoutError(error: Error, context?: string): StepHandlerResult;
+    private fetch;
+    private buildUrl;
+    private mergeHeaders;
+    private prepareBody;
+    private classifyError;
+    private formatErrorMessage;
+    private extractBodyErrorMessage;
+}
+/**
+ * Helper function to apply API methods to a handler instance.
+ *
+ * @example
+ * ```typescript
+ * class MyApiHandler extends StepHandler {
+ *   constructor() {
+ *     super();
+ *     applyAPI(this);
+ *   }
+ * }
+ * ```
+ */
+declare function applyAPI<T extends object>(target: T): T & APICapable;
+
+/**
+ * API handler for HTTP interactions.
+ *
+ * TAS-112: Composition Pattern (DEPRECATED CLASS)
+ *
+ * This module provides the ApiHandler class for backward compatibility.
+ * For new code, use the mixin pattern:
+ *
+ * @example Using APIMixin
+ * ```typescript
+ * import { StepHandler } from './base';
+ * import { APIMixin, APICapable, applyAPI } from './mixins/api';
+ *
+ * class FetchUserHandler extends StepHandler implements APICapable {
+ *   static handlerName = 'fetch_user';
+ *   static baseUrl = 'https://api.example.com';
+ *
+ *   constructor() {
+ *     super();
+ *     applyAPI(this);
+ *   }
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const response = await this.get('/users');
+ *     if (response.ok) {
+ *       return this.apiSuccess(response);
+ *     }
+ *     return this.apiFailure(response);
+ *   }
+ * }
+ * ```
+ *
+ * @module handler/api
+ */
+
+/**
+ * Base class for HTTP API step handlers.
+ *
+ * TAS-112: This class is provided for backward compatibility.
+ * For new code, prefer using APIMixin directly with applyAPI().
+ *
+ * Provides HTTP client functionality with automatic error classification,
+ * retry handling, and convenient methods for common HTTP operations.
+ *
+ * Uses native fetch API (available in Bun and Node.js 18+).
+ *
+ * @example
+ * ```typescript
+ * class PaymentApiHandler extends ApiHandler {
+ *   static handlerName = 'process_payment';
+ *   static baseUrl = 'https://payments.example.com/api/v1';
+ *   static defaultHeaders = { 'X-API-Key': 'secret' };
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const paymentData = context.inputData['payment'];
+ *     const response = await this.post('/payments', { body: paymentData });
+ *     if (response.ok) {
+ *       return this.apiSuccess(response);
+ *     }
+ *     return this.apiFailure(response);
+ *   }
+ * }
+ * ```
+ */
+declare abstract class ApiHandler extends StepHandler {
+    /** Base URL for API calls. Override in subclasses. */
+    static baseUrl: string;
+    /** Default request timeout in milliseconds. */
+    static defaultTimeout: number;
+    /** Default headers to include in all requests. */
+    static defaultHeaders: Record<string, string>;
+    private _apiMixin;
+    private getApiMixin;
+    get capabilities(): string[];
+    /**
+     * Get the base URL for this handler.
+     */
+    get baseUrl(): string;
+    /**
+     * Get the default timeout for this handler.
+     */
+    get timeout(): number;
+    /**
+     * Get the default headers for this handler.
+     */
+    get defaultHeaders(): Record<string, string>;
+    protected get(path: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<ApiResponse>;
+    protected post(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    protected put(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    protected patch(path: string, options?: {
+        body?: unknown;
+        json?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse>;
+    protected delete(path: string, headers?: Record<string, string>): Promise<ApiResponse>;
+    protected request(method: string, path: string, options?: RequestInit): Promise<ApiResponse>;
+    protected apiSuccess(response: ApiResponse, result?: Record<string, unknown>, includeResponse?: boolean): StepHandlerResult;
+    protected apiFailure(response: ApiResponse, message?: string): StepHandlerResult;
+    protected connectionError(error: Error, context?: string): StepHandlerResult;
+    protected timeoutError(error: Error, context?: string): StepHandlerResult;
+}
+
+/**
+ * Batch processing types for cursor-based batch operations.
+ *
+ * These types support the analyzer/worker pattern for processing
+ * large datasets in parallel batches.
+ *
+ * Matches Python's batch processing types and Ruby's batch types (TAS-92 aligned).
+ *
+ * ## FFI Boundary Types (TAS-112/TAS-123)
+ *
+ * This module includes types that cross the Rust ↔ TypeScript FFI boundary:
+ *
+ * - `RustCursorConfig` - Cursor configuration with flexible cursor types
+ * - `BatchProcessingOutcome` - Discriminated union for batch processing decisions
+ * - `RustBatchWorkerInputs` - Worker initialization inputs from Rust orchestration
+ * - `BatchMetadata` - Batch processing metadata from template configuration
+ *
+ * These types are serialized by Rust and deserialized by TypeScript workers.
+ * They must remain compatible with Rust's serde serialization format.
+ *
+ * @module types/batch
+ */
+/**
+ * Configuration for cursor-based batch processing.
+ *
+ * Defines a range of items to process in a batch worker step.
+ */
+interface CursorConfig {
+    /** Starting cursor position (inclusive) */
+    startCursor: number;
+    /** Ending cursor position (exclusive) */
+    endCursor: number;
+    /** Step size for iteration (usually 1) */
+    stepSize: number;
+    /** Additional metadata for this cursor range */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Outcome from a batch analyzer handler.
+ *
+ * Batch analyzers return this to define the cursor ranges that will
+ * spawn parallel batch worker steps.
+ */
+interface BatchAnalyzerOutcome {
+    /** List of cursor configurations for batch workers */
+    cursorConfigs: CursorConfig[];
+    /** Total number of items to process (for progress tracking) */
+    totalItems: number | null;
+    /** Metadata to pass to all batch workers */
+    batchMetadata: Record<string, unknown>;
+}
+/**
+ * Context for a batch worker step.
+ *
+ * Provides information about the specific batch this worker should process,
+ * including checkpoint data from previous yields (TAS-125).
+ */
+interface BatchWorkerContext {
+    /** Unique identifier for this batch */
+    batchId: string;
+    /** Cursor configuration for this batch */
+    cursorConfig: CursorConfig;
+    /** Index of this batch (0-based) */
+    batchIndex: number;
+    /** Total number of batches */
+    totalBatches: number;
+    /** Metadata from the analyzer */
+    batchMetadata: Record<string, unknown>;
+    /** TAS-125: Checkpoint data from previous yields */
+    checkpoint: Record<string, unknown>;
+    /** Convenience accessor for start cursor */
+    readonly startCursor: number;
+    /** Convenience accessor for end cursor */
+    readonly endCursor: number;
+    /** Convenience accessor for step size */
+    readonly stepSize: number;
+    /** TAS-125: Get checkpoint cursor from previous yield */
+    readonly checkpointCursor: number | string | Record<string, unknown> | undefined;
+    /** TAS-125: Get accumulated results from previous checkpoint yield */
+    readonly accumulatedResults: Record<string, unknown> | undefined;
+    /** TAS-125: Get items processed count from checkpoint */
+    readonly checkpointItemsProcessed: number;
+    /** TAS-125: Check if checkpoint exists */
+    hasCheckpoint(): boolean;
+}
+/**
+ * Outcome from a batch worker step.
+ *
+ * Batch workers return this to report progress and results.
+ */
+interface BatchWorkerOutcome {
+    /** Total items processed in this batch */
+    itemsProcessed: number;
+    /** Items that succeeded */
+    itemsSucceeded: number;
+    /** Items that failed */
+    itemsFailed: number;
+    /** Items that were skipped */
+    itemsSkipped: number;
+    /** Individual item results */
+    results: Array<Record<string, unknown>>;
+    /** Individual item errors */
+    errors: Array<Record<string, unknown>>;
+    /** Last cursor position processed */
+    lastCursor: number | null;
+    /** Additional batch metadata */
+    batchMetadata: Record<string, unknown>;
+}
+/**
+ * Create a BatchWorkerContext from raw batch data.
+ *
+ * Handles both formats:
+ * - Nested: { batch_id, cursor_config: { start_cursor, end_cursor, ... } }
+ * - Flat: { batch_id, start_cursor, end_cursor, ... }
+ *
+ * TAS-125: Also extracts checkpoint data if present.
+ *
+ * @internal
+ */
+declare function createBatchWorkerContext(batchData: Record<string, unknown>, checkpoint?: Record<string, unknown>): BatchWorkerContext;
+/**
+ * Cursor configuration for a single batch's position and range.
+ *
+ * Matches Rust's `CursorConfig` in `tasker-shared/src/messaging/execution_types.rs`.
+ *
+ * ## Flexible Cursor Types
+ *
+ * Unlike the simpler `CursorConfig` interface (which uses `number`),
+ * this type supports flexible cursor values that can be:
+ * - Integer for record IDs: `123`
+ * - String for timestamps: `"2025-11-01T00:00:00Z"`
+ * - Object for composite keys: `{"page": 1, "offset": 0}`
+ *
+ * This enables cursor-based pagination across diverse data sources.
+ *
+ * @example
+ * ```typescript
+ * // Integer cursors (most common)
+ * const intCursor: RustCursorConfig = {
+ *   batch_id: "batch_001",
+ *   start_cursor: 0,
+ *   end_cursor: 1000,
+ *   batch_size: 1000,
+ * };
+ *
+ * // Timestamp cursors
+ * const timestampCursor: RustCursorConfig = {
+ *   batch_id: "batch_001",
+ *   start_cursor: "2025-01-01T00:00:00Z",
+ *   end_cursor: "2025-01-02T00:00:00Z",
+ *   batch_size: 86400, // seconds in a day
+ * };
+ *
+ * // Composite cursors
+ * const compositeCursor: RustCursorConfig = {
+ *   batch_id: "batch_001",
+ *   start_cursor: { page: 1, offset: 0 },
+ *   end_cursor: { page: 10, offset: 0 },
+ *   batch_size: 1000,
+ * };
+ * ```
+ */
+interface RustCursorConfig {
+    /** Batch identifier (e.g., "batch_001", "batch_002") */
+    batch_id: string;
+    /**
+     * Starting position for this batch (inclusive).
+     *
+     * Type depends on cursor strategy:
+     * - `number` for record IDs
+     * - `string` for timestamps or UUIDs
+     * - `object` for composite keys
+     */
+    start_cursor: unknown;
+    /**
+     * Ending position for this batch (exclusive).
+     *
+     * Workers process items from `start_cursor` (inclusive)
+     * up to but not including `end_cursor`.
+     */
+    end_cursor: unknown;
+    /** Number of items in this batch (for progress reporting) */
+    batch_size: number;
+}
+/**
+ * Failure strategy for batch processing.
+ *
+ * Matches Rust's `FailureStrategy` enum in `task_template.rs`.
+ */
+type FailureStrategy = 'continue_on_failure' | 'fail_fast' | 'isolate';
+/**
+ * Batch processing metadata from template configuration.
+ *
+ * Matches Rust's `BatchMetadata` in `tasker-shared/src/models/core/batch_worker.rs`.
+ *
+ * This structure extracts relevant template configuration that workers
+ * need during execution. Workers don't need parallelism settings or
+ * batch size calculation logic - just execution parameters.
+ */
+interface BatchMetadata {
+    /**
+     * Database field name used for cursor-based pagination.
+     *
+     * Workers use this to construct queries like:
+     * `WHERE cursor_field > start_cursor AND cursor_field <= end_cursor`
+     *
+     * Common values: "id", "created_at", "sequence_number"
+     */
+    cursor_field: string;
+    /**
+     * How this worker should handle failures during batch processing.
+     *
+     * - `continue_on_failure`: Log errors, continue processing remaining items
+     * - `fail_fast`: Stop immediately on first error
+     * - `isolate`: Mark batch for manual investigation
+     */
+    failure_strategy: FailureStrategy;
+}
+/**
+ * Initialization inputs for batch worker instances.
+ *
+ * Matches Rust's `BatchWorkerInputs` in `tasker-shared/src/models/core/batch_worker.rs`.
+ *
+ * This structure is serialized to JSONB by Rust orchestration and stored
+ * in `workflow_steps.inputs` for dynamically created batch workers.
+ *
+ * @example
+ * ```typescript
+ * // In a batch worker handler
+ * async call(context: StepContext): Promise<StepHandlerResult> {
+ *   const inputs = context.stepInputs as RustBatchWorkerInputs;
+ *
+ *   // Check for no-op placeholder first
+ *   if (inputs.is_no_op) {
+ *     return this.success({
+ *       batch_id: inputs.cursor.batch_id,
+ *       no_op: true,
+ *       message: 'No batches to process',
+ *     });
+ *   }
+ *
+ *   // Process the batch using cursor bounds
+ *   const { start_cursor, end_cursor } = inputs.cursor;
+ *   // ... process items in range
+ * }
+ * ```
+ */
+interface RustBatchWorkerInputs {
+    /**
+     * Cursor configuration defining this worker's processing range.
+     *
+     * Created by the batchable handler after analyzing dataset size.
+     */
+    cursor: RustCursorConfig;
+    /**
+     * Batch processing metadata from template configuration.
+     *
+     * Provides checkpointing frequency, cursor field, and failure strategy.
+     */
+    batch_metadata: BatchMetadata;
+    /**
+     * Explicit flag indicating if this is a no-op/placeholder worker.
+     *
+     * Set by orchestration based on BatchProcessingOutcome type:
+     * - `true` for NoBatches outcome (placeholder worker)
+     * - `false` for CreateBatches outcome (real worker with data)
+     *
+     * Workers should check this flag FIRST before any processing logic.
+     * If `true`, immediately return success without processing.
+     */
+    is_no_op: boolean;
+}
+/**
+ * No batches needed - process as single step or skip.
+ *
+ * Returned when:
+ * - Dataset is too small to warrant batching
+ * - Data doesn't meet batching criteria
+ * - Batch processing not applicable for this execution
+ *
+ * Serialization format: `{ "type": "no_batches" }`
+ */
+interface NoBatchesOutcome {
+    type: 'no_batches';
+}
+/**
+ * Create batch worker steps from template.
+ *
+ * The orchestration system will:
+ * 1. Instantiate N workers from the template step
+ * 2. Assign each worker a unique cursor config
+ * 3. Create DAG edges from batchable step to workers
+ * 4. Enqueue workers for parallel execution
+ *
+ * Serialization format:
+ * ```json
+ * {
+ *   "type": "create_batches",
+ *   "worker_template_name": "batch_worker_template",
+ *   "worker_count": 5,
+ *   "cursor_configs": [...],
+ *   "total_items": 5000
+ * }
+ * ```
+ */
+interface CreateBatchesOutcome {
+    type: 'create_batches';
+    /**
+     * Template step name to use for creating workers.
+     *
+     * Must match a step definition in the template with `type: batch_worker`.
+     * The system creates multiple instances with generated names like:
+     * - `{template_name}_001`
+     * - `{template_name}_002`
+     */
+    worker_template_name: string;
+    /**
+     * Number of worker instances to create.
+     *
+     * Typically calculated based on dataset size / batch_size.
+     */
+    worker_count: number;
+    /**
+     * Initial cursor positions for each batch.
+     *
+     * Each worker receives one cursor config that defines its
+     * processing boundaries. Length must equal `worker_count`.
+     */
+    cursor_configs: RustCursorConfig[];
+    /**
+     * Total items to process across all batches.
+     *
+     * Used for progress tracking and observability.
+     */
+    total_items: number;
+}
+/**
+ * Outcome of a batchable step that determines batch worker creation.
+ *
+ * Matches Rust's `BatchProcessingOutcome` enum in
+ * `tasker-shared/src/messaging/execution_types.rs`.
+ *
+ * This discriminated union enables type-safe pattern matching:
+ *
+ * @example
+ * ```typescript
+ * function handleOutcome(outcome: BatchProcessingOutcome): void {
+ *   switch (outcome.type) {
+ *     case 'no_batches':
+ *       console.log('No batches needed');
+ *       break;
+ *     case 'create_batches':
+ *       console.log(`Creating ${outcome.worker_count} workers`);
+ *       console.log(`Total items: ${outcome.total_items}`);
+ *       break;
+ *     default: {
+ *       const _exhaustive: never = outcome;
+ *       throw new Error(`Unhandled outcome type: ${_exhaustive}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+type BatchProcessingOutcome = NoBatchesOutcome | CreateBatchesOutcome;
+/**
+ * Create a NoBatches outcome.
+ *
+ * Use when batching is not needed or applicable.
+ *
+ * @returns A NoBatchesOutcome object
+ */
+declare function noBatches(): NoBatchesOutcome;
+/**
+ * Create a CreateBatches outcome with specified configuration.
+ *
+ * @param workerTemplateName - Name of the template step to instantiate
+ * @param workerCount - Number of workers to create
+ * @param cursorConfigs - Cursor configuration for each worker
+ * @param totalItems - Total number of items to process
+ * @returns A CreateBatchesOutcome object
+ *
+ * @example
+ * ```typescript
+ * const outcome = createBatches(
+ *   'process_csv_batch',
+ *   3,
+ *   [
+ *     { batch_id: '001', start_cursor: 0, end_cursor: 1000, batch_size: 1000 },
+ *     { batch_id: '002', start_cursor: 1000, end_cursor: 2000, batch_size: 1000 },
+ *     { batch_id: '003', start_cursor: 2000, end_cursor: 3000, batch_size: 1000 },
+ *   ],
+ *   3000
+ * );
+ * ```
+ */
+declare function createBatches(workerTemplateName: string, workerCount: number, cursorConfigs: RustCursorConfig[], totalItems: number): CreateBatchesOutcome;
+/**
+ * Type guard to check if an outcome is NoBatches.
+ */
+declare function isNoBatches(outcome: BatchProcessingOutcome): outcome is NoBatchesOutcome;
+/**
+ * Type guard to check if an outcome is CreateBatches.
+ */
+declare function isCreateBatches(outcome: BatchProcessingOutcome): outcome is CreateBatchesOutcome;
+/**
+ * Result from aggregating multiple batch worker results.
+ *
+ * Cross-language standard: matches Python's aggregate_worker_results output
+ * and Ruby's aggregate_batch_worker_results.
+ *
+ * TAS-112: Standardized aggregation result structure.
+ */
+interface BatchAggregationResult {
+    /** Total items processed across all batches */
+    total_processed: number;
+    /** Total items that succeeded */
+    total_succeeded: number;
+    /** Total items that failed */
+    total_failed: number;
+    /** Total items that were skipped */
+    total_skipped: number;
+    /** Number of batch workers that ran */
+    batch_count: number;
+    /** Success rate (0.0 to 1.0) */
+    success_rate: number;
+    /** Collected errors from all batches (limited) */
+    errors: Array<Record<string, unknown>>;
+    /** Total error count (may exceed errors array length) */
+    error_count: number;
+}
+/**
+ * Aggregate results from multiple batch workers.
+ *
+ * Cross-language standard: matches Python's `Batchable.aggregate_worker_results`
+ * and Ruby's `aggregate_batch_worker_results`.
+ *
+ * @param workerResults - Array of results from batch worker steps
+ * @param maxErrors - Maximum number of errors to collect (default: 100)
+ * @returns Aggregated summary of all batch processing
+ *
+ * @example
+ * ```typescript
+ * // In an aggregator handler
+ * const workerResults = Object.values(context.previousResults)
+ *   .filter(r => r?.batch_worker);
+ * const summary = aggregateBatchResults(workerResults);
+ * return this.success(summary);
+ * ```
+ */
+declare function aggregateBatchResults(workerResults: Array<Record<string, unknown> | null | undefined>, maxErrors?: number): BatchAggregationResult;
+
+/**
+ * Represents the aggregation scenario for batch processing convergence steps.
+ *
+ * Cross-language standard: matches Ruby's BatchAggregationScenario,
+ * Python's BatchAggregationScenario, and Rust's BatchAggregationScenario enum.
+ *
+ * There are two scenarios:
+ * - **NoBatches**: The batchable step returned `noBatches()`, no workers were created.
+ *   The convergence step should read results directly from the batchable step.
+ * - **WithBatches**: Workers were created and processed batches. The convergence
+ *   step should aggregate results from all batch workers.
+ */
+interface BatchAggregationScenario {
+    /** True if this is a NoBatches scenario. */
+    isNoBatches: boolean;
+    /** Result from the batchable step (always present). */
+    batchableResult: Record<string, unknown>;
+    /** Dict of worker_name -> result (empty for NoBatches). */
+    batchResults: Record<string, Record<string, unknown>>;
+    /** Number of batch workers (0 for NoBatches). */
+    workerCount: number;
+}
+/**
+ * Mixin interface for batch processing capabilities.
+ *
+ * TypeScript implementation using interface + method binding pattern
+ * (since TS doesn't have true mixins like Python/Ruby).
+ *
+ * Matches Python's Batchable mixin and Ruby's Batchable module (TAS-92 aligned).
+ */
+interface Batchable {
+    createCursorConfig(start: number, end: number, stepSize?: number, metadata?: Record<string, unknown>): CursorConfig;
+    createCursorRanges(totalItems: number, batchSize: number, stepSize?: number, maxBatches?: number): CursorConfig[];
+    /**
+     * Create cursor configurations for a specific number of workers.
+     *
+     * Ruby-style method that divides items into worker_count roughly equal ranges.
+     * Use this when you know the desired number of workers rather than batch size.
+     *
+     * Cross-language standard: matches Ruby's create_cursor_configs(total_items, worker_count).
+     */
+    createCursorConfigs(totalItems: number, workerCount: number): BatchWorkerConfig[];
+    createBatchOutcome(totalItems: number, batchSize: number, stepSize?: number, batchMetadata?: Record<string, unknown>): BatchAnalyzerOutcome;
+    createWorkerOutcome(itemsProcessed: number, itemsSucceeded?: number, itemsFailed?: number, itemsSkipped?: number, results?: Array<Record<string, unknown>>, errors?: Array<Record<string, unknown>>, lastCursor?: number | null, batchMetadata?: Record<string, unknown>): BatchWorkerOutcome;
+    getBatchContext(context: StepContext): BatchWorkerContext | null;
+    /**
+     * Get Rust batch worker inputs from step context.
+     *
+     * Returns the BatchWorkerInputs structure from workflow_step.inputs,
+     * which contains cursor config, batch metadata, and no-op flag.
+     *
+     * Cross-language standard: matches Ruby's get_batch_context pattern.
+     */
+    getBatchWorkerInputs(context: StepContext): Partial<RustBatchWorkerInputs> | null;
+    /**
+     * Handle no-op placeholder worker scenario.
+     *
+     * Returns a success result if the worker is a no-op placeholder,
+     * otherwise returns null to allow normal processing to continue.
+     *
+     * Cross-language standard: matches Ruby's handle_no_op_worker.
+     */
+    handleNoOpWorker(context: StepContext): StepHandlerResult | null;
+    batchAnalyzerSuccess(outcome: BatchAnalyzerOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    batchWorkerSuccess(outcome: BatchWorkerOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * TAS-125: Yield checkpoint for batch processing.
+     *
+     * Use this method when your handler needs to persist progress and be
+     * re-dispatched for continued processing. Unlike batchWorkerSuccess,
+     * this does NOT complete the step.
+     *
+     * @param cursor - Position to resume from (number, string, or object)
+     * @param itemsProcessed - Total items processed so far (cumulative)
+     * @param accumulatedResults - Partial aggregations to carry forward
+     * @returns A StepHandlerResult with checkpoint_yield type
+     */
+    checkpointYield(cursor: number | string | Record<string, unknown>, itemsProcessed: number, accumulatedResults?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Detect batch aggregation scenario from dependency results.
+     *
+     * Cross-language standard: matches Ruby's detect_aggregation_scenario,
+     * Python's detect_aggregation_scenario, and Rust's BatchAggregationScenario::detect.
+     */
+    detectAggregationScenario(dependencyResults: Record<string, unknown>, batchableStepName: string, batchWorkerPrefix: string): BatchAggregationScenario;
+    /**
+     * Create a success result for NoBatches aggregation scenario.
+     *
+     * Cross-language standard: matches Ruby's no_batches_aggregation_result
+     * and Python's no_batches_aggregation_result.
+     */
+    noBatchesAggregationResult(zeroMetrics?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Aggregate batch worker results handling both scenarios.
+     *
+     * Cross-language standard: matches Ruby's aggregate_batch_worker_results
+     * and Python's aggregate_batch_worker_results.
+     */
+    aggregateBatchWorkerResults(scenario: BatchAggregationScenario, zeroMetrics?: Record<string, unknown>, aggregationFn?: (batchResults: Record<string, Record<string, unknown>>) => Record<string, unknown>): StepHandlerResult;
+}
+/**
+ * Implementation of Batchable methods.
+ *
+ * Use this class to add batch processing capabilities to your handlers.
+ * The methods can be bound to handler instances or used as a mixin.
+ *
+ * @example Analyzer using method binding
+ * ```typescript
+ * class ProductAnalyzer extends StepHandler implements Batchable {
+ *   // Bind Batchable methods to this instance
+ *   createBatchOutcome = BatchableMixin.prototype.createBatchOutcome.bind(this);
+ *   batchAnalyzerSuccess = BatchableMixin.prototype.batchAnalyzerSuccess.bind(this);
+ *   // ... other required Batchable methods
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const total = context.inputData['product_count'] as number;
+ *     const outcome = this.createBatchOutcome(total, 100);
+ *     return this.batchAnalyzerSuccess(outcome);
+ *   }
+ * }
+ * ```
+ *
+ * @example Worker using method binding
+ * ```typescript
+ * class ProductWorker extends StepHandler implements Batchable {
+ *   getBatchContext = BatchableMixin.prototype.getBatchContext.bind(this);
+ *   createWorkerOutcome = BatchableMixin.prototype.createWorkerOutcome.bind(this);
+ *   batchWorkerSuccess = BatchableMixin.prototype.batchWorkerSuccess.bind(this);
+ *   // ... other required Batchable methods
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const batchCtx = this.getBatchContext(context);
+ *     if (!batchCtx) {
+ *       return this.failure('No batch context found');
+ *     }
+ *
+ *     const results = [];
+ *     for (let i = batchCtx.startCursor; i < batchCtx.endCursor; i++) {
+ *       results.push(await this.processItem(i));
+ *     }
+ *
+ *     const outcome = this.createWorkerOutcome(results.length, results.length);
+ *     return this.batchWorkerSuccess(outcome);
+ *   }
+ * }
+ * ```
+ */
+declare class BatchableMixin implements Batchable {
+    /**
+     * Create a cursor configuration for a batch range.
+     *
+     * @param start - Starting cursor position (inclusive)
+     * @param end - Ending cursor position (exclusive)
+     * @param stepSize - Step size for iteration (default: 1)
+     * @param metadata - Additional metadata for this cursor range
+     * @returns CursorConfig for the specified range
+     */
+    createCursorConfig(start: number, end: number, stepSize?: number, metadata?: Record<string, unknown>): CursorConfig;
+    /**
+     * Create cursor ranges for batch processing.
+     *
+     * Divides totalItems into batches of batchSize, optionally limiting
+     * the number of batches.
+     *
+     * @param totalItems - Total number of items to process
+     * @param batchSize - Number of items per batch
+     * @param stepSize - Step size for iteration (default: 1)
+     * @param maxBatches - Maximum number of batches (optional)
+     * @returns Array of CursorConfig for each batch
+     */
+    createCursorRanges(totalItems: number, batchSize: number, stepSize?: number, maxBatches?: number): CursorConfig[];
+    /**
+     * Create cursor configurations for a specific number of workers.
+     *
+     * Ruby-style method that divides items into worker_count roughly equal ranges.
+     * Uses ceiling division to ensure all items are covered.
+     *
+     * ## Cursor Boundary Math
+     *
+     * 1. items_per_worker = ceil(total_items / worker_count)
+     * 2. For worker i (0-indexed):
+     *    - start = i * items_per_worker
+     *    - end = min((i + 1) * items_per_worker, total_items)
+     *    - batch_size = end - start
+     *
+     * Example: 1000 items, 3 workers
+     *   - items_per_worker = ceil(1000/3) = 334
+     *   - Worker 0: start=0, end=334, size=334
+     *   - Worker 1: start=334, end=668, size=334
+     *   - Worker 2: start=668, end=1000, size=332
+     *
+     * Cross-language standard: matches Ruby's create_cursor_configs(total_items, worker_count).
+     *
+     * @param totalItems - Total number of items to process
+     * @param workerCount - Number of workers to create configs for (must be > 0)
+     * @returns Array of BatchWorkerConfig for each worker
+     */
+    createCursorConfigs(totalItems: number, workerCount: number): BatchWorkerConfig[];
+    /**
+     * Create a batch analyzer outcome.
+     *
+     * Convenience method that creates cursor ranges and wraps them
+     * in a BatchAnalyzerOutcome.
+     *
+     * @param totalItems - Total number of items to process
+     * @param batchSize - Number of items per batch
+     * @param stepSize - Step size for iteration (default: 1)
+     * @param batchMetadata - Metadata to pass to all batch workers
+     * @returns BatchAnalyzerOutcome ready for batchAnalyzerSuccess
+     */
+    createBatchOutcome(totalItems: number, batchSize: number, stepSize?: number, batchMetadata?: Record<string, unknown>): BatchAnalyzerOutcome;
+    /**
+     * Create a batch worker outcome.
+     *
+     * @param itemsProcessed - Total items processed in this batch
+     * @param itemsSucceeded - Items that succeeded (default: itemsProcessed)
+     * @param itemsFailed - Items that failed (default: 0)
+     * @param itemsSkipped - Items that were skipped (default: 0)
+     * @param results - Individual item results
+     * @param errors - Individual item errors
+     * @param lastCursor - Last cursor position processed
+     * @param batchMetadata - Additional batch metadata
+     * @returns BatchWorkerOutcome ready for batchWorkerSuccess
+     */
+    createWorkerOutcome(itemsProcessed: number, itemsSucceeded?: number, itemsFailed?: number, itemsSkipped?: number, results?: Array<Record<string, unknown>>, errors?: Array<Record<string, unknown>>, lastCursor?: number | null, batchMetadata?: Record<string, unknown>): BatchWorkerOutcome;
+    /**
+     * Get the batch context from a step context.
+     *
+     * Looks for batch context in step_config, input_data, or step_inputs.
+     *
+     * @param context - The step context
+     * @returns BatchWorkerContext or null if not found
+     */
+    getBatchContext(context: StepContext): BatchWorkerContext | null;
+    /**
+     * Get Rust batch worker inputs from step context.
+     *
+     * Returns the BatchWorkerInputs structure from workflow_step.inputs,
+     * which contains cursor config, batch metadata, and no-op flag.
+     *
+     * Cross-language standard: matches Ruby's get_batch_context pattern
+     * for accessing Rust-provided batch configuration.
+     *
+     * @param context - The step context
+     * @returns BatchWorkerInputs or null if not found
+     */
+    getBatchWorkerInputs(context: StepContext): Partial<RustBatchWorkerInputs> | null;
+    /**
+     * Handle no-op placeholder worker scenario.
+     *
+     * Returns a success result if the worker is a no-op placeholder
+     * (created when a batchable step returns NoBatches), otherwise
+     * returns null to allow normal processing to continue.
+     *
+     * Cross-language standard: matches Ruby's handle_no_op_worker.
+     *
+     * @param context - The step context
+     * @returns Success result if no-op, null otherwise
+     *
+     * @example
+     * ```typescript
+     * async call(context: StepContext): Promise<StepHandlerResult> {
+     *   const noOpResult = this.handleNoOpWorker(context);
+     *   if (noOpResult) {
+     *     return noOpResult;
+     *   }
+     *   // ... normal processing
+     * }
+     * ```
+     */
+    handleNoOpWorker(context: StepContext): StepHandlerResult | null;
+    /**
+     * Create a success result for a batch analyzer.
+     *
+     * Formats the BatchAnalyzerOutcome in the structure expected by
+     * the orchestration layer.
+     *
+     * @param outcome - The batch analyzer outcome
+     * @param metadata - Optional additional metadata
+     * @returns A success StepHandlerResult with the batch outcome
+     */
+    batchAnalyzerSuccess(outcome: BatchAnalyzerOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a success result for a batch worker.
+     *
+     * Formats the BatchWorkerOutcome in the structure expected by
+     * the orchestration layer.
+     *
+     * @param outcome - The batch worker outcome
+     * @param metadata - Optional additional metadata
+     * @returns A success StepHandlerResult with the worker outcome
+     */
+    batchWorkerSuccess(outcome: BatchWorkerOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * TAS-125: Yield checkpoint for batch processing.
+     *
+     * Use this method when your handler needs to persist progress and be
+     * re-dispatched for continued processing. This is useful for:
+     * - Processing very large datasets that exceed memory limits
+     * - Providing progress visibility for long-running batch jobs
+     * - Enabling graceful shutdown with resumption capability
+     *
+     * Unlike batchWorkerSuccess, this does NOT complete the step.
+     * Instead, it persists the checkpoint and causes the step to be
+     * re-dispatched with the updated checkpoint context.
+     *
+     * @param cursor - Position to resume from
+     *   - number: For offset-based pagination (row number)
+     *   - string: For cursor-based pagination (opaque token)
+     *   - object: For complex cursors (e.g., {page_token: "..."})
+     * @param itemsProcessed - Total items processed so far (cumulative across all yields)
+     * @param accumulatedResults - Partial aggregations to carry forward
+     * @returns A StepHandlerResult with checkpoint_yield type
+     *
+     * @example
+     * ```typescript
+     * async call(context: StepContext): Promise<StepHandlerResult> {
+     *   const batchCtx = this.getBatchContext(context);
+     *   const start = batchCtx?.checkpointCursor ?? batchCtx?.startCursor ?? 0;
+     *   const accumulated = batchCtx?.accumulatedResults ?? { total: 0 };
+     *
+     *   // Process a chunk
+     *   const chunkSize = 1000;
+     *   for (let i = 0; i < chunkSize && start + i < batchCtx.endCursor; i++) {
+     *     accumulated.total += await processItem(start + i);
+     *   }
+     *
+     *   const newCursor = start + chunkSize;
+     *   if (newCursor < batchCtx.endCursor) {
+     *     // More work to do - yield checkpoint
+     *     return this.checkpointYield(newCursor, newCursor, accumulated);
+     *   }
+     *
+     *   // Done - return final success
+     *   return this.batchWorkerSuccess(
+     *     this.createWorkerOutcome(batchCtx.endCursor - batchCtx.startCursor)
+     *   );
+     * }
+     * ```
+     */
+    checkpointYield(cursor: number | string | Record<string, unknown>, itemsProcessed: number, accumulatedResults?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Detect batch aggregation scenario from dependency results.
+     *
+     * Cross-language standard: matches Ruby's detect_aggregation_scenario,
+     * Python's detect_aggregation_scenario, and Rust's BatchAggregationScenario::detect.
+     *
+     * @param dependencyResults - All dependency results from the step context.
+     * @param batchableStepName - Name of the batchable step (e.g., "analyze_csv").
+     * @param batchWorkerPrefix - Prefix for batch worker step names (e.g., "process_csv_batch_").
+     * @returns BatchAggregationScenario indicating NoBatches or WithBatches.
+     *
+     * @example
+     * ```typescript
+     * const scenario = this.detectAggregationScenario(
+     *   context.dependencyResults,
+     *   'analyze_csv',
+     *   'process_csv_batch_'
+     * );
+     * if (scenario.isNoBatches) {
+     *   return this.noBatchesAggregationResult({ total: 0 });
+     * }
+     * ```
+     */
+    detectAggregationScenario(dependencyResults: Record<string, unknown>, batchableStepName: string, batchWorkerPrefix: string): BatchAggregationScenario;
+    /**
+     * Create a success result for NoBatches aggregation scenario.
+     *
+     * Cross-language standard: matches Ruby's no_batches_aggregation_result
+     * and Python's no_batches_aggregation_result.
+     *
+     * @param zeroMetrics - Metrics to return (typically zeros).
+     * @returns Success result with workerCount=0 and scenario="no_batches".
+     *
+     * @example
+     * ```typescript
+     * return this.noBatchesAggregationResult({
+     *   totalProcessed: 0,
+     *   totalValue: 0.0,
+     * });
+     * ```
+     */
+    noBatchesAggregationResult(zeroMetrics?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Aggregate batch worker results handling both scenarios.
+     *
+     * Cross-language standard: matches Ruby's aggregate_batch_worker_results
+     * and Python's aggregate_batch_worker_results.
+     * Handles both NoBatches and WithBatches scenarios automatically.
+     *
+     * For NoBatches, returns zeroMetrics with worker_count=0.
+     * For WithBatches, calls aggregationFn with batchResults dict.
+     *
+     * @param scenario - BatchAggregationScenario from detectAggregationScenario().
+     * @param zeroMetrics - Metrics to return for NoBatches scenario.
+     * @param aggregationFn - Function to aggregate batch results. Receives dict of
+     *   worker_name -> result_dict, returns aggregated metrics dict.
+     * @returns Success result with aggregated data and worker_count.
+     *
+     * @example
+     * ```typescript
+     * const scenario = this.detectAggregationScenario(
+     *   context.dependencyResults,
+     *   'analyze_csv',
+     *   'process_csv_batch_'
+     * );
+     *
+     * return this.aggregateBatchWorkerResults(
+     *   scenario,
+     *   { totalProcessed: 0 },
+     *   (batchResults) => {
+     *     let total = 0;
+     *     for (const result of Object.values(batchResults)) {
+     *       total += (result.count as number) || 0;
+     *     }
+     *     return { totalProcessed: total };
+     *   }
+     * );
+     * ```
+     */
+    aggregateBatchWorkerResults(scenario: BatchAggregationScenario, zeroMetrics?: Record<string, unknown>, aggregationFn?: (batchResults: Record<string, Record<string, unknown>>) => Record<string, unknown>): StepHandlerResult;
+    /**
+     * Aggregate results from multiple batch workers.
+     *
+     * Delegates to `aggregateBatchResults` from types/batch.ts (TAS-112/TAS-123).
+     * Cross-language standard: matches Python's aggregate_batch_results.
+     *
+     * @param workerResults - Array of results from batch worker steps
+     * @param maxErrors - Maximum number of errors to collect (default: 100)
+     * @returns Aggregated summary of all batch processing
+     *
+     * @example
+     * ```typescript
+     * // In an aggregator handler
+     * const workerResults = context.getAllDependencyResults('process_batch_');
+     * const summary = BatchableMixin.aggregateWorkerResults(workerResults);
+     * return this.success(summary);
+     * ```
+     */
+    static aggregateWorkerResults(workerResults: Array<Record<string, unknown> | null>, maxErrors?: number): BatchAggregationResult;
+}
+/**
+ * Helper function to apply Batchable methods to a handler class.
+ *
+ * This is a convenience for applying all Batchable methods at once.
+ *
+ * @example
+ * ```typescript
+ * class MyBatchHandler extends StepHandler {
+ *   constructor() {
+ *     super();
+ *     applyBatchable(this);
+ *   }
+ * }
+ * ```
+ */
+declare function applyBatchable<T extends object>(target: T): T & Batchable;
+
+/**
+ * Decision mixin for workflow routing.
+ *
+ * TAS-112: Composition Pattern - Decision Mixin
+ *
+ * This module provides the DecisionMixin class for step handlers that make
+ * routing decisions. Use via interface implementation with method binding.
+ *
+ * @example
+ * ```typescript
+ * class RouteOrderHandler extends StepHandler implements DecisionCapable {
+ *   static handlerName = 'route_order';
+ *
+ *   // Bind DecisionMixin methods
+ *   decisionSuccess = DecisionMixin.prototype.decisionSuccess.bind(this);
+ *   skipBranches = DecisionMixin.prototype.skipBranches.bind(this);
+ *   // ... other required methods
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const orderType = context.inputData['order_type'];
+ *     if (orderType === 'premium') {
+ *       return this.decisionSuccess(
+ *         ['validate_premium', 'process_premium'],
+ *         { order_type: orderType }
+ *       );
+ *     }
+ *     return this.decisionSuccess(['process_standard']);
+ *   }
+ * }
+ * ```
+ *
+ * @module handler/mixins/decision
+ */
+
+/**
+ * Type of decision point outcome.
+ */
+declare enum DecisionType {
+    CREATE_STEPS = "create_steps",
+    NO_BRANCHES = "no_branches"
+}
+/**
+ * Outcome from a decision point handler.
+ *
+ * Decision handlers return this to indicate which branch(es) of a workflow
+ * to execute.
+ */
+interface DecisionPointOutcome {
+    /** Type of decision made */
+    decisionType: DecisionType;
+    /** Names of steps to execute next */
+    nextStepNames: string[];
+    /** Optional dynamically created steps */
+    dynamicSteps?: Array<Record<string, unknown>>;
+    /** Human-readable reason for the decision */
+    reason?: string;
+    /** Context data for routing */
+    routingContext: Record<string, unknown>;
+}
+/**
+ * Interface for decision-capable handlers.
+ *
+ * Implement this interface and bind DecisionMixin methods to get decision functionality.
+ */
+interface DecisionCapable {
+    /** Handler name (from StepHandler) */
+    name: string;
+    /** Handler version (from StepHandler) */
+    version: string;
+    decisionSuccess(steps: string[], routingContext?: Record<string, unknown>, metadata?: Record<string, unknown>): StepHandlerResult;
+    decisionSuccessWithOutcome(outcome: DecisionPointOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    decisionNoBranches(outcome: DecisionPointOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    skipBranches(reason: string, routingContext?: Record<string, unknown>, metadata?: Record<string, unknown>): StepHandlerResult;
+    decisionFailure(message: string, errorType?: string, retryable?: boolean, metadata?: Record<string, unknown>): StepHandlerResult;
+}
+/**
+ * Implementation of decision methods.
+ *
+ * TAS-112: Use via interface implementation with method binding.
+ *
+ * Decision handlers are used to make routing decisions in workflows.
+ * They evaluate conditions and determine which steps should execute next.
+ */
+declare class DecisionMixin implements DecisionCapable {
+    get name(): string;
+    get version(): string;
+    /**
+     * Simplified decision success helper (cross-language standard API).
+     *
+     * Use this when routing to one or more steps based on a decision.
+     * This is the recommended method for most decision handlers.
+     *
+     * @param steps - List of step names to activate
+     * @param routingContext - Optional context for routing decisions
+     * @param metadata - Optional additional metadata
+     * @returns A success StepHandlerResult with the decision outcome
+     */
+    decisionSuccess(steps: string[], routingContext?: Record<string, unknown>, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a success result with a DecisionPointOutcome.
+     *
+     * Use this for complex decision outcomes that require dynamic steps
+     * or advanced routing. For simple step routing, use `decisionSuccess()`.
+     */
+    decisionSuccessWithOutcome(outcome: DecisionPointOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a success result for a decision with no branches.
+     *
+     * Use this when the decision results in no additional steps being executed.
+     * This is still a successful outcome - the decision was made correctly,
+     * it just doesn't require any follow-up steps.
+     */
+    decisionNoBranches(outcome: DecisionPointOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Convenience method to skip all branches.
+     *
+     * @param reason - Human-readable reason for skipping branches
+     * @param routingContext - Optional context data
+     * @param metadata - Optional additional metadata
+     * @returns A success StepHandlerResult indicating no branches
+     */
+    skipBranches(reason: string, routingContext?: Record<string, unknown>, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a failure result for a decision that could not be made.
+     *
+     * Use this when the handler cannot determine the appropriate routing,
+     * typically due to invalid input data or missing required information.
+     *
+     * Decision failures are usually NOT retryable.
+     */
+    decisionFailure(message: string, errorType?: string, retryable?: boolean, metadata?: Record<string, unknown>): StepHandlerResult;
+}
+/**
+ * Helper function to apply decision methods to a handler instance.
+ *
+ * @example
+ * ```typescript
+ * class MyDecisionHandler extends StepHandler {
+ *   constructor() {
+ *     super();
+ *     applyDecision(this);
+ *   }
+ * }
+ * ```
+ */
+declare function applyDecision<T extends {
+    name: string;
+    version: string;
+}>(target: T): T & DecisionCapable;
+
+/**
+ * Decision handler for workflow routing.
+ *
+ * TAS-112: Composition Pattern (DEPRECATED CLASS)
+ *
+ * This module provides the DecisionHandler class for backward compatibility.
+ * For new code, use the mixin pattern:
+ *
+ * @example Using DecisionMixin
+ * ```typescript
+ * import { StepHandler } from './base';
+ * import { DecisionMixin, DecisionCapable, applyDecision } from './mixins/decision';
+ *
+ * class RouteOrderHandler extends StepHandler implements DecisionCapable {
+ *   static handlerName = 'route_order';
+ *
+ *   constructor() {
+ *     super();
+ *     applyDecision(this);
+ *   }
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const orderType = context.inputData['order_type'];
+ *     if (orderType === 'premium') {
+ *       return this.decisionSuccess(
+ *         ['validate_premium', 'process_premium'],
+ *         { order_type: orderType }
+ *       );
+ *     }
+ *     return this.decisionSuccess(['process_standard']);
+ *   }
+ * }
+ * ```
+ *
+ * @module handler/decision
+ */
+
+/**
+ * Base class for decision point step handlers.
+ *
+ * TAS-112: This class is provided for backward compatibility.
+ * For new code, prefer using DecisionMixin directly with applyDecision().
+ *
+ * Decision handlers are used to make routing decisions in workflows.
+ * They evaluate conditions and determine which steps should execute next.
+ *
+ * @example
+ * ```typescript
+ * class CustomerTierRouter extends DecisionHandler {
+ *   static handlerName = 'route_by_tier';
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     const tier = context.inputData['customer_tier'];
+ *     if (tier === 'enterprise') {
+ *       return this.decisionSuccess(
+ *         ['enterprise_validation', 'enterprise_processing'],
+ *         { tier }
+ *       );
+ *     } else if (tier === 'premium') {
+ *       return this.decisionSuccess(['premium_processing']);
+ *     } else {
+ *       return this.decisionSuccess(['standard_processing']);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare abstract class DecisionHandler extends StepHandler {
+    private readonly _decisionMixin;
+    get capabilities(): string[];
+    /**
+     * Simplified decision success helper (cross-language standard API).
+     *
+     * Use this when routing to one or more steps based on a decision.
+     * This is the recommended method for most decision handlers.
+     */
+    protected decisionSuccess(steps: string[], routingContext?: Record<string, unknown>, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a success result with a DecisionPointOutcome.
+     *
+     * Use this for complex decision outcomes that require dynamic steps
+     * or advanced routing. For simple step routing, use `decisionSuccess()`.
+     */
+    protected decisionSuccessWithOutcome(outcome: DecisionPointOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a success result for a decision with no branches.
+     *
+     * Use this when the decision results in no additional steps being executed.
+     */
+    protected decisionNoBranches(outcome: DecisionPointOutcome, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Convenience method to skip all branches.
+     */
+    protected skipBranches(reason: string, routingContext?: Record<string, unknown>, metadata?: Record<string, unknown>): StepHandlerResult;
+    /**
+     * Create a failure result for a decision that could not be made.
+     */
+    protected decisionFailure(message: string, errorType?: string, retryable?: boolean, metadata?: Record<string, unknown>): StepHandlerResult;
+}
+
+/**
+ * Domain Events Module for TypeScript Workers
+ *
+ * Provides infrastructure for custom domain event publishers and subscribers.
+ * Publishers transform step results into business events; subscribers handle
+ * fast (in-process) events for internal processing.
+ *
+ * Architecture: Handlers DON'T publish events directly. Events are declared
+ * in YAML templates, and Rust orchestration publishes them after step completion.
+ * Custom publishers only transform payloads. Subscribers only receive fast events.
+ *
+ * @module handler/domain-events
+ * @see docs/architecture/domain-events.md
+ * @see TAS-122, TAS-112 Phase 7
+ */
+
+/**
+ * Context passed to publishers for event transformation.
+ *
+ * Contains all information needed to build a business event payload.
+ */
+interface StepEventContext {
+    /** UUID of the task */
+    readonly taskUuid: string;
+    /** UUID of the step */
+    readonly stepUuid: string;
+    /** Name of the step handler */
+    readonly stepName: string;
+    /** Namespace (e.g., "payments", "inventory") */
+    readonly namespace: string;
+    /** Correlation ID for distributed tracing */
+    readonly correlationId: string;
+    /** Step result data (success payload or error info) */
+    readonly result?: Record<string, unknown>;
+    /** Execution metadata */
+    readonly metadata: Record<string, unknown>;
+}
+/**
+ * Event declaration from YAML task template.
+ */
+interface EventDeclaration {
+    /** Event name (e.g., "payment.processed") */
+    readonly name: string;
+    /** Publication condition: "success" | "failure" | "always" */
+    readonly condition?: 'success' | 'failure' | 'retryable_failure' | 'permanent_failure' | 'always';
+    /** Delivery mode: "durable" (PGMQ) | "fast" (in-process) | "broadcast" (both) */
+    readonly deliveryMode?: 'durable' | 'fast' | 'broadcast';
+    /** Custom publisher name (optional) */
+    readonly publisher?: string;
+    /** JSON schema for payload validation (optional) */
+    readonly schema?: Record<string, unknown>;
+}
+/**
+ * Step result passed to publishers.
+ */
+interface StepResult {
+    /** Whether the step succeeded */
+    readonly success: boolean;
+    /** Step handler's return value */
+    readonly result?: Record<string, unknown>;
+    /** Execution metadata */
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Domain event structure for subscribers.
+ *
+ * This is the shape of events received by BaseSubscriber.handle().
+ */
+interface DomainEvent {
+    /** Unique event ID (UUID v7) */
+    readonly eventId: string;
+    /** Event name (e.g., "payment.processed") */
+    readonly eventName: string;
+    /** Business payload from publisher transformation */
+    readonly payload: Record<string, unknown>;
+    /** Event metadata */
+    readonly metadata: DomainEventMetadata;
+    /** Original step execution result */
+    readonly executionResult: StepResult;
+}
+/**
+ * Metadata attached to every domain event.
+ */
+interface DomainEventMetadata {
+    /** Task UUID */
+    readonly taskUuid: string;
+    /** Step UUID */
+    readonly stepUuid: string;
+    /** Step name */
+    readonly stepName?: string;
+    /** Namespace */
+    readonly namespace: string;
+    /** Correlation ID for tracing */
+    readonly correlationId: string;
+    /** When the event was fired (ISO8601) */
+    readonly firedAt: string;
+    /** Publisher that created this event */
+    readonly publisher?: string;
+    /** Additional custom metadata */
+    readonly [key: string]: unknown;
+}
+/**
+ * Context passed to the publish() method.
+ *
+ * Cross-language standard API (TAS-96).
+ */
+interface PublishContext {
+    /** Event name */
+    readonly eventName: string;
+    /** Step result */
+    readonly stepResult: StepResult;
+    /** Event declaration from YAML */
+    readonly eventDeclaration?: EventDeclaration;
+    /** Step execution context */
+    readonly stepContext?: StepEventContext;
+}
+/**
+ * Abstract base class for custom domain event publishers.
+ *
+ * Publishers transform step execution results into business events.
+ * They are declared in YAML via the `publisher:` field and registered
+ * at bootstrap time.
+ *
+ * NOTE: Publishers don't call publish APIs directly. They transform data
+ * that Rust orchestration publishes.
+ *
+ * @example
+ * ```typescript
+ * class PaymentEventPublisher extends BasePublisher {
+ *   readonly publisherName = 'PaymentEventPublisher';
+ *
+ *   transformPayload(stepResult: StepResult, eventDecl?: EventDeclaration): Record<string, unknown> {
+ *     const result = stepResult.result ?? {};
+ *     return {
+ *       transactionId: result.transaction_id,
+ *       amount: result.amount,
+ *       currency: result.currency ?? 'USD',
+ *       status: stepResult.success ? 'succeeded' : 'failed',
+ *     };
+ *   }
+ *
+ *   shouldPublish(stepResult: StepResult): boolean {
+ *     return stepResult.success && stepResult.result?.transaction_id != null;
+ *   }
+ * }
+ * ```
+ */
+declare abstract class BasePublisher {
+    protected readonly logger: Logger;
+    /**
+     * Publisher name for registry lookup.
+     * Must match the `publisher:` field in YAML.
+     */
+    abstract readonly publisherName: string;
+    /**
+     * Transform step result into business event payload.
+     *
+     * Override to customize the event payload for your domain.
+     * Default returns the step result as-is.
+     *
+     * @param stepResult - The step execution result
+     * @param eventDeclaration - The event declaration from YAML
+     * @param stepContext - The step execution context
+     * @returns Business event payload to publish
+     */
+    transformPayload(stepResult: StepResult, _eventDeclaration?: EventDeclaration, _stepContext?: StepEventContext): Record<string, unknown>;
+    /**
+     * Determine if this event should be published.
+     *
+     * Override to add custom conditions beyond YAML's `condition:` field.
+     * The YAML condition is evaluated first by Rust orchestration.
+     *
+     * @param stepResult - The step execution result
+     * @param eventDeclaration - The event declaration from YAML
+     * @param stepContext - The step execution context
+     * @returns true if the event should be published
+     */
+    shouldPublish(_stepResult: StepResult, _eventDeclaration?: EventDeclaration, _stepContext?: StepEventContext): boolean;
+    /**
+     * Add additional metadata to the event.
+     *
+     * Override to add custom metadata fields.
+     *
+     * @param stepResult - The step execution result
+     * @param eventDeclaration - The event declaration from YAML
+     * @param stepContext - The step execution context
+     * @returns Additional metadata to merge into event metadata
+     */
+    additionalMetadata(_stepResult: StepResult, _eventDeclaration?: EventDeclaration, _stepContext?: StepEventContext): Record<string, unknown>;
+    /**
+     * Hook called before publishing.
+     *
+     * Override for pre-publish validation, logging, or metrics.
+     * Return false to prevent publishing.
+     *
+     * @param eventName - The event name
+     * @param payload - The transformed payload
+     * @param metadata - The event metadata
+     * @returns true to continue, false to skip publishing
+     */
+    beforePublish(eventName: string, _payload: Record<string, unknown>, _metadata: Record<string, unknown>): boolean;
+    /**
+     * Hook called after successful publishing.
+     *
+     * Override for post-publish logging, metrics, or cleanup.
+     *
+     * @param eventName - The event name
+     * @param payload - The transformed payload
+     * @param metadata - The event metadata
+     */
+    afterPublish(eventName: string, _payload: Record<string, unknown>, _metadata: Record<string, unknown>): void;
+    /**
+     * Hook called if publishing fails.
+     *
+     * Override for error handling, logging, or fallback behavior.
+     *
+     * @param eventName - The event name
+     * @param error - The error that occurred
+     * @param payload - The transformed payload
+     */
+    onPublishError(eventName: string, error: Error, _payload: Record<string, unknown>): void;
+    /**
+     * Cross-language standard: Publish an event with unified context.
+     *
+     * Coordinates the lifecycle hooks into a single publish call.
+     *
+     * @param ctx - Publish context containing all required data
+     * @returns true if event was published, false if skipped
+     */
+    publish(ctx: PublishContext): boolean;
+}
+/**
+ * Default publisher that passes step result through unchanged.
+ */
+declare class DefaultPublisher extends BasePublisher {
+    readonly publisherName = "default";
+    transformPayload(stepResult: StepResult): Record<string, unknown>;
+}
+/**
+ * Static interface for subscriber classes (for type checking).
+ */
+interface SubscriberClass {
+    /** Patterns to subscribe to */
+    subscribesTo(): string[];
+    /** Constructor */
+    new (): BaseSubscriber;
+}
+/**
+ * Abstract base class for domain event subscribers.
+ *
+ * Subscribers handle fast (in-process) domain events for internal processing.
+ * They subscribe to event patterns and receive events via the InProcessEventBus.
+ *
+ * @example
+ * ```typescript
+ * class MetricsSubscriber extends BaseSubscriber {
+ *   static subscribesTo(): string[] {
+ *     return ['*']; // All events
+ *   }
+ *
+ *   handle(event: DomainEvent): void {
+ *     metrics.increment(`domain_events.${event.eventName.replace('.', '_')}`);
+ *   }
+ * }
+ *
+ * class PaymentSubscriber extends BaseSubscriber {
+ *   static subscribesTo(): string[] {
+ *     return ['payment.*']; // Only payment events
+ *   }
+ *
+ *   handle(event: DomainEvent): void {
+ *     if (event.eventName === 'payment.processed') {
+ *       notifyAccounting(event.payload);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare abstract class BaseSubscriber {
+    protected readonly logger: Logger;
+    private _active;
+    private _subscriptions;
+    /**
+     * Event patterns to subscribe to.
+     *
+     * Override this static method to declare patterns.
+     * Supports wildcards: "*" matches all, "payment.*" matches payment.processed, etc.
+     *
+     * @returns Array of event patterns
+     */
+    static subscribesTo(): string[];
+    /**
+     * Check if the subscriber is active.
+     */
+    get active(): boolean;
+    /**
+     * Get subscribed patterns.
+     */
+    get subscriptions(): readonly string[];
+    /**
+     * Handle a domain event.
+     *
+     * Subclasses MUST implement this method.
+     *
+     * @param event - The domain event to handle
+     */
+    abstract handle(event: DomainEvent): void | Promise<void>;
+    /**
+     * Hook called before handling an event.
+     *
+     * Override for pre-processing, validation, or filtering.
+     * Return false to skip handling this event.
+     *
+     * @param event - The domain event
+     * @returns true to continue handling, false to skip
+     */
+    beforeHandle(_event: DomainEvent): boolean;
+    /**
+     * Hook called after successful handling.
+     *
+     * Override for post-processing, metrics, or cleanup.
+     *
+     * @param event - The domain event
+     */
+    afterHandle(_event: DomainEvent): void;
+    /**
+     * Hook called if handling fails.
+     *
+     * Override for custom error handling, alerts, or retry logic.
+     * Note: Domain events use fire-and-forget semantics.
+     *
+     * @param event - The domain event
+     * @param error - The error that occurred
+     */
+    onHandleError(event: DomainEvent, error: Error): void;
+    /**
+     * Check if this subscriber matches an event name.
+     *
+     * Supports wildcard patterns:
+     * - "*" matches everything
+     * - "payment.*" matches "payment.processed", "payment.failed"
+     * - "order.created" matches exactly "order.created"
+     *
+     * @param eventName - The event name to check
+     * @returns true if this subscriber should handle the event
+     */
+    matches(eventName: string): boolean;
+    /**
+     * Start listening for events.
+     *
+     * Registers with the InProcessDomainEventPoller.
+     *
+     * @param poller - The event poller to register with
+     */
+    start(poller: InProcessDomainEventPoller): void;
+    /**
+     * Stop listening for events.
+     */
+    stop(): void;
+    /**
+     * Safely handle an event with error capture.
+     */
+    private handleEventSafely;
+}
+/**
+ * Error thrown when a required publisher is not registered.
+ */
+declare class PublisherNotFoundError extends Error {
+    readonly publisherName: string;
+    readonly registeredPublishers: string[];
+    constructor(name: string, registered: string[]);
+}
+/**
+ * Error thrown when required publishers are missing during validation.
+ */
+declare class PublisherValidationError extends Error {
+    readonly missingPublishers: string[];
+    readonly registeredPublishers: string[];
+    constructor(missing: string[], registered: string[]);
+}
+/**
+ * Error thrown when modifying a frozen registry.
+ */
+declare class RegistryFrozenError extends Error {
+    constructor();
+}
+/**
+ * Error thrown when registering a duplicate publisher.
+ */
+declare class DuplicatePublisherError extends Error {
+    readonly publisherName: string;
+    constructor(name: string);
+}
+/**
+ * Registry for custom domain event publishers.
+ *
+ * Maps publisher names (from YAML configuration) to their implementations.
+ * Publishers are registered at bootstrap time and validated against task templates.
+ *
+ * @example
+ * ```typescript
+ * const registry = PublisherRegistry.instance;
+ *
+ * // Register custom publishers
+ * registry.register(new PaymentEventPublisher());
+ * registry.register(new InventoryEventPublisher());
+ *
+ * // Validate against templates
+ * registry.validateRequired(['PaymentEventPublisher', 'InventoryEventPublisher']);
+ *
+ * // Look up publishers
+ * const publisher = registry.get('PaymentEventPublisher');
+ * ```
+ */
+declare class PublisherRegistry {
+    private static _instance;
+    private readonly publishers;
+    private readonly defaultPublisher;
+    private frozen;
+    private readonly logger;
+    private constructor();
+    /**
+     * Get the singleton instance.
+     */
+    static get instance(): PublisherRegistry;
+    /**
+     * Register a custom publisher.
+     *
+     * @param publisher - The publisher instance to register
+     * @throws RegistryFrozenError if registry is frozen
+     * @throws DuplicatePublisherError if name is already registered
+     */
+    register(publisher: BasePublisher): void;
+    /**
+     * Get a publisher by name.
+     *
+     * @param name - The publisher name
+     * @returns The publisher, or undefined if not found
+     */
+    get(name: string): BasePublisher | undefined;
+    /**
+     * Get a publisher by name, or return the default.
+     *
+     * @param name - The publisher name (optional)
+     * @returns The publisher or default
+     */
+    getOrDefault(name?: string): BasePublisher;
+    /**
+     * Get a publisher by name (strict mode).
+     *
+     * @param name - The publisher name
+     * @returns The publisher
+     * @throws PublisherNotFoundError if not registered
+     */
+    getStrict(name: string): BasePublisher;
+    /**
+     * Check if a publisher is registered.
+     */
+    isRegistered(name: string): boolean;
+    /**
+     * Get all registered publisher names.
+     */
+    get registeredNames(): string[];
+    /**
+     * Get count of registered publishers.
+     */
+    get count(): number;
+    /**
+     * Check if registry is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if registry is frozen.
+     */
+    get isFrozen(): boolean;
+    /**
+     * Unregister a publisher.
+     *
+     * @throws RegistryFrozenError if registry is frozen
+     */
+    unregister(name: string): boolean;
+    /**
+     * Clear all registered publishers.
+     *
+     * @throws RegistryFrozenError if registry is frozen
+     */
+    clear(): void;
+    /**
+     * Validate that all required publishers are registered.
+     *
+     * After validation, the registry is frozen.
+     *
+     * @param requiredPublishers - Publisher names from YAML configs
+     * @throws PublisherValidationError if some publishers are missing
+     */
+    validateRequired(requiredPublishers: string[]): void;
+    /**
+     * Freeze the registry to prevent further changes.
+     */
+    freeze(): void;
+    /**
+     * Reset the registry (for testing).
+     */
+    reset(): void;
+}
+/**
+ * Subscriber statistics.
+ */
+interface SubscriberStats {
+    /** Whether subscribers have been started */
+    readonly started: boolean;
+    /** Total subscriber count */
+    readonly subscriberCount: number;
+    /** Number of active subscribers */
+    readonly activeCount: number;
+    /** Individual subscriber info */
+    readonly subscribers: ReadonlyArray<{
+        readonly className: string;
+        readonly active: boolean;
+        readonly patterns: readonly string[];
+    }>;
+}
+/**
+ * Registry for domain event subscribers.
+ *
+ * Manages the lifecycle of subscribers. Subscribers are registered at bootstrap
+ * time and started/stopped together with the worker.
+ *
+ * @example
+ * ```typescript
+ * const registry = SubscriberRegistry.instance;
+ *
+ * // Register subscriber classes (instantiation deferred)
+ * registry.register(PaymentSubscriber);
+ * registry.register(MetricsSubscriber);
+ *
+ * // Start all subscribers with the poller
+ * registry.startAll(poller);
+ *
+ * // Stop all when shutting down
+ * registry.stopAll();
+ * ```
+ */
+declare class SubscriberRegistry {
+    private static _instance;
+    private readonly subscriberClasses;
+    private readonly subscribers;
+    private started;
+    private readonly logger;
+    private constructor();
+    /**
+     * Get the singleton instance.
+     */
+    static get instance(): SubscriberRegistry;
+    /**
+     * Register a subscriber class.
+     *
+     * The class will be instantiated when startAll() is called.
+     *
+     * @param subscriberClass - A subclass of BaseSubscriber
+     */
+    register(subscriberClass: SubscriberClass): void;
+    /**
+     * Register a subscriber instance directly.
+     *
+     * Use this when your subscriber needs custom initialization.
+     *
+     * @param subscriber - A subscriber instance
+     */
+    registerInstance(subscriber: BaseSubscriber): void;
+    /**
+     * Start all registered subscribers.
+     *
+     * @param poller - The event poller to register subscribers with
+     */
+    startAll(poller: InProcessDomainEventPoller): void;
+    /**
+     * Stop all subscribers.
+     */
+    stopAll(): void;
+    /**
+     * Check if subscribers have been started.
+     */
+    get isStarted(): boolean;
+    /**
+     * Get count of registered subscribers (classes + instances).
+     */
+    get count(): number;
+    /**
+     * Get subscriber statistics.
+     */
+    get stats(): SubscriberStats;
+    /**
+     * Reset the registry (for testing).
+     */
+    reset(): void;
+}
+/**
+ * Callback type for domain event handlers.
+ */
+type DomainEventCallback = (event: DomainEvent) => void | Promise<void>;
+/**
+ * Error callback type for domain event processing.
+ */
+type DomainEventErrorCallback = (error: Error) => void;
+/**
+ * Poller statistics.
+ */
+interface PollerStats {
+    /** Total poll cycles */
+    readonly pollCount: number;
+    /** Total events processed */
+    readonly eventsProcessed: number;
+    /** Events that lagged (couldn't keep up) */
+    readonly eventsLagged: number;
+    /** Whether the poller is running */
+    readonly running: boolean;
+}
+/**
+ * Poller configuration.
+ */
+interface DomainEventPollerConfig {
+    /** Polling interval in milliseconds (default: 10) */
+    readonly pollIntervalMs?: number;
+    /** Maximum events per poll cycle (default: 100) */
+    readonly maxEventsPerPoll?: number;
+}
+/**
+ * In-process domain event poller.
+ *
+ * Polls for fast domain events from the Rust broadcast channel and
+ * dispatches them to registered subscribers.
+ *
+ * Threading Model:
+ * - Main Thread: TypeScript application, event handlers
+ * - Poll Loop: Async timer-based polling
+ * - Rust: Rust worker runtime (separate from TypeScript)
+ *
+ * @example
+ * ```typescript
+ * const poller = new InProcessDomainEventPoller({
+ *   pollIntervalMs: 10,
+ *   maxEventsPerPoll: 100,
+ * });
+ *
+ * // Subscribe to patterns
+ * poller.subscribe('payment.*', (event) => {
+ *   console.log('Payment event:', event.eventName);
+ * });
+ *
+ * // Start polling
+ * poller.start();
+ *
+ * // Stop when done
+ * poller.stop();
+ * ```
+ */
+declare class InProcessDomainEventPoller {
+    private readonly pollIntervalMs;
+    private readonly maxEventsPerPoll;
+    private running;
+    private pollTimer;
+    private readonly logger;
+    private readonly subscriptions;
+    private readonly errorCallbacks;
+    private pollCount;
+    private eventsProcessed;
+    private eventsLagged;
+    private pollFn;
+    constructor(config?: DomainEventPollerConfig);
+    /**
+     * Set the FFI poll function.
+     *
+     * This must be called before start() to enable actual polling.
+     * Without it, the poller runs in "dry" mode (for testing).
+     *
+     * @param pollFn - Function that polls for events from Rust
+     */
+    setPollFunction(pollFn: () => DomainEvent | null): void;
+    /**
+     * Subscribe to events matching a pattern.
+     *
+     * @param pattern - Event pattern (e.g., "*", "payment.*")
+     * @param callback - Function to call when events match
+     */
+    subscribe(pattern: string, callback: DomainEventCallback): void;
+    /**
+     * Unsubscribe from a pattern.
+     *
+     * @param pattern - The pattern to unsubscribe from
+     */
+    unsubscribe(pattern: string): void;
+    /**
+     * Register an error callback.
+     */
+    onError(callback: DomainEventErrorCallback): void;
+    /**
+     * Start the polling loop.
+     */
+    start(): void;
+    /**
+     * Stop the polling loop.
+     */
+    stop(): void;
+    /**
+     * Check if the poller is running.
+     */
+    get isRunning(): boolean;
+    /**
+     * Get poller statistics.
+     */
+    get stats(): PollerStats;
+    /**
+     * Schedule the next poll cycle.
+     */
+    private schedulePoll;
+    /**
+     * Execute a poll cycle.
+     */
+    private pollCycle;
+    /**
+     * Dispatch an event to matching subscribers.
+     */
+    private dispatchEvent;
+    /**
+     * Check if an event name matches a pattern.
+     */
+    private matchesPattern;
+    /**
+     * Emit an error to registered callbacks.
+     */
+    private emitError;
+}
+/**
+ * Create a StepEventContext from step data.
+ *
+ * @param data - Raw step context data
+ * @returns StepEventContext
+ */
+declare function createStepEventContext(data: {
+    taskUuid: string;
+    stepUuid: string;
+    stepName: string;
+    namespace?: string;
+    correlationId?: string;
+    result?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}): StepEventContext;
+/**
+ * Create a DomainEvent from raw data.
+ *
+ * @param data - Raw event data
+ * @returns DomainEvent
+ */
+declare function createDomainEvent(data: {
+    eventId: string;
+    eventName: string;
+    payload: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    executionResult: StepResult;
+}): DomainEvent;
+/**
+ * Transform an FfiDomainEvent to a DomainEvent.
+ *
+ * The FFI domain event has a simpler structure than the full DomainEvent.
+ * This function converts between them, synthesizing missing fields.
+ *
+ * @param ffiEvent - Event from FFI poll_in_process_events
+ * @returns DomainEvent suitable for subscribers
+ */
+declare function ffiEventToDomainEvent(ffiEvent: FfiDomainEvent): DomainEvent;
+/**
+ * Create an FFI poll function adapter for InProcessDomainEventPoller.
+ *
+ * This function wraps the runtime's pollInProcessEvents() to return
+ * DomainEvent objects that the poller expects.
+ *
+ * @param runtime - The FFI runtime instance
+ * @returns A poll function that returns DomainEvent | null
+ *
+ * @example
+ * ```typescript
+ * const poller = new InProcessDomainEventPoller();
+ * poller.setPollFunction(createFfiPollAdapter(runtime));
+ * poller.start();
+ * ```
+ */
+declare function createFfiPollAdapter(runtime: TaskerRuntime): () => DomainEvent | null;
+
+/**
+ * TAS-93: Handler definition type for resolver chain.
+ *
+ * Represents the configuration for a step handler, including:
+ * - callable: The handler address/identifier
+ * - method: Optional method to invoke (defaults to "call")
+ * - resolver: Optional resolver hint to bypass chain
+ * - initialization: Optional configuration passed to handler
+ *
+ * @example
+ * ```typescript
+ * const definition: HandlerDefinition = {
+ *   callable: 'payment_handler',
+ *   method: 'refund',
+ *   resolver: 'explicit_mapping',
+ *   initialization: { apiKey: 'secret' },
+ * };
+ *
+ * // Check if method dispatch is needed
+ * if (usesMethodDispatch(definition)) {
+ *   // Wrap handler for method dispatch
+ * }
+ * ```
+ */
+
+/**
+ * Handler definition with resolution metadata.
+ */
+interface HandlerDefinition {
+    /** The handler address/identifier (required) */
+    callable: string;
+    /** Method to invoke on the handler (defaults to "call") */
+    method?: string | null;
+    /** Resolver hint to bypass chain resolution */
+    resolver?: string | null;
+    /** Initialization configuration passed to handler */
+    initialization?: Record<string, unknown>;
+}
+/**
+ * Get the effective method to invoke.
+ *
+ * @param definition - Handler definition
+ * @returns The method name (defaults to "call")
+ */
+declare function effectiveMethod(definition: HandlerDefinition): string;
+/**
+ * Check if method dispatch is needed.
+ *
+ * Returns true if a non-default method is specified.
+ *
+ * @param definition - Handler definition
+ * @returns True if method dispatch wrapper is needed
+ */
+declare function usesMethodDispatch(definition: HandlerDefinition): boolean;
+/**
+ * Check if a resolver hint is provided.
+ *
+ * @param definition - Handler definition
+ * @returns True if resolver hint should be used
+ */
+declare function hasResolverHint(definition: HandlerDefinition): boolean;
+/**
+ * Create a HandlerDefinition from a callable string.
+ *
+ * @param callable - Handler callable string
+ * @returns HandlerDefinition with defaults
+ */
+declare function fromCallable(callable: string): HandlerDefinition;
+/**
+ * Create a HandlerDefinition from FFI DTO.
+ *
+ * Maps Rust field names to TypeScript:
+ * - Rust uses 'method' field (matches our interface)
+ *
+ * @param dto - FFI handler definition DTO
+ * @returns HandlerDefinition
+ */
+declare function fromDto(dto: HandlerDefinitionDto | null | undefined): HandlerDefinition;
+/**
+ * Type alias for handler specification input.
+ *
+ * Accepts:
+ * - string: Simple callable name
+ * - HandlerDefinition: Full definition with method/resolver
+ * - HandlerDefinitionDto: FFI DTO from Rust
+ */
+type HandlerSpec = string | HandlerDefinition | HandlerDefinitionDto;
+/**
+ * Normalize any handler spec to HandlerDefinition.
+ *
+ * @param spec - Handler specification (string, definition, or DTO)
+ * @returns Normalized HandlerDefinition
+ */
+declare function normalizeToDefinition(spec: HandlerSpec): HandlerDefinition;
+
+/**
+ * TAS-93: Base resolver interface for step handler resolution.
+ *
+ * Defines the contract that all resolvers must implement.
+ * Resolvers are ordered by priority (lower = checked first).
+ *
+ * @example
+ * ```typescript
+ * class MyResolver implements BaseResolver {
+ *   readonly name = 'my_resolver';
+ *   readonly priority = 50;
+ *
+ *   canResolve(definition: HandlerDefinition): boolean {
+ *     return definition.callable.startsWith('my:');
+ *   }
+ *
+ *   async resolve(definition: HandlerDefinition): Promise<StepHandler | null> {
+ *     if (!this.canResolve(definition)) return null;
+ *     return new MyHandler();
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Configuration passed to resolvers during resolution.
+ */
+interface ResolverConfig {
+    /** Additional context for resolution */
+    [key: string]: unknown;
+}
+/**
+ * Base interface for step handler resolvers.
+ *
+ * Resolvers are responsible for finding and instantiating handlers
+ * based on their callable format. Multiple resolvers form a chain,
+ * ordered by priority.
+ */
+interface BaseResolver {
+    /**
+     * Unique name for this resolver.
+     * Used for resolver hints and debugging.
+     */
+    readonly name: string;
+    /**
+     * Priority in the resolver chain.
+     * Lower values are checked first.
+     *
+     * Suggested ranges:
+     * - 1-20: Explicit mappings (highest priority)
+     * - 21-50: Custom domain resolvers
+     * - 51-99: Pattern-based resolvers
+     * - 100+: Inferential resolvers (lowest priority)
+     */
+    readonly priority: number;
+    /**
+     * Check if this resolver can handle the given definition.
+     *
+     * This is a quick check without actually resolving.
+     * Used to determine if resolve() should be called.
+     *
+     * @param definition - Handler definition to check
+     * @param config - Optional resolver configuration
+     * @returns True if this resolver can attempt resolution
+     */
+    canResolve(definition: HandlerDefinition, config?: ResolverConfig): boolean;
+    /**
+     * Resolve a handler from the definition.
+     *
+     * Should return null if resolution fails (allows chain to continue).
+     * Should throw only for unrecoverable errors.
+     *
+     * @param definition - Handler definition to resolve
+     * @param config - Optional resolver configuration
+     * @returns Handler instance or null if not found
+     */
+    resolve(definition: HandlerDefinition, config?: ResolverConfig): Promise<StepHandler | null>;
+}
+
+/**
+ * TAS-93: Error types for resolver chain.
+ */
+/**
+ * Base error class for resolution errors.
+ */
+declare class ResolutionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a specified resolver is not found.
+ */
+declare class ResolverNotFoundError extends ResolutionError {
+    readonly resolverName: string;
+    constructor(resolverName: string);
+}
+/**
+ * Error thrown when no resolver can handle a callable.
+ */
+declare class NoResolverMatchError extends ResolutionError {
+    readonly callable: string;
+    readonly triedResolvers: string[];
+    constructor(callable: string, triedResolvers: string[]);
+}
+/**
+ * Error thrown when method dispatch fails.
+ */
+declare class MethodDispatchError extends ResolutionError {
+    readonly handlerName: string;
+    readonly methodName: string;
+    constructor(handlerName: string, methodName: string);
+}
+
+/**
+ * TAS-93: Method dispatch wrapper for step handlers.
+ *
+ * Wraps a handler to redirect .call() invocations to a specified method.
+ * This enables the `handler_method` field to work transparently.
+ *
+ * @example
+ * ```typescript
+ * class PaymentHandler extends StepHandler {
+ *   static handlerName = 'payment_handler';
+ *
+ *   async call(context: StepContext): Promise<StepHandlerResult> {
+ *     return this.success({ action: 'default' });
+ *   }
+ *
+ *   async refund(context: StepContext): Promise<StepHandlerResult> {
+ *     return this.success({ action: 'refund' });
+ *   }
+ * }
+ *
+ * // Without wrapper: handler.call(ctx) returns { action: 'default' }
+ * // With wrapper:
+ * const wrapped = new MethodDispatchWrapper(handler, 'refund');
+ * await wrapped.call(ctx); // returns { action: 'refund' }
+ * ```
+ */
+
+/**
+ * Wrapper that redirects .call() to a specified method.
+ *
+ * Implements ExecutableHandler to be type-safe when used in place of
+ * a regular StepHandler. This avoids unsafe type casting while providing
+ * the same public interface.
+ */
+declare class MethodDispatchWrapper implements ExecutableHandler {
+    /** The wrapped handler instance */
+    readonly handler: StepHandler;
+    /** The method to invoke instead of call() */
+    readonly targetMethod: string;
+    /** The bound method function */
+    private readonly boundMethod;
+    /**
+     * Create a new method dispatch wrapper.
+     *
+     * @param handler - The handler to wrap
+     * @param targetMethod - The method name to invoke
+     * @throws MethodDispatchError if handler doesn't have the method
+     */
+    constructor(handler: StepHandler, targetMethod: string);
+    /**
+     * Get the handler name.
+     * Delegates to wrapped handler.
+     */
+    get name(): string;
+    /**
+     * Get the handler version.
+     * Delegates to wrapped handler.
+     */
+    get version(): string;
+    /**
+     * Get the handler capabilities.
+     * Delegates to wrapped handler.
+     */
+    get capabilities(): string[];
+    /**
+     * Execute the step by calling the target method.
+     *
+     * @param context - Step execution context
+     * @returns Handler result from the target method
+     */
+    call(context: StepContext): Promise<StepHandlerResult>;
+    /**
+     * Get config schema from wrapped handler.
+     */
+    configSchema(): Record<string, unknown> | null;
+    /**
+     * Get the unwrapped handler.
+     *
+     * Useful for testing and debugging.
+     *
+     * @returns The original handler instance
+     */
+    unwrap(): StepHandler;
+    /**
+     * String representation for debugging.
+     */
+    toString(): string;
+}
+
+/**
+ * TAS-93: Developer-friendly base class for custom resolvers.
+ *
+ * Provides pattern and prefix matching capabilities for implementing
+ * custom domain-specific resolvers.
+ *
+ * @example
+ * ```typescript
+ * class PaymentResolver extends RegistryResolver {
+ *   static readonly _name = 'payment_resolver';
+ *   static readonly _priority = 20;
+ *   static readonly pattern = /^payments:(?<provider>\w+):(?<action>\w+)$/;
+ *
+ *   async resolveHandler(
+ *     definition: HandlerDefinition,
+ *     match: RegExpMatchArray | null
+ *   ): Promise<StepHandler | null> {
+ *     if (!match?.groups) return null;
+ *
+ *     const { provider, action } = match.groups;
+ *     return PaymentHandlers.get(provider, action);
+ *   }
+ * }
+ *
+ * // Register with chain
+ * chain.addResolver(new PaymentResolver());
+ *
+ * // Resolves: { callable: 'payments:stripe:refund' }
+ * ```
+ */
+
+/**
+ * Static configuration for RegistryResolver subclasses.
+ */
+interface RegistryResolverStatic {
+    /** Resolver name (required) */
+    readonly _name: string;
+    /** Priority in chain (default: 50) */
+    readonly _priority?: number;
+    /** Regex pattern to match callables (optional) */
+    readonly pattern?: RegExp;
+    /** String prefix to match callables (optional) */
+    readonly prefix?: string;
+}
+/**
+ * Developer-friendly base class for custom resolvers.
+ *
+ * Subclasses should:
+ * 1. Set static `_name` and optionally `_priority`
+ * 2. Set static `pattern` or `prefix` for matching
+ * 3. Implement `resolveHandler()` for resolution logic
+ */
+declare abstract class RegistryResolver implements BaseResolver {
+    /**
+     * Get the resolver name from static property.
+     */
+    get name(): string;
+    /**
+     * Get the resolver priority from static property.
+     */
+    get priority(): number;
+    /**
+     * Check if this resolver can handle the definition.
+     *
+     * Uses pattern or prefix matching from static properties.
+     *
+     * @param definition - Handler definition
+     * @param _config - Unused, part of interface
+     * @returns True if callable matches
+     */
+    canResolve(definition: HandlerDefinition, _config?: ResolverConfig): boolean;
+    /**
+     * Resolve the handler.
+     *
+     * Delegates to resolveHandler() with pattern match if applicable.
+     *
+     * @param definition - Handler definition
+     * @param config - Resolver configuration
+     * @returns Handler instance or null
+     */
+    resolve(definition: HandlerDefinition, config?: ResolverConfig): Promise<StepHandler | null>;
+    /**
+     * Override this in subclasses for custom resolution logic.
+     *
+     * @param definition - Handler definition
+     * @param match - Regex match result (if pattern was used)
+     * @param config - Resolver configuration
+     * @returns Handler instance or null
+     */
+    abstract resolveHandler(definition: HandlerDefinition, match: RegExpMatchArray | null, config?: ResolverConfig): Promise<StepHandler | null>;
+}
+
+/**
+ * TAS-93: Resolver chain for step handler resolution.
+ *
+ * Orchestrates multiple resolvers in priority order to find handlers.
+ * Supports resolver hints to bypass the chain and method dispatch wrapping.
+ *
+ * @example
+ * ```typescript
+ * // Create chain with default resolvers
+ * const chain = ResolverChain.default();
+ *
+ * // Register a handler
+ * const explicit = chain.getResolver('explicit_mapping') as ExplicitMappingResolver;
+ * explicit.register('my_handler', MyHandler);
+ *
+ * // Resolve handler
+ * const definition: HandlerDefinition = { callable: 'my_handler' };
+ * const handler = await chain.resolve(definition);
+ *
+ * // Resolve with method dispatch
+ * const definition2: HandlerDefinition = {
+ *   callable: 'my_handler',
+ *   method: 'process',
+ * };
+ * const handler2 = await chain.resolve(definition2);
+ * // handler2.call() will invoke handler.process()
+ * ```
+ */
+
+/**
+ * Priority-ordered chain of resolvers for handler resolution.
+ */
+declare class ResolverChain {
+    private resolvers;
+    private resolversByName;
+    /**
+     * Create a resolver chain with default resolvers.
+     *
+     * Default resolvers:
+     * - ExplicitMappingResolver (priority 10)
+     * - ClassLookupResolver (priority 100)
+     *
+     * Note: Uses Promise caching to prevent race conditions when called
+     * concurrently. Multiple callers will receive the same chain instance.
+     *
+     * @returns Configured resolver chain
+     */
+    static default(): Promise<ResolverChain>;
+    /**
+     * Reset the default chain (for testing only).
+     *
+     * @internal
+     */
+    static resetDefault(): void;
+    /**
+     * Internal method to create the default chain.
+     */
+    private static createDefaultChain;
+    /**
+     * Create a resolver chain synchronously with provided resolvers.
+     *
+     * Use this when you want to avoid async initialization.
+     *
+     * @param resolvers - Resolvers to add to the chain
+     * @returns Configured resolver chain
+     */
+    static withResolvers(resolvers: BaseResolver[]): ResolverChain;
+    /**
+     * Add a resolver to the chain.
+     *
+     * Resolvers are automatically sorted by priority (lowest first).
+     *
+     * @param resolver - Resolver to add
+     */
+    addResolver(resolver: BaseResolver): void;
+    /**
+     * Get a resolver by name.
+     *
+     * @param name - Resolver name
+     * @returns Resolver or undefined if not found
+     */
+    getResolver(name: string): BaseResolver | undefined;
+    /**
+     * List all resolvers with their priorities.
+     *
+     * @returns Array of [name, priority] tuples, sorted by priority
+     */
+    listResolvers(): Array<[string, number]>;
+    /**
+     * Resolve a handler from a definition.
+     *
+     * Resolution process:
+     * 1. If resolver hint is present, use only that resolver
+     * 2. Otherwise, try resolvers in priority order
+     * 3. If method dispatch is needed, wrap the handler
+     *
+     * @param definition - Handler definition to resolve
+     * @param config - Optional resolver configuration
+     * @returns ExecutableHandler instance (possibly wrapped) or null
+     */
+    resolve(definition: HandlerDefinition, config?: ResolverConfig): Promise<ExecutableHandler | null>;
+    /**
+     * Wrap a handler for method dispatch if needed.
+     *
+     * @param handler - Handler to potentially wrap
+     * @param definition - Handler definition with method info
+     * @returns Original handler or MethodDispatchWrapper (both implement ExecutableHandler)
+     */
+    wrapForMethodDispatch(handler: StepHandler, definition: HandlerDefinition): ExecutableHandler;
+    /**
+     * Resolve using a specific resolver (from hint).
+     */
+    private resolveWithHint;
+    /**
+     * Resolve by trying resolvers in priority order.
+     */
+    private resolveWithChain;
+    /**
+     * Sort resolvers by priority (ascending).
+     */
+    private sortResolvers;
+}
+
+/**
+ * TAS-93: Class lookup resolver (priority 100).
+ *
+ * Infers handler classes from callable strings using dynamic imports.
+ * This resolver handles module path formats.
+ *
+ * Supports callable formats:
+ * - "./path/to/handler.js" - Relative module path
+ * - "../parent/handler.js" - Parent-relative module path
+ * - "@scope/package/handler" - Scoped package path
+ *
+ * NOT supported (security):
+ * - "/absolute/path/to/handler.js" - Absolute paths are blocked to prevent
+ *   loading arbitrary code in shared hosting environments.
+ *
+ * The module must export a class with a static `handlerName` property
+ * matching the expected handler interface.
+ *
+ * Note: This resolver is lower priority (100) because dynamic imports
+ * are more expensive than explicit mappings.
+ *
+ * @example
+ * ```typescript
+ * const resolver = new ClassLookupResolver();
+ *
+ * // Resolve from module path
+ * const definition: HandlerDefinition = {
+ *   callable: './handlers/payment-handler.js',
+ * };
+ * const handler = await resolver.resolve(definition);
+ * ```
+ */
+
+/**
+ * Resolver that infers handlers from module paths via dynamic import.
+ *
+ * Priority 100 - checked last in the default chain (inferential).
+ */
+declare class ClassLookupResolver implements BaseResolver {
+    readonly name = "class_lookup";
+    readonly priority = 100;
+    /**
+     * Check if callable looks like an importable path.
+     *
+     * @param definition - Handler definition
+     * @param _config - Unused, part of interface
+     * @returns True if callable matches importable pattern
+     */
+    canResolve(definition: HandlerDefinition, _config?: ResolverConfig): boolean;
+    /**
+     * Resolve handler by dynamically importing the module.
+     *
+     * Looks for:
+     * 1. Default export that is a handler class
+     * 2. Named exports that are handler classes
+     *
+     * @param definition - Handler definition with module path
+     * @param _config - Unused, part of interface
+     * @returns Handler instance or null if not found
+     */
+    resolve(definition: HandlerDefinition, _config?: ResolverConfig): Promise<StepHandler | null>;
+    /**
+     * Find a handler class in a module's exports.
+     */
+    private findHandlerClass;
+    /**
+     * Check if a value is a valid handler class.
+     */
+    private isHandlerClass;
+    /**
+     * Instantiate a handler class.
+     */
+    private instantiateHandler;
+}
+
+/**
+ * TAS-93: Explicit mapping resolver (priority 10).
+ *
+ * Resolves handlers from explicitly registered mappings.
+ * This is the highest priority resolver in the default chain.
+ *
+ * Supports registering:
+ * - Handler classes (instantiated on resolve)
+ * - Handler instances (returned directly)
+ * - Factory functions (called with config on resolve)
+ *
+ * @example
+ * ```typescript
+ * const resolver = new ExplicitMappingResolver();
+ *
+ * // Register a class
+ * resolver.register('my_handler', MyHandler);
+ *
+ * // Register an instance
+ * resolver.register('shared_handler', new SharedHandler());
+ *
+ * // Register a factory
+ * resolver.register('configurable_handler', (config) => new ConfigHandler(config));
+ *
+ * // Resolve
+ * const definition: HandlerDefinition = { callable: 'my_handler' };
+ * const handler = await resolver.resolve(definition);
+ * ```
+ */
+
+/**
+ * Factory function for creating handlers.
+ */
+type HandlerFactory = (config: ResolverConfig) => StepHandler;
+/**
+ * Entry types that can be registered.
+ */
+type HandlerEntry = StepHandlerClass | StepHandler | HandlerFactory;
+/**
+ * Resolver for explicitly registered handlers.
+ *
+ * Priority 10 - checked first in the default chain.
+ */
+declare class ExplicitMappingResolver implements BaseResolver {
+    readonly name: string;
+    readonly priority = 10;
+    private handlers;
+    /**
+     * Create an explicit mapping resolver.
+     *
+     * @param name - Resolver name (default: 'explicit_mapping')
+     */
+    constructor(name?: string);
+    /**
+     * Check if a handler is registered for this callable.
+     *
+     * @param definition - Handler definition
+     * @param _config - Unused, part of interface
+     * @returns True if handler is registered
+     */
+    canResolve(definition: HandlerDefinition, _config?: ResolverConfig): boolean;
+    /**
+     * Resolve and instantiate a registered handler.
+     *
+     * @param definition - Handler definition
+     * @param config - Configuration passed to factories
+     * @returns Handler instance or null if not registered
+     */
+    resolve(definition: HandlerDefinition, config?: ResolverConfig): Promise<StepHandler | null>;
+    /**
+     * Register a handler.
+     *
+     * @param key - Handler identifier (matched against definition.callable)
+     * @param handler - Handler class, instance, or factory function
+     */
+    register(key: string, handler: HandlerEntry): void;
+    /**
+     * Unregister a handler.
+     *
+     * @param key - Handler identifier to remove
+     * @returns True if handler was removed, false if not found
+     */
+    unregister(key: string): boolean;
+    /**
+     * Get all registered callable keys.
+     *
+     * @returns Array of registered keys
+     */
+    registeredCallables(): string[];
+    /**
+     * Instantiate a handler from a registered entry.
+     */
+    private instantiateHandler;
+    /**
+     * Check if entry is a handler class.
+     */
+    private isHandlerClass;
+    /**
+     * Instantiate a handler class.
+     */
+    private instantiateClass;
+}
+
+/**
+ * TAS-93: Step handler registry with resolver chain support.
+ *
+ * Provides handler registration and resolution using a priority-ordered
+ * resolver chain. Supports method dispatch and resolver hints.
+ *
+ * @example
+ * ```typescript
+ * const registry = new HandlerRegistry();
+ * await registry.initialize();
+ *
+ * // Register a handler
+ * registry.register('my_handler', MyHandler);
+ *
+ * // Simple resolution (string callable)
+ * const handler = await registry.resolve('my_handler');
+ *
+ * // Resolution with method dispatch
+ * const definition: HandlerDefinition = {
+ *   callable: 'my_handler',
+ *   method: 'process',
+ * };
+ * const handler2 = await registry.resolve(definition);
+ * // handler2.call() invokes handler.process()
+ *
+ * // Resolution with resolver hint
+ * const definition2: HandlerDefinition = {
+ *   callable: 'my_handler',
+ *   resolver: 'explicit_mapping',
+ * };
+ * const handler3 = await registry.resolve(definition2);
+ * ```
+ */
+
+/**
+ * Registry for step handler classes.
+ *
+ * TAS-93: Uses ResolverChain for flexible handler resolution
+ * with support for method dispatch and resolver hints.
+ *
+ * Provides handler discovery, registration, and resolution.
+ */
+declare class HandlerRegistry {
+    private _resolverChain;
+    private _explicitResolver;
+    private _initialized;
+    /** Promise-based lock for initialization to prevent concurrent init */
+    private _initPromise;
+    /** Track registrations so they can be transferred to chain resolver */
+    private _pendingRegistrations;
+    /**
+     * Initialize the registry with default resolvers.
+     *
+     * Must be called before using resolve() with resolver chain features.
+     * For simple register/resolve with strings, lazy initialization is used.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure the registry is initialized.
+     * Uses lazy initialization with proper locking to prevent concurrent init.
+     */
+    private ensureInitialized;
+    /**
+     * Get the explicit mapping resolver for direct registration.
+     */
+    private getExplicitResolver;
+    /**
+     * Register a handler class.
+     *
+     * @param name - Handler name (must match step definition)
+     * @param handlerClass - StepHandler subclass
+     * @throws Error if handlerClass is not a valid StepHandler subclass
+     *
+     * @example
+     * ```typescript
+     * registry.register('my_handler', MyHandler);
+     * ```
+     */
+    register(name: string, handlerClass: StepHandlerClass): void;
+    /**
+     * Unregister a handler.
+     *
+     * @param name - Handler name to unregister
+     * @returns True if handler was unregistered, false if not found
+     */
+    unregister(name: string): boolean;
+    /**
+     * Resolve and instantiate a handler.
+     *
+     * TAS-93: Accepts flexible input types:
+     * - string: Simple callable name
+     * - HandlerDefinition: Full definition with method/resolver
+     * - HandlerSpec: Union type for all formats
+     *
+     * @param handlerSpec - Handler specification
+     * @returns ExecutableHandler (StepHandler or MethodDispatchWrapper) or null if not found
+     *
+     * @example
+     * ```typescript
+     * // String callable
+     * const handler = await registry.resolve('my_handler');
+     *
+     * // With method dispatch
+     * const handler2 = await registry.resolve({
+     *   callable: 'my_handler',
+     *   method: 'process',
+     * });
+     * ```
+     */
+    resolve(handlerSpec: HandlerSpec): Promise<ExecutableHandler | null>;
+    /**
+     * Synchronous resolve for backward compatibility.
+     *
+     * Note: This only works with explicitly registered handlers.
+     * For full resolver chain support, use the async resolve() method.
+     *
+     * @param name - Handler name to resolve
+     * @returns Instantiated handler or null if not found
+     */
+    resolveSync(name: string): StepHandler | null;
+    /**
+     * Get a handler class without instantiation.
+     *
+     * @param name - Handler name to look up
+     * @returns Handler class or undefined if not found
+     */
+    getHandlerClass(_name: string): StepHandlerClass | undefined;
+    /**
+     * Check if a handler is registered.
+     *
+     * @param name - Handler name to check
+     * @returns True if handler is registered
+     */
+    isRegistered(name: string): boolean;
+    /**
+     * List all registered handler names.
+     *
+     * @returns Array of registered handler names
+     */
+    listHandlers(): string[];
+    /**
+     * Get the number of registered handlers.
+     */
+    handlerCount(): number;
+    /**
+     * Clear all registered handlers.
+     */
+    clear(): void;
+    /**
+     * Add a custom resolver to the chain.
+     *
+     * TAS-93: Allows adding custom domain-specific resolvers.
+     *
+     * @param resolver - Resolver to add
+     */
+    addResolver(resolver: BaseResolver): Promise<void>;
+    /**
+     * Get a resolver by name.
+     *
+     * @param name - Resolver name
+     * @returns Resolver or undefined
+     */
+    getResolver(name: string): Promise<BaseResolver | undefined>;
+    /**
+     * List all resolvers with priorities.
+     *
+     * @returns Array of [name, priority] tuples
+     */
+    listResolvers(): Promise<Array<[string, number]>>;
+    /**
+     * Get the underlying resolver chain.
+     *
+     * Useful for advanced configuration.
+     */
+    getResolverChain(): Promise<ResolverChain | null>;
+    /**
+     * Get debug information about the registry.
+     */
+    debugInfo(): Record<string, unknown>;
+}
+
+/**
+ * HandlerSystem - Owns handler registration and discovery.
+ *
+ * TAS-93: Uses HandlerRegistry with resolver chain for flexible handler resolution.
+ *
+ * This class encapsulates handler management:
+ * - Owns a HandlerRegistry instance (no singleton)
+ * - Provides handler discovery from directories
+ * - Manages handler registration lifecycle
+ * - Full resolver chain support via HandlerRegistry
+ *
+ * Design principles:
+ * - Explicit construction: No singleton pattern
+ * - Clear ownership: Owns the registry instance
+ * - Encapsulated discovery: Handler loading logic contained here
+ * - Single registry: Uses HandlerRegistry for all resolution
+ */
+
+/**
+ * Owns handler registration and discovery.
+ *
+ * TAS-93: Uses HandlerRegistry internally for unified resolution.
+ *
+ * Unlike using HandlerRegistry directly, this class:
+ * - Encapsulates handler discovery from directories
+ * - Provides convenience methods for loading handlers
+ * - Manages the full handler lifecycle
+ *
+ * @example
+ * ```typescript
+ * const handlerSystem = new HandlerSystem();
+ *
+ * // Register individual handlers
+ * handlerSystem.register('my_handler', MyHandler);
+ *
+ * // Or load from directory
+ * await handlerSystem.loadFromPath('./handlers');
+ *
+ * // Resolve with full resolver chain support
+ * const handler = await handlerSystem.resolve('my_handler');
+ *
+ * // Resolve with method dispatch
+ * const handler2 = await handlerSystem.resolve({
+ *   callable: 'my_handler',
+ *   method: 'process',
+ * });
+ * ```
+ */
+declare class HandlerSystem {
+    private readonly registry;
+    /**
+     * Create a new HandlerSystem.
+     */
+    constructor();
+    /**
+     * Initialize the handler system.
+     *
+     * Initializes the underlying HandlerRegistry with resolver chain.
+     * Call this before using resolve() for best performance.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the system is initialized.
+     */
+    get initialized(): boolean;
+    /**
+     * Load handlers from a directory path.
+     *
+     * Searches for handler modules in the directory and registers them.
+     * Supports both index file exports and directory scanning.
+     *
+     * @param path - Path to directory containing handlers
+     * @returns Number of handlers loaded
+     */
+    loadFromPath(path: string): Promise<number>;
+    /**
+     * Load handlers from TYPESCRIPT_HANDLER_PATH environment variable.
+     *
+     * @returns Number of handlers loaded
+     */
+    loadFromEnv(): Promise<number>;
+    /**
+     * Register a handler class.
+     *
+     * @param name - Handler name (must match step definition)
+     * @param handlerClass - StepHandler subclass
+     */
+    register(name: string, handlerClass: StepHandlerClass): void;
+    /**
+     * Unregister a handler.
+     *
+     * @param name - Handler name to unregister
+     * @returns True if handler was unregistered
+     */
+    unregister(name: string): boolean;
+    /**
+     * Resolve and instantiate a handler.
+     *
+     * TAS-93: Supports full resolver chain with method dispatch and resolver hints.
+     *
+     * @param handlerSpec - Handler specification (string, definition, or DTO)
+     * @returns Instantiated handler or null if not found
+     *
+     * @example
+     * ```typescript
+     * // String callable
+     * const handler = await handlerSystem.resolve('my_handler');
+     *
+     * // With method dispatch
+     * const handler2 = await handlerSystem.resolve({
+     *   callable: 'my_handler',
+     *   method: 'process',
+     * });
+     *
+     * // With resolver hint
+     * const handler3 = await handlerSystem.resolve({
+     *   callable: 'my_handler',
+     *   resolver: 'explicit_mapping',
+     * });
+     * ```
+     */
+    resolve(handlerSpec: HandlerSpec): Promise<ExecutableHandler | null>;
+    /**
+     * Check if a handler is registered.
+     */
+    isRegistered(name: string): boolean;
+    /**
+     * List all registered handler names.
+     */
+    listHandlers(): string[];
+    /**
+     * Get the number of registered handlers.
+     */
+    handlerCount(): number;
+    /**
+     * Clear all registered handlers.
+     */
+    clear(): void;
+    /**
+     * Add a custom resolver to the chain.
+     *
+     * TAS-93: Allows adding custom domain-specific resolvers.
+     *
+     * @param resolver - Resolver to add
+     */
+    addResolver(resolver: BaseResolver): Promise<void>;
+    /**
+     * Get a resolver by name.
+     *
+     * @param name - Resolver name
+     * @returns Resolver or undefined
+     */
+    getResolver(name: string): Promise<BaseResolver | undefined>;
+    /**
+     * List all resolvers with priorities.
+     *
+     * @returns Array of [name, priority] tuples
+     */
+    listResolvers(): Promise<Array<[string, number]>>;
+    /**
+     * Get the underlying resolver chain.
+     *
+     * Useful for advanced configuration.
+     */
+    getResolverChain(): Promise<ResolverChain | null>;
+    /**
+     * Get the underlying HandlerRegistry.
+     *
+     * TAS-93: Returns the HandlerRegistry directly for use with
+     * StepExecutionSubscriber and other components.
+     */
+    getRegistry(): HandlerRegistry;
+    /**
+     * Get debug information about the handler system.
+     */
+    debugInfo(): Record<string, unknown>;
+    /**
+     * Try to import an index file from the handler path.
+     */
+    private tryImportIndexFile;
+    /**
+     * Register handlers from a module's exports.
+     */
+    private registerHandlersFromModule;
+    /**
+     * Register handlers from ALL_EXAMPLE_HANDLERS array.
+     */
+    private registerFromHandlerArray;
+    /**
+     * Register handlers from module exports.
+     */
+    private registerFromModuleExports;
+    /**
+     * Check if a value is a valid handler class.
+     */
+    private isValidHandlerClass;
+    /**
+     * Recursively scan a directory for handler files and import them.
+     */
+    private scanAndImportHandlers;
+    /**
+     * Process a single directory entry for handler import.
+     */
+    private processDirectoryEntry;
+    /**
+     * Check if a directory should be scanned for handlers.
+     */
+    private shouldScanDirectory;
+    /**
+     * Check if a file might contain handlers.
+     */
+    private isHandlerFile;
+    /**
+     * Import handlers from a single file.
+     */
+    private importHandlerFile;
+}
+
+/**
+ * Structured logging API for TypeScript workers.
+ *
+ * Provides unified structured logging that integrates with Rust tracing
+ * infrastructure via FFI. All log messages are forwarded to the Rust
+ * tracing subscriber for consistent formatting and output.
+ *
+ * Matches Python's logging module and Ruby's tracing module (TAS-92 aligned).
+ *
+ * To enable FFI logging, call setLoggingRuntime() after loading the FFI layer.
+ * If no runtime is installed, logs fall back to console output.
+ */
+
+/**
+ * Structured logging fields.
+ *
+ * All fields are optional. Common fields include:
+ * - component: Component/subsystem identifier (e.g., "handler", "registry")
+ * - operation: Operation being performed (e.g., "process_payment")
+ * - correlation_id: Distributed tracing correlation ID
+ * - task_uuid: Task identifier
+ * - step_uuid: Step identifier
+ * - namespace: Task namespace
+ * - error_message: Error message for error logs
+ * - duration_ms: Execution duration for timed operations
+ */
+interface LogFields {
+    [key: string]: string | number | boolean | null | undefined;
+}
+/**
+ * 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;
+    warn: (message: string, fields?: LogFields) => void;
+    info: (message: string, fields?: LogFields) => void;
+    debug: (message: string, fields?: LogFields) => void;
+    trace: (message: string, fields?: LogFields) => void;
+};
+
+/**
+ * Shutdown controller for coordinating graceful shutdown.
+ *
+ * Provides a signal-based mechanism for triggering and awaiting
+ * shutdown across async boundaries.
+ */
+/**
+ * Shutdown signal handler type.
+ */
+type ShutdownHandler = () => void | Promise<void>;
+/**
+ * Controller for coordinating graceful shutdown.
+ *
+ * Provides a promise-based mechanism for waiting on shutdown signals
+ * and executing cleanup handlers in order.
+ *
+ * @example
+ * ```typescript
+ * const shutdown = new ShutdownController();
+ *
+ * process.on('SIGTERM', () => shutdown.trigger('SIGTERM'));
+ * process.on('SIGINT', () => shutdown.trigger('SIGINT'));
+ *
+ * // Wait for shutdown signal
+ * await shutdown.promise;
+ *
+ * // Or check if shutdown was requested
+ * if (shutdown.isRequested) {
+ *   await cleanup();
+ * }
+ * ```
+ */
+declare class ShutdownController {
+    private _shutdownRequested;
+    private _resolver;
+    private _signal;
+    private readonly _handlers;
+    /**
+     * Promise that resolves when shutdown is triggered.
+     */
+    readonly promise: Promise<void>;
+    constructor();
+    /**
+     * Check if shutdown has been requested.
+     */
+    get isRequested(): boolean;
+    /**
+     * Get the signal that triggered shutdown, if any.
+     */
+    get signal(): string | null;
+    /**
+     * Register a handler to be called during shutdown.
+     *
+     * Handlers are called in registration order.
+     */
+    onShutdown(handler: ShutdownHandler): void;
+    /**
+     * Trigger shutdown with the given signal.
+     *
+     * @param signal - The signal that triggered shutdown (e.g., 'SIGTERM', 'SIGINT')
+     */
+    trigger(signal: string): void;
+    /**
+     * Execute all registered shutdown handlers.
+     *
+     * Handlers are called in registration order. Errors are logged
+     * but do not prevent subsequent handlers from running.
+     */
+    executeHandlers(): Promise<void>;
+    /**
+     * Reset the controller for reuse (primarily for testing).
+     */
+    reset(): void;
+}
+
+/**
+ * Server module types.
+ *
+ * Defines types for WorkerServer lifecycle and configuration.
+ */
+
+/**
+ * Server state constants.
+ *
+ * Use these constants instead of raw strings for type safety and consistency.
+ *
+ * State transitions:
+ * - INITIALIZED -> STARTING -> RUNNING -> SHUTTING_DOWN -> STOPPED
+ * - Any state can transition to ERROR on fatal failures
+ */
+declare const ServerStates: {
+    /** Initial state after construction */
+    readonly INITIALIZED: "initialized";
+    /** Starting up: loading FFI, registering handlers, bootstrapping */
+    readonly STARTING: "starting";
+    /** Running and processing events */
+    readonly RUNNING: "running";
+    /** Graceful shutdown in progress */
+    readonly SHUTTING_DOWN: "shutting_down";
+    /** Fully stopped */
+    readonly STOPPED: "stopped";
+    /** Error state - fatal failure occurred */
+    readonly ERROR: "error";
+};
+/**
+ * Server lifecycle states (union type derived from constants).
+ */
+type ServerState = (typeof ServerStates)[keyof typeof ServerStates];
+/**
+ * Worker server configuration.
+ *
+ * All fields are optional with sensible defaults.
+ */
+interface WorkerServerConfig {
+    /** Task namespace to handle (default: "default") */
+    namespace?: string;
+    /** Log level for Rust tracing (default: "info") */
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    /** Path to TOML configuration file */
+    configPath?: string;
+    /** PostgreSQL database connection URL */
+    databaseUrl?: string;
+    /** Path to the FFI library (overrides auto-discovery) */
+    libraryPath?: string;
+    /** Maximum concurrent handler executions (default: 10) */
+    maxConcurrentHandlers?: number;
+    /** Handler execution timeout in milliseconds (default: 300000 = 5 minutes) */
+    handlerTimeoutMs?: number;
+    /** Event polling interval in milliseconds (default: 10) */
+    pollIntervalMs?: number;
+    /** Starvation check interval in poll cycles (default: 100) */
+    starvationCheckInterval?: number;
+    /** Cleanup interval in poll cycles (default: 1000) */
+    cleanupInterval?: number;
+    /** Metrics reporting interval in poll cycles (default: 100) */
+    metricsInterval?: number;
+}
+/**
+ * Health check result.
+ */
+interface HealthCheckResult {
+    /** Whether the worker is healthy */
+    healthy: boolean;
+    /** Optional status details when healthy */
+    status?: ServerStatus;
+    /** Error message when unhealthy */
+    error?: string;
+}
+/**
+ * Server status information.
+ */
+interface ServerStatus {
+    /** Current server state */
+    state: ServerState;
+    /** Worker identifier */
+    workerId: string | null;
+    /** Whether the worker is actively running */
+    running: boolean;
+    /** Number of events processed */
+    processedCount: number;
+    /** Number of errors encountered */
+    errorCount: number;
+    /** Number of currently active handlers */
+    activeHandlers: number;
+    /** Server uptime in milliseconds */
+    uptimeMs: number;
+}
+/**
+ * Internal server components.
+ *
+ * Used by WorkerServer to manage lifecycle of all components.
+ */
+interface ServerComponents {
+    /** FFI runtime instance */
+    runtime: TaskerRuntime;
+    /** Event emitter for step events */
+    emitter: TaskerEventEmitter;
+    /** Handler registry */
+    registry: HandlerRegistry;
+    /** Event poller for FFI events */
+    eventPoller: EventPoller;
+    /** Step execution subscriber */
+    stepSubscriber: StepExecutionSubscriber;
+    /** Worker identifier from bootstrap */
+    workerId: string;
+}
+
+/**
+ * WorkerServer - Orchestrates the TypeScript worker lifecycle.
+ *
+ * Manages the complete lifecycle of a TypeScript worker:
+ * - FFI library loading (via FfiLayer)
+ * - Handler registration (via HandlerSystem)
+ * - Rust worker bootstrapping
+ * - Event processing (via EventSystem)
+ * - Graceful shutdown
+ *
+ * Design principles:
+ * - Explicit construction: No singleton pattern - caller creates and manages
+ * - Clear ownership: Owns FfiLayer, HandlerSystem, EventSystem
+ * - Explicit lifecycle: Clear 3-phase startup and shutdown
+ *
+ * @example
+ * ```typescript
+ * const server = new WorkerServer();
+ *
+ * await server.start({
+ *   namespace: 'payments',
+ *   logLevel: 'debug',
+ * });
+ *
+ * // Server is now running and processing tasks
+ *
+ * await server.shutdown();
+ * ```
+ */
+
+/**
+ * Worker server class.
+ *
+ * Unlike the previous singleton pattern, this class is instantiated directly
+ * by the caller (typically bin/server.ts). This provides explicit lifecycle
+ * control and clear dependency ownership.
+ */
+declare class WorkerServer {
+    private readonly ffiLayer;
+    private readonly handlerSystem;
+    private eventSystem;
+    private state;
+    private config;
+    private workerId;
+    private startTime;
+    private shutdownHandlers;
+    /**
+     * Create a new WorkerServer.
+     *
+     * @param ffiConfig - Optional FFI layer configuration
+     */
+    constructor(ffiConfig?: FfiLayerConfig);
+    /**
+     * Get the current server state.
+     */
+    getState(): ServerState;
+    /**
+     * Get the worker identifier.
+     */
+    getWorkerId(): string | null;
+    /**
+     * Check if the server is currently running.
+     */
+    isRunning(): boolean;
+    /**
+     * Get the handler system for external handler registration.
+     */
+    getHandlerSystem(): HandlerSystem;
+    /**
+     * Get the event system (available after start).
+     */
+    getEventSystem(): EventSystem | null;
+    /**
+     * Start the worker server.
+     *
+     * Three-phase startup:
+     * 1. Initialize: Load FFI, load handlers
+     * 2. Bootstrap: Initialize Rust worker
+     * 3. Start: Begin event processing
+     *
+     * @param config - Optional server configuration
+     * @returns The server instance for chaining
+     * @throws Error if server is already running or fails to start
+     */
+    start(config?: WorkerServerConfig): Promise<this>;
+    /**
+     * Shutdown the worker server gracefully.
+     *
+     * Three-phase shutdown:
+     * 1. Stop event processing
+     * 2. Stop Rust worker
+     * 3. Unload FFI
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Register a handler to be called during shutdown.
+     *
+     * @param handler - Function to execute during shutdown
+     */
+    onShutdown(handler: () => void | Promise<void>): void;
+    /**
+     * Perform a health check on the worker.
+     */
+    healthCheck(): HealthCheckResult;
+    /**
+     * Get detailed server status.
+     */
+    status(): ServerStatus;
+    /**
+     * Phase 1: Initialize FFI and handlers.
+     */
+    private initializePhase;
+    /**
+     * Phase 2: Bootstrap Rust worker.
+     */
+    private bootstrapPhase;
+    /**
+     * Phase 3: Start event processing.
+     */
+    private startEventProcessingPhase;
+    /**
+     * Cleanup on error during startup.
+     */
+    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, type CreateBatchesOutcome, 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, FfiLayerConfig, type HandlerEntry, type HandlerFactory, HandlerRegistry, type HandlerSpec, HandlerSystem, InProcessDomainEventPoller, 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, 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 };