@tasker-systems/tasker 0.1.1 → 0.1.3

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'eventemitter3';
-import { l as FfiStepEvent, p as StepExecutionResult, k as FfiDispatchMetrics, T as TaskerRuntime } from './runtime-interface-CE4viUt7.js';
+import { l as FfiStepEvent, p as StepExecutionResult, k as FfiDispatchMetrics, T as TaskerRuntime } from './runtime-interface-D940vUzy.js';
 
 /**
  * Event emitter for TypeScript workers.

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-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 { T as TaskerRuntime, C as ClientTaskResponse, a as ClientTaskListResponse, b as ClientStepResponse, c as ClientStepAuditResponse, d as ClientHealthResponse, F as FfiDomainEvent, H as HandlerDefinitionDto } from './runtime-interface-D940vUzy.js';
+export { B as BaseTaskerRuntime, g as ClientPaginationInfo, h as ClientResult, i as ClientStepReadiness, j as ClientTaskRequest, D as DependencyResult, e as FfiBootstrapConfig, f as FfiBootstrapResult, k as FfiDispatchMetrics, L as FfiLogFields, l as FfiStepEvent, q as FfiStopResult, W as FfiWorkerStatus, m as HandlerDefinition, O as OrchestrationMetadata, R as RetryConfiguration, S as StepDefinition, n as StepExecutionError, o as StepExecutionMetadata, p as StepExecutionResult, r as Task, s as WorkflowStep } from './runtime-interface-D940vUzy.js';
+import { FfiLayer, FfiLayerConfig } from './ffi/index.js';
+export { BunRuntime, DenoRuntime, NodeRuntime, RuntimeInfo, RuntimeType, detectRuntime, getLibraryPath, getRuntimeInfo, isBun, isDeno, isNode } from './ffi/index.js';
+import { S as StepHandlerResult, a as StepHandler, B as BatchWorkerConfig, b as StepContext, E as ExecutableHandler, c as StepHandlerClass, T as TaskerEventEmitter, d as EventPoller, e as StepExecutionSubscriber, f as EventSystem } from './index-CTl8lGpU.js';
+export { y as ErrorCallback, I as ErrorType, n as EventName, o as EventNames, z as EventPollerConfig, F as EventSystemConfig, G as EventSystemStats, A as MetricsCallback, p as MetricsEventName, q as MetricsEventNames, M as MetricsPayload, P as PollerCyclePayload, r as PollerEventName, s as PollerEventNames, C as PollerState, g as StepCompletionSentPayload, L as StepContextParams, D as StepEventCallback, t as StepEventName, u as StepEventNames, h as StepExecutionCompletedPayload, i as StepExecutionFailedPayload, j as StepExecutionReceivedPayload, k as StepExecutionStartedPayload, H as StepExecutionSubscriberConfig, N as StepHandlerResultParams, l as TaskerEventMap, W as WorkerErrorPayload, v as WorkerEventName, w as WorkerEventNames, m as WorkerEventPayload, x as createEventPoller, J as isStandardErrorType, K as isTypicallyRetryable } from './index-CTl8lGpU.js';
 import { Logger } from 'pino';
 import 'eventemitter3';
 
@@ -225,6 +225,166 @@ declare function getRustVersion(runtime?: TaskerRuntime): string;
  */
 declare function healthCheck(runtime?: TaskerRuntime): boolean;
 
+/**
+ * High-level client wrapper for orchestration API operations.
+ *
+ * The raw FFI exposes `runtime.clientCreateTask(json)` and similar methods
+ * that require callers to construct complete JSON request strings with all
+ * required fields and return untyped `ClientResult` envelopes.
+ *
+ * This module provides a `TaskerClient` class with typed methods, sensible
+ * defaults, and proper error handling.
+ *
+ * @example
+ * ```typescript
+ * import { FfiLayer, TaskerClient } from '@tasker-systems/tasker';
+ *
+ * const ffiLayer = new FfiLayer();
+ * await ffiLayer.load();
+ * const client = new TaskerClient(ffiLayer);
+ *
+ * const task = client.createTask({ name: 'process_order', namespace: 'ecommerce' });
+ * console.log(task.task_uuid);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Options for creating a task.
+ *
+ * Only `name` is required; all other fields have sensible defaults.
+ */
+interface CreateTaskOptions {
+    /** Named task template name */
+    name: string;
+    /** Task namespace (default: 'default') */
+    namespace?: string;
+    /** Workflow context passed to step handlers (default: {}) */
+    context?: Record<string, unknown>;
+    /** Template version (default: '1.0.0') */
+    version?: string;
+    /** Who initiated the request (default: 'tasker-core-typescript') */
+    initiator?: string;
+    /** Originating system (default: 'tasker-core') */
+    sourceSystem?: string;
+    /** Reason for creating the task (default: 'Task requested') */
+    reason?: string;
+    /** Optional tags */
+    tags?: string[];
+    /** Optional priority */
+    priority?: number | null;
+    /** Optional correlation ID (auto-generated if not provided) */
+    correlationId?: string;
+    /** Optional parent correlation ID */
+    parentCorrelationId?: string | null;
+    /** Optional idempotency key */
+    idempotencyKey?: string | null;
+}
+/**
+ * Options for listing tasks.
+ */
+interface ListTasksOptions {
+    /** Maximum number of results (default: 50) */
+    limit?: number;
+    /** Pagination offset (default: 0) */
+    offset?: number;
+    /** Filter by namespace */
+    namespace?: string;
+    /** Filter by status */
+    status?: string;
+}
+/**
+ * Error thrown when a client operation fails.
+ */
+declare class TaskerClientError extends Error {
+    /** Whether the error is potentially recoverable */
+    readonly recoverable: boolean;
+    constructor(message: string, recoverable?: boolean);
+}
+/**
+ * High-level client for orchestration API operations.
+ *
+ * Wraps the raw FFI methods with typed interfaces, sensible defaults,
+ * and proper error handling via `TaskerClientError`.
+ */
+declare class TaskerClient {
+    private readonly ffiLayer;
+    constructor(ffiLayer: FfiLayer);
+    /**
+     * Create a task via the orchestration API.
+     *
+     * @param options - Task creation options (only `name` is required)
+     * @returns Typed task response
+     * @throws TaskerClientError if the operation fails
+     */
+    createTask(options: CreateTaskOptions): ClientTaskResponse;
+    /**
+     * Get a task by UUID.
+     *
+     * @param taskUuid - The task UUID
+     * @returns Typed task response
+     * @throws TaskerClientError if the operation fails
+     */
+    getTask(taskUuid: string): ClientTaskResponse;
+    /**
+     * List tasks with optional filtering and pagination.
+     *
+     * @param options - Filtering and pagination options
+     * @returns Typed task list response with pagination
+     * @throws TaskerClientError if the operation fails
+     */
+    listTasks(options?: ListTasksOptions): ClientTaskListResponse;
+    /**
+     * Cancel a task by UUID.
+     *
+     * @param taskUuid - The task UUID
+     * @throws TaskerClientError if the operation fails
+     */
+    cancelTask(taskUuid: string): void;
+    /**
+     * List workflow steps for a task.
+     *
+     * @param taskUuid - The task UUID
+     * @returns Array of typed step responses
+     * @throws TaskerClientError if the operation fails
+     */
+    listTaskSteps(taskUuid: string): ClientStepResponse[];
+    /**
+     * Get a specific workflow step.
+     *
+     * @param taskUuid - The task UUID
+     * @param stepUuid - The step UUID
+     * @returns Typed step response
+     * @throws TaskerClientError if the operation fails
+     */
+    getStep(taskUuid: string, stepUuid: string): ClientStepResponse;
+    /**
+     * Get audit history for a workflow step.
+     *
+     * @param taskUuid - The task UUID
+     * @param stepUuid - The step UUID
+     * @returns Array of typed audit history entries
+     * @throws TaskerClientError if the operation fails
+     */
+    getStepAuditHistory(taskUuid: string, stepUuid: string): ClientStepAuditResponse[];
+    /**
+     * Check orchestration API health.
+     *
+     * @returns Typed health response
+     * @throws TaskerClientError if the operation fails
+     */
+    healthCheck(): ClientHealthResponse;
+    /**
+     * Unwrap a ClientResult envelope, throwing on error.
+     */
+    private unwrap;
+    /**
+     * Get the FFI runtime from the layer.
+     */
+    private getRuntime;
+}
+
 /**
  * API mixin for HTTP functionality.
  *
@@ -4010,4 +4170,4 @@ declare class WorkerServer {
     private cleanupOnError;
 }
 
-export { type APICapable, APIMixin, ApiHandler, ApiResponse, BasePublisher, type BaseResolver, BaseSubscriber, type BatchAggregationResult, type BatchAnalyzerOutcome, type BatchMetadata, type BatchProcessingOutcome, type BatchWorkerContext, type BatchWorkerOutcome, type Batchable, BatchableMixin, type BootstrapConfig, type BootstrapResult, ClassLookupResolver, 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 };
+export { type APICapable, APIMixin, ApiHandler, ApiResponse, BasePublisher, type BaseResolver, BaseSubscriber, type BatchAggregationResult, type BatchAnalyzerOutcome, type BatchMetadata, type BatchProcessingOutcome, type BatchWorkerContext, type BatchWorkerOutcome, type Batchable, BatchableMixin, type BootstrapConfig, type BootstrapResult, ClassLookupResolver, ClientHealthResponse, ClientStepAuditResponse, ClientStepResponse, ClientTaskListResponse, ClientTaskResponse, type CreateBatchesOutcome, type CreateTaskOptions, type CursorConfig, type DecisionCapable, DecisionHandler, DecisionMixin, type DecisionPointOutcome, DecisionType, DefaultPublisher, type DomainEvent, type DomainEventCallback, type DomainEventErrorCallback, type DomainEventMetadata, type DomainEventPollerConfig, DuplicatePublisherError, type EventDeclaration, EventPoller, EventSystem, ExecutableHandler, ExplicitMappingResolver, type FailureStrategy, FfiLayer, FfiLayerConfig, type HandlerEntry, type HandlerFactory, HandlerRegistry, type HandlerSpec, HandlerSystem, InProcessDomainEventPoller, type ListTasksOptions, type LogFields, MethodDispatchError, MethodDispatchWrapper, type NoBatchesOutcome, NoResolverMatchError, type PollerStats, type PublishContext, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, type RegistryResolverStatic, ResolutionError, ResolverChain, type ResolverConfig, ResolverNotFoundError, type RustBatchWorkerInputs, type RustCursorConfig, type ServerComponents, type HealthCheckResult as ServerHealthCheckResult, type ServerState, type ServerStatus, ShutdownController, type ShutdownHandler, StepContext, type StepEventContext, StepExecutionSubscriber, StepHandler, StepHandlerClass, StepHandlerResult, type StepResult, type StopResult, type SubscriberClass, SubscriberRegistry, type SubscriberStats, TaskerClient, TaskerClientError, TaskerEventEmitter, TaskerRuntime, WorkerServer, type WorkerServerConfig, type WorkerStatus, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createFfiPollAdapter, createLogger, createStepEventContext, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isCreateBatches, isNoBatches, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };

package/dist/index.js

@@ -1,8 +1,9 @@
 import { EventEmitter } from 'eventemitter3';
 import pino from 'pino';
 import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { readdir } from 'fs/promises';
-import { join } from 'path';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -521,8 +522,8 @@ var require_koffi19 = __commonJS2({
                   data = data.subarray(0, header.size);
                   if (header.type == "0" || header.type == "7") {
                     let filename3 = dest_dir + "/" + header.filename;
-                    let dirname = path2.dirname(filename3);
-                    fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
+                    let dirname2 = path2.dirname(filename3);
+                    fs2.mkdirSync(dirname2, { recursive: true, mode: 493 });
                     fs2.writeFileSync(filename3, data, { mode: header.mode });
                   } else if (header.type == "5") {
                     let filename3 = dest_dir + "/" + header.filename;
@@ -2103,6 +2104,151 @@ function healthCheck(runtime) {
   }
 }
 
+// src/client/index.ts
+var TaskerClientError = class extends Error {
+  /** Whether the error is potentially recoverable */
+  recoverable;
+  constructor(message, recoverable = false) {
+    super(message);
+    this.name = "TaskerClientError";
+    this.recoverable = recoverable;
+  }
+};
+var TaskerClient = class {
+  ffiLayer;
+  constructor(ffiLayer) {
+    this.ffiLayer = ffiLayer;
+  }
+  /**
+   * Create a task via the orchestration API.
+   *
+   * @param options - Task creation options (only `name` is required)
+   * @returns Typed task response
+   * @throws TaskerClientError if the operation fails
+   */
+  createTask(options) {
+    const request = {
+      name: options.name,
+      namespace: options.namespace ?? "default",
+      version: options.version ?? "1.0.0",
+      context: options.context ?? {},
+      initiator: options.initiator ?? "tasker-core-typescript",
+      source_system: options.sourceSystem ?? "tasker-core",
+      reason: options.reason ?? "Task requested",
+      tags: options.tags ?? [],
+      requested_at: (/* @__PURE__ */ new Date()).toISOString(),
+      options: null,
+      priority: options.priority ?? null,
+      correlation_id: options.correlationId ?? crypto.randomUUID(),
+      parent_correlation_id: options.parentCorrelationId ?? null,
+      idempotency_key: options.idempotencyKey ?? null
+    };
+    const result = this.getRuntime().clientCreateTask(JSON.stringify(request));
+    return this.unwrap(result);
+  }
+  /**
+   * Get a task by UUID.
+   *
+   * @param taskUuid - The task UUID
+   * @returns Typed task response
+   * @throws TaskerClientError if the operation fails
+   */
+  getTask(taskUuid) {
+    const result = this.getRuntime().clientGetTask(taskUuid);
+    return this.unwrap(result);
+  }
+  /**
+   * List tasks with optional filtering and pagination.
+   *
+   * @param options - Filtering and pagination options
+   * @returns Typed task list response with pagination
+   * @throws TaskerClientError if the operation fails
+   */
+  listTasks(options = {}) {
+    const params = {
+      limit: options.limit ?? 50,
+      offset: options.offset ?? 0,
+      namespace: options.namespace ?? null,
+      status: options.status ?? null
+    };
+    const result = this.getRuntime().clientListTasks(JSON.stringify(params));
+    return this.unwrap(result);
+  }
+  /**
+   * Cancel a task by UUID.
+   *
+   * @param taskUuid - The task UUID
+   * @throws TaskerClientError if the operation fails
+   */
+  cancelTask(taskUuid) {
+    const result = this.getRuntime().clientCancelTask(taskUuid);
+    this.unwrap(result);
+  }
+  /**
+   * List workflow steps for a task.
+   *
+   * @param taskUuid - The task UUID
+   * @returns Array of typed step responses
+   * @throws TaskerClientError if the operation fails
+   */
+  listTaskSteps(taskUuid) {
+    const result = this.getRuntime().clientListTaskSteps(taskUuid);
+    return this.unwrap(result);
+  }
+  /**
+   * Get a specific workflow step.
+   *
+   * @param taskUuid - The task UUID
+   * @param stepUuid - The step UUID
+   * @returns Typed step response
+   * @throws TaskerClientError if the operation fails
+   */
+  getStep(taskUuid, stepUuid) {
+    const result = this.getRuntime().clientGetStep(taskUuid, stepUuid);
+    return this.unwrap(result);
+  }
+  /**
+   * Get audit history for a workflow step.
+   *
+   * @param taskUuid - The task UUID
+   * @param stepUuid - The step UUID
+   * @returns Array of typed audit history entries
+   * @throws TaskerClientError if the operation fails
+   */
+  getStepAuditHistory(taskUuid, stepUuid) {
+    const result = this.getRuntime().clientGetStepAuditHistory(taskUuid, stepUuid);
+    return this.unwrap(result);
+  }
+  /**
+   * Check orchestration API health.
+   *
+   * @returns Typed health response
+   * @throws TaskerClientError if the operation fails
+   */
+  healthCheck() {
+    const result = this.getRuntime().clientHealthCheck();
+    return this.unwrap(result);
+  }
+  /**
+   * Unwrap a ClientResult envelope, throwing on error.
+   */
+  unwrap(result) {
+    if (!result.success) {
+      throw new TaskerClientError(
+        result.error ?? "Unknown client error",
+        result.recoverable ?? false
+      );
+    }
+    return result.data;
+  }
+  /**
+   * Get the FFI runtime from the layer.
+   */
+  getRuntime() {
+    return this.ffiLayer.getRuntime();
+  }
+};
+
 // src/events/event-names.ts
 var StepEventNames = {
   /** Emitted when a step execution event is received from the FFI layer */
@@ -3903,7 +4049,10 @@ var FfiLayer = class _FfiLayer {
     const path2 = customPath ?? this.configuredLibraryPath ?? this.discoverLibraryPath();
     if (!path2) {
       throw new Error(
-        "FFI library not found. TASKER_FFI_LIBRARY_PATH environment variable must be set to the path of the compiled library.\nExample: export TASKER_FFI_LIBRARY_PATH=/path/to/target/debug/libtasker_ts.dylib\nBuild the library with: cargo build -p tasker-ts"
+        `FFI library not found. No bundled native library matches this platform, and TASKER_FFI_LIBRARY_PATH is not set.
+Current platform: ${process.platform}-${process.arch}
+Supported: linux-x64, linux-arm64, darwin-arm64
+Override: export TASKER_FFI_LIBRARY_PATH=/path/to/libtasker_ts.dylib`
       );
     }
     this.runtime = await this.createRuntime();
@@ -3957,23 +4106,27 @@ var FfiLayer = class _FfiLayer {
    * Static method for finding the library path without creating an instance.
    * Useful for test utilities and pre-flight checks.
    *
-   * REQUIRES: TASKER_FFI_LIBRARY_PATH environment variable to be set.
-   * This explicit requirement prevents confusion from automatic debug/release
-   * library discovery and ensures intentional configuration at build/runtime.
+   * Resolution order:
+   * 1. TASKER_FFI_LIBRARY_PATH environment variable (explicit override)
+   * 2. Bundled native library in the package's native/ directory
    *
    * @param _callerDir Deprecated parameter, kept for API compatibility
    * @returns Path to the library if found and exists, null otherwise
    */
   static findLibraryPath(_callerDir) {
     const envPath = process.env.TASKER_FFI_LIBRARY_PATH;
-    if (!envPath) {
-      return null;
+    if (envPath) {
+      if (!existsSync(envPath)) {
+        console.warn(`TASKER_FFI_LIBRARY_PATH is set to "${envPath}" but the file does not exist`);
+        return null;
+      }
+      return envPath;
     }
-    if (!existsSync(envPath)) {
-      console.warn(`TASKER_FFI_LIBRARY_PATH is set to "${envPath}" but the file does not exist`);
-      return null;
+    const bundledPath = findBundledNativeLibrary();
+    if (bundledPath && existsSync(bundledPath)) {
+      return bundledPath;
     }
-    return envPath;
+    return null;
   }
   /**
    * Discover the FFI library path.
@@ -4009,6 +4162,21 @@ var FfiLayer = class _FfiLayer {
     }
   }
 };
+var BUNDLED_LIBRARIES = {
+  "linux-x64": "libtasker_ts-linux-x64.so",
+  "linux-arm64": "libtasker_ts-linux-arm64.so",
+  "darwin-arm64": "libtasker_ts-darwin-arm64.dylib"
+};
+function findBundledNativeLibrary() {
+  const key = `${process.platform}-${process.arch}`;
+  const filename2 = BUNDLED_LIBRARIES[key];
+  if (!filename2) {
+    return null;
+  }
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = join(thisDir, "..", "..");
+  return join(packageRoot, "native", filename2);
+}
 
 // src/ffi/index.ts
 init_node_runtime();
@@ -7865,6 +8033,6 @@ var WorkerServer = class {
   }
 };
 
-export { APIMixin, ApiHandler, ApiResponse, BasePublisher, BaseSubscriber, BaseTaskerRuntime, BatchableMixin, BunRuntime, ClassLookupResolver, DecisionHandler, DecisionMixin, DecisionType, DefaultPublisher, DenoRuntime, DuplicatePublisherError, ErrorType, EventNames, EventPoller, EventSystem, ExplicitMappingResolver, FfiLayer, HandlerRegistry, HandlerSystem, InProcessDomainEventPoller, MethodDispatchError, MethodDispatchWrapper, MetricsEventNames, NoResolverMatchError, NodeRuntime, PollerEventNames, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, ResolutionError, ResolverChain, ResolverNotFoundError, ShutdownController, StepContext, StepEventNames, StepExecutionSubscriber, StepHandler, StepHandlerResult, SubscriberRegistry, TaskerEventEmitter, WorkerEventNames, WorkerServer, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createEventPoller, createFfiPollAdapter, createLogger, createStepEventContext, detectRuntime, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getLibraryPath, getRuntimeInfo, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isBun, isCreateBatches, isDeno, isNoBatches, isNode, isStandardErrorType, isTypicallyRetryable, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };
+export { APIMixin, ApiHandler, ApiResponse, BasePublisher, BaseSubscriber, BaseTaskerRuntime, BatchableMixin, BunRuntime, ClassLookupResolver, DecisionHandler, DecisionMixin, DecisionType, DefaultPublisher, DenoRuntime, DuplicatePublisherError, ErrorType, EventNames, EventPoller, EventSystem, ExplicitMappingResolver, FfiLayer, HandlerRegistry, HandlerSystem, InProcessDomainEventPoller, MethodDispatchError, MethodDispatchWrapper, MetricsEventNames, NoResolverMatchError, NodeRuntime, PollerEventNames, PublisherNotFoundError, PublisherRegistry, PublisherValidationError, RegistryFrozenError, RegistryResolver, ResolutionError, ResolverChain, ResolverNotFoundError, ShutdownController, StepContext, StepEventNames, StepExecutionSubscriber, StepHandler, StepHandlerResult, SubscriberRegistry, TaskerClient, TaskerClientError, TaskerEventEmitter, WorkerEventNames, WorkerServer, aggregateBatchResults, applyAPI, applyBatchable, applyDecision, bootstrapWorker, createBatchWorkerContext, createBatches, createDomainEvent, createEventPoller, createFfiPollAdapter, createLogger, createStepEventContext, detectRuntime, effectiveMethod, ffiEventToDomainEvent, fromCallable, fromDto, getLibraryPath, getRuntimeInfo, getRustVersion, getVersion, getWorkerStatus, hasResolverHint, healthCheck, isBun, isCreateBatches, isDeno, isNoBatches, isNode, isStandardErrorType, isTypicallyRetryable, isWorkerRunning, logDebug, logError, logInfo, logTrace, logWarn, noBatches, normalizeToDefinition, stopWorker, transitionToGracefulShutdown, usesMethodDispatch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map