web-csv-toolbox 0.13.0-next-7d51d5285be9cffa5103de58469d8de0c98959d7 → 0.13.0-next-b21b6d89a7a3f18dcbf79ec04ffefde0d7ff4c4c

package/dist/execution/worker/helpers/ReusableWorkerPool.js

@@ -0,0 +1,238 @@
+import { createWorker } from './createWorker.web.js';
+
+class ReusableWorkerPool {
+  workers = [];
+  requestId = 0;
+  currentWorkerIndex = 0;
+  maxWorkers;
+  customWorkerURL;
+  pendingWorkerCreations = /* @__PURE__ */ new Map();
+  pendingCreationsByURL = /* @__PURE__ */ new Map();
+  disposed = false;
+  nextPendingId = 0;
+  /**
+   * Create a new ReusableWorkerPool.
+   *
+   * @param options - Configuration options for the pool
+   */
+  constructor(options = {}) {
+    this.maxWorkers = options.maxWorkers ?? 1;
+    this.customWorkerURL = options.workerURL;
+    if (this.maxWorkers < 1) {
+      throw new Error("maxWorkers must be at least 1");
+    }
+  }
+  /**
+   * Get a worker instance from the pool using round-robin load balancing.
+   *
+   * @param workerURL - Optional custom worker URL (overrides pool's workerURL)
+   * @returns A worker instance from the pool
+   * @internal
+   */
+  async getWorker(workerURL) {
+    if (this.disposed) {
+      throw new Error("Worker pool has been disposed");
+    }
+    const effectiveURL = workerURL ?? this.customWorkerURL;
+    const urlKey = effectiveURL ? String(effectiveURL) : "default";
+    const matchingWorkers = this.workers.filter(
+      (entry) => entry.url === urlKey
+    );
+    const totalWorkers = this.workers.length + this.pendingWorkerCreations.size;
+    if (totalWorkers < this.maxWorkers) {
+      const pendingId = `${urlKey}-${this.nextPendingId++}`;
+      const workerPromise = createWorker(effectiveURL).then((worker) => {
+        if (this.disposed) {
+          worker.terminate();
+          throw new Error("Worker pool was disposed during worker creation");
+        }
+        this.workers.push({ worker, url: urlKey });
+        this.pendingWorkerCreations.delete(pendingId);
+        const urlPendings2 = this.pendingCreationsByURL.get(urlKey);
+        if (urlPendings2) {
+          urlPendings2.delete(pendingId);
+          if (urlPendings2.size === 0) {
+            this.pendingCreationsByURL.delete(urlKey);
+          }
+        }
+        return worker;
+      }).catch((error) => {
+        this.pendingWorkerCreations.delete(pendingId);
+        const urlPendings2 = this.pendingCreationsByURL.get(urlKey);
+        if (urlPendings2) {
+          urlPendings2.delete(pendingId);
+          if (urlPendings2.size === 0) {
+            this.pendingCreationsByURL.delete(urlKey);
+          }
+        }
+        throw error;
+      });
+      this.pendingWorkerCreations.set(pendingId, workerPromise);
+      if (!this.pendingCreationsByURL.has(urlKey)) {
+        this.pendingCreationsByURL.set(urlKey, /* @__PURE__ */ new Set());
+      }
+      this.pendingCreationsByURL.get(urlKey).add(pendingId);
+      return workerPromise;
+    }
+    if (matchingWorkers.length === 0) {
+      const urlPendings2 = this.pendingCreationsByURL.get(urlKey);
+      if (urlPendings2 && urlPendings2.size > 0) {
+        const pendingId = Array.from(urlPendings2)[0];
+        const pendingWorker = this.pendingWorkerCreations.get(pendingId);
+        if (pendingWorker) {
+          return pendingWorker;
+        }
+      }
+      throw new Error(
+        `Worker pool is at maximum capacity (${this.maxWorkers}) and no worker with URL "${urlKey}" is available`
+      );
+    }
+    const urlPendings = this.pendingCreationsByURL.get(urlKey);
+    if (urlPendings && urlPendings.size > 0) {
+      const pendingId = Array.from(urlPendings)[0];
+      const pendingWorker = this.pendingWorkerCreations.get(pendingId);
+      if (pendingWorker) {
+        await pendingWorker;
+        const updatedMatchingWorkers = this.workers.filter(
+          (entry) => entry.url === urlKey
+        );
+        if (updatedMatchingWorkers.length === 0) {
+          throw new Error(
+            `Worker pool was disposed or worker creation failed for URL "${urlKey}"`
+          );
+        }
+      }
+    }
+    const matchingIndices = this.workers.map((entry, index) => entry.url === urlKey ? index : -1).filter((index) => index !== -1);
+    let selectedIndex = matchingIndices[0];
+    for (const index of matchingIndices) {
+      if (index >= this.currentWorkerIndex) {
+        selectedIndex = index;
+        break;
+      }
+    }
+    this.currentWorkerIndex = (selectedIndex + 1) % this.workers.length;
+    return this.workers[selectedIndex].worker;
+  }
+  /**
+   * Get the next request ID for this pool.
+   *
+   * @returns The next request ID
+   * @internal
+   */
+  getNextRequestId() {
+    return this.requestId++;
+  }
+  /**
+   * Release a worker back to the pool.
+   * For ReusableWorkerPool, this does nothing as workers are kept alive and reused.
+   *
+   * @param _worker - The worker to release
+   * @internal
+   */
+  releaseWorker(_worker) {
+  }
+  /**
+   * Get the current number of workers in the pool.
+   *
+   * @returns The number of active workers
+   */
+  get size() {
+    return this.workers.length;
+  }
+  /**
+   * Check if the pool has reached its maximum capacity.
+   *
+   * @returns True if the pool is at maximum capacity, false otherwise
+   *
+   * @remarks
+   * This method is useful for implementing early rejection of requests
+   * when the worker pool is saturated, preventing resource exhaustion.
+   *
+   * @example
+   * ```ts
+   * import { Hono } from 'hono';
+   * import { ReusableWorkerPool } from 'web-csv-toolbox';
+   *
+   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });
+   *
+   * app.post('/validate-csv', async (c) => {
+   *   // Early rejection if pool is saturated
+   *   if (pool.isFull()) {
+   *     return c.json({ error: 'Service busy, please try again later' }, 503);
+   *   }
+   *
+   *   // Process CSV...
+   * });
+   * ```
+   */
+  isFull() {
+    const totalWorkers = this.workers.length + this.pendingWorkerCreations.size;
+    return totalWorkers >= this.maxWorkers;
+  }
+  /**
+   * Terminate all workers in the pool and clean up resources.
+   *
+   * This method should be called when the pool is no longer needed,
+   * typically during application shutdown.
+   *
+   * @example
+   * ```ts
+   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });
+   *
+   * // When shutting down
+   * pool.terminate();
+   * ```
+   *
+   * @example With Hono
+   * ```ts
+   * import { Hono } from 'hono';
+   * import { ReusableWorkerPool } from 'web-csv-toolbox';
+   *
+   * const app = new Hono();
+   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });
+   *
+   * app.onShutdown(() => {
+   *   pool.terminate();
+   * });
+   * ```
+   */
+  terminate() {
+    this.disposed = true;
+    for (const entry of this.workers) {
+      entry.worker.terminate();
+    }
+    this.workers = [];
+    this.currentWorkerIndex = 0;
+    this.pendingWorkerCreations.clear();
+    this.pendingCreationsByURL.clear();
+  }
+  /**
+   * Dispose of the worker pool, terminating all workers.
+   *
+   * This method is called automatically when using the `using` syntax.
+   * For manual cleanup, use {@link terminate} instead.
+   *
+   * @example With `using` syntax (automatic cleanup)
+   * ```ts
+   * using pool = new ReusableWorkerPool({ maxWorkers: 4 });
+   * // Workers are automatically terminated when leaving scope
+   * ```
+   *
+   * @example Manual cleanup
+   * ```ts
+   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });
+   * try {
+   *   // Use pool
+   * } finally {
+   *   pool.terminate(); // Preferred over pool[Symbol.dispose]()
+   * }
+   * ```
+   */
+  [Symbol.dispose]() {
+    this.terminate();
+  }
+}
+
+export { ReusableWorkerPool };
+//# sourceMappingURL=ReusableWorkerPool.js.map

package/dist/execution/worker/helpers/ReusableWorkerPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReusableWorkerPool.js","sources":["../../../../src/execution/worker/helpers/ReusableWorkerPool.ts"],"sourcesContent":["import { createWorker } from \"#execution/worker/createWorker.js\";\nimport type { WorkerPool } from \"./WorkerPool.ts\";\n\n/**\n * Options for configuring the ReusableWorkerPool.\n */\nexport interface ReusableWorkerPoolOptions {\n  /**\n   * Maximum number of worker instances in the pool.\n   *\n   * @default 1\n   *\n   * @remarks\n   * **Security Recommendation:**\n   * For production applications that accept user uploads, set this to a reasonable limit (e.g., 2-4)\n   * to prevent resource exhaustion attacks. Without limits, malicious users could spawn unlimited\n   * workers by uploading multiple large CSV files simultaneously, leading to memory exhaustion and DoS.\n   *\n   * @example\n   * ```ts\n   * // Recommended for production\n   * const pool = new ReusableReusableWorkerPool({ maxWorkers: 4 });\n   * ```\n   */\n  maxWorkers?: number;\n\n  /**\n   * Custom worker URL to use for all workers in the pool.\n   */\n  workerURL?: string | URL;\n}\n\n/**\n * A pool that manages multiple worker instances with automatic cleanup and load balancing.\n *\n * This class implements the Disposable interface, allowing automatic\n * worker termination when the pool goes out of scope using the `using` syntax.\n *\n * @remarks\n * **⚠️ Security: Resource Protection**\n *\n * When building applications that accept user-uploaded CSV files, it is **strongly recommended**\n * to use `ReusableWorkerPool` with a limited `maxWorkers` setting to protect against resource exhaustion attacks.\n *\n * **Why this matters:**\n * - Attackers can upload multiple large CSV files simultaneously to overwhelm your application\n * - Without `ReusableWorkerPool` limits, each request could spawn unlimited workers\n * - This leads to excessive memory consumption, CPU exhaustion, and potential DoS\n *\n * **Recommended settings:**\n * - Web applications: `maxWorkers: 2-4`\n * - Server applications: `Math.min(4, os.cpus().length)`\n * - High-security environments: `maxWorkers: 1`\n *\n * See {@link https://github.com/kamiazya/web-csv-toolbox/blob/main/SECURITY.md | SECURITY.md} for detailed security guidelines.\n *\n * @example Basic usage with automatic cleanup (single worker)\n * ```ts\n * import { ReusableWorkerPool, parseString } from 'web-csv-toolbox';\n *\n * async function processCSV(csv: string) {\n *   using pool = new ReusableWorkerPool();\n *\n *   const records = [];\n *   for await (const record of parseString(csv, {\n *     execution: ['worker'],\n *     workerPool: pool\n *   })) {\n *     records.push(record);\n *   }\n *\n *   return records;\n *   // Worker is automatically terminated when leaving this scope\n * }\n * ```\n *\n * @example Parallel processing with multiple workers\n * ```ts\n * import { ReusableWorkerPool, parseString } from 'web-csv-toolbox';\n *\n * async function processMultipleCSVs(csvFiles: string[]) {\n *   using pool = new ReusableWorkerPool({ maxWorkers: 4 });\n *\n *   // Process all CSV files in parallel\n *   const results = await Promise.all(\n *     csvFiles.map(async (csv) => {\n *       const records = [];\n *       for await (const record of parseString(csv, {\n *         execution: ['worker'],\n *         workerPool: pool\n *       })) {\n *         records.push(record);\n *       }\n *       return records;\n *     })\n *   );\n *\n *   return results;\n *   // All workers are automatically terminated when leaving this scope\n * }\n * ```\n *\n * @example Manual cleanup (if not using `using` syntax)\n * ```ts\n * import { ReusableWorkerPool, parseString } from 'web-csv-toolbox';\n *\n * async function processCSV(csv: string) {\n *   const pool = new ReusableWorkerPool({ maxWorkers: 2 });\n *\n *   try {\n *     const records = [];\n *     for await (const record of parseString(csv, {\n *       execution: ['worker'],\n *       workerPool: pool\n *     })) {\n *       records.push(record);\n *     }\n *     return records;\n *   } finally {\n *     pool[Symbol.dispose]();\n *   }\n * }\n * ```\n */\ninterface WorkerEntry {\n  worker: Worker;\n  url: string;\n}\n\nexport class ReusableWorkerPool implements WorkerPool, Disposable {\n  private workers: WorkerEntry[] = [];\n  private requestId = 0;\n  private currentWorkerIndex = 0;\n  private readonly maxWorkers: number;\n  private readonly customWorkerURL?: string | URL;\n  private pendingWorkerCreations: Map<string, Promise<Worker>> = new Map();\n  private pendingCreationsByURL: Map<string, Set<string>> = new Map();\n  private disposed = false;\n  private nextPendingId = 0;\n\n  /**\n   * Create a new ReusableWorkerPool.\n   *\n   * @param options - Configuration options for the pool\n   */\n  constructor(options: ReusableWorkerPoolOptions = {}) {\n    this.maxWorkers = options.maxWorkers ?? 1;\n    this.customWorkerURL = options.workerURL;\n\n    if (this.maxWorkers < 1) {\n      throw new Error(\"maxWorkers must be at least 1\");\n    }\n  }\n\n  /**\n   * Get a worker instance from the pool using round-robin load balancing.\n   *\n   * @param workerURL - Optional custom worker URL (overrides pool's workerURL)\n   * @returns A worker instance from the pool\n   * @internal\n   */\n  async getWorker(workerURL?: string | URL): Promise<Worker> {\n    if (this.disposed) {\n      throw new Error(\"Worker pool has been disposed\");\n    }\n\n    const effectiveURL = workerURL ?? this.customWorkerURL;\n    const urlKey = effectiveURL ? String(effectiveURL) : \"default\";\n\n    // Find workers that match the requested URL\n    const matchingWorkers = this.workers.filter(\n      (entry) => entry.url === urlKey,\n    );\n\n    // Calculate total workers including pending creations\n    const totalWorkers = this.workers.length + this.pendingWorkerCreations.size;\n\n    // If pool is not yet full, create a new worker\n    if (totalWorkers < this.maxWorkers) {\n      // Generate unique key for this pending creation\n      const pendingId = `${urlKey}-${this.nextPendingId++}`;\n\n      // Create a new worker and cache the promise\n      const workerPromise = createWorker(effectiveURL)\n        .then((worker) => {\n          if (this.disposed) {\n            // If disposed during creation, terminate the new worker immediately\n            worker.terminate();\n            throw new Error(\"Worker pool was disposed during worker creation\");\n          }\n          this.workers.push({ worker, url: urlKey });\n          this.pendingWorkerCreations.delete(pendingId);\n          // Remove from URL-based tracking\n          const urlPendings = this.pendingCreationsByURL.get(urlKey);\n          if (urlPendings) {\n            urlPendings.delete(pendingId);\n            if (urlPendings.size === 0) {\n              this.pendingCreationsByURL.delete(urlKey);\n            }\n          }\n          return worker;\n        })\n        .catch((error) => {\n          // Clean up on error\n          this.pendingWorkerCreations.delete(pendingId);\n          const urlPendings = this.pendingCreationsByURL.get(urlKey);\n          if (urlPendings) {\n            urlPendings.delete(pendingId);\n            if (urlPendings.size === 0) {\n              this.pendingCreationsByURL.delete(urlKey);\n            }\n          }\n          throw error;\n        });\n\n      this.pendingWorkerCreations.set(pendingId, workerPromise);\n      // Track by URL for future matching\n      if (!this.pendingCreationsByURL.has(urlKey)) {\n        this.pendingCreationsByURL.set(urlKey, new Set());\n      }\n      this.pendingCreationsByURL.get(urlKey)!.add(pendingId);\n\n      return workerPromise;\n    }\n\n    // If pool is full and no matching workers exist, check for pending workers with this URL\n    if (matchingWorkers.length === 0) {\n      const urlPendings = this.pendingCreationsByURL.get(urlKey);\n      if (urlPendings && urlPendings.size > 0) {\n        // Wait for one of the pending workers with this URL\n        const pendingId = Array.from(urlPendings)[0];\n        const pendingWorker = this.pendingWorkerCreations.get(pendingId);\n        if (pendingWorker) {\n          return pendingWorker;\n        }\n      }\n\n      throw new Error(\n        `Worker pool is at maximum capacity (${this.maxWorkers}) and no worker with URL \"${urlKey}\" is available`,\n      );\n    }\n\n    // Wait for any pending worker creations with this URL to complete\n    const urlPendings = this.pendingCreationsByURL.get(urlKey);\n    if (urlPendings && urlPendings.size > 0) {\n      const pendingId = Array.from(urlPendings)[0];\n      const pendingWorker = this.pendingWorkerCreations.get(pendingId);\n      if (pendingWorker) {\n        await pendingWorker;\n        // Re-fetch matching workers as the pending creation may have completed\n        const updatedMatchingWorkers = this.workers.filter(\n          (entry) => entry.url === urlKey,\n        );\n        if (updatedMatchingWorkers.length === 0) {\n          throw new Error(\n            `Worker pool was disposed or worker creation failed for URL \"${urlKey}\"`,\n          );\n        }\n      }\n    }\n\n    // Use round-robin among matching workers\n    const matchingIndices = this.workers\n      .map((entry, index) => (entry.url === urlKey ? index : -1))\n      .filter((index) => index !== -1);\n\n    // Find next matching worker in round-robin order\n    let selectedIndex = matchingIndices[0];\n    for (const index of matchingIndices) {\n      if (index >= this.currentWorkerIndex) {\n        selectedIndex = index;\n        break;\n      }\n    }\n\n    this.currentWorkerIndex = (selectedIndex + 1) % this.workers.length;\n    return this.workers[selectedIndex].worker;\n  }\n\n  /**\n   * Get the next request ID for this pool.\n   *\n   * @returns The next request ID\n   * @internal\n   */\n  getNextRequestId(): number {\n    return this.requestId++;\n  }\n\n  /**\n   * Release a worker back to the pool.\n   * For ReusableWorkerPool, this does nothing as workers are kept alive and reused.\n   *\n   * @param _worker - The worker to release\n   * @internal\n   */\n  releaseWorker(_worker: Worker): void {\n    // ReusableWorkerPool keeps workers alive for reuse\n  }\n\n  /**\n   * Get the current number of workers in the pool.\n   *\n   * @returns The number of active workers\n   */\n  get size(): number {\n    return this.workers.length;\n  }\n\n  /**\n   * Check if the pool has reached its maximum capacity.\n   *\n   * @returns True if the pool is at maximum capacity, false otherwise\n   *\n   * @remarks\n   * This method is useful for implementing early rejection of requests\n   * when the worker pool is saturated, preventing resource exhaustion.\n   *\n   * @example\n   * ```ts\n   * import { Hono } from 'hono';\n   * import { ReusableWorkerPool } from 'web-csv-toolbox';\n   *\n   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });\n   *\n   * app.post('/validate-csv', async (c) => {\n   *   // Early rejection if pool is saturated\n   *   if (pool.isFull()) {\n   *     return c.json({ error: 'Service busy, please try again later' }, 503);\n   *   }\n   *\n   *   // Process CSV...\n   * });\n   * ```\n   */\n  isFull(): boolean {\n    const totalWorkers = this.workers.length + this.pendingWorkerCreations.size;\n    return totalWorkers >= this.maxWorkers;\n  }\n\n  /**\n   * Terminate all workers in the pool and clean up resources.\n   *\n   * This method should be called when the pool is no longer needed,\n   * typically during application shutdown.\n   *\n   * @example\n   * ```ts\n   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });\n   *\n   * // When shutting down\n   * pool.terminate();\n   * ```\n   *\n   * @example With Hono\n   * ```ts\n   * import { Hono } from 'hono';\n   * import { ReusableWorkerPool } from 'web-csv-toolbox';\n   *\n   * const app = new Hono();\n   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });\n   *\n   * app.onShutdown(() => {\n   *   pool.terminate();\n   * });\n   * ```\n   */\n  terminate(): void {\n    this.disposed = true;\n\n    // Terminate all existing workers\n    for (const entry of this.workers) {\n      entry.worker.terminate();\n    }\n    this.workers = [];\n    this.currentWorkerIndex = 0;\n\n    // Reject and clear all pending worker creations\n    // Note: The pending promises will handle cleanup via their catch blocks\n    this.pendingWorkerCreations.clear();\n    this.pendingCreationsByURL.clear();\n  }\n\n  /**\n   * Dispose of the worker pool, terminating all workers.\n   *\n   * This method is called automatically when using the `using` syntax.\n   * For manual cleanup, use {@link terminate} instead.\n   *\n   * @example With `using` syntax (automatic cleanup)\n   * ```ts\n   * using pool = new ReusableWorkerPool({ maxWorkers: 4 });\n   * // Workers are automatically terminated when leaving scope\n   * ```\n   *\n   * @example Manual cleanup\n   * ```ts\n   * const pool = new ReusableWorkerPool({ maxWorkers: 4 });\n   * try {\n   *   // Use pool\n   * } finally {\n   *   pool.terminate(); // Preferred over pool[Symbol.dispose]()\n   * }\n   * ```\n   */\n  [Symbol.dispose](): void {\n    this.terminate();\n  }\n}\n"],"names":["urlPendings"],"mappings":"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"}

package/dist/execution/worker/helpers/TransientWorkerPool.d.ts

@@ -0,0 +1,89 @@
+import { WorkerPool } from './WorkerPool.ts';
+/**
+ * Options for configuring the TransientWorkerPool.
+ */
+export interface TransientWorkerPoolOptions {
+    /**
+     * Custom worker URL to use for all workers in the pool.
+     */
+    workerURL?: string | URL;
+}
+/**
+ * A pool that creates transient workers which are automatically terminated after each job.
+ *
+ * This pool is designed for the default worker pool to prevent workers from staying alive
+ * and blocking process exit. Each worker is terminated immediately after the job completes.
+ *
+ * @remarks
+ * **Design Rationale:**
+ *
+ * Unlike {@link ReusableWorkerPool} which keeps workers alive for reuse, `TransientWorkerPool`
+ * terminates workers after each job. This is specifically designed for the internal default pool
+ * to avoid requiring users to call `terminateWorkers()` for process cleanup.
+ *
+ * **Characteristics:**
+ * - Workers are created on-demand
+ * - Workers are terminated immediately after job completion
+ * - No persistent worker instances
+ * - Prevents process from hanging due to active workers
+ *
+ * @internal
+ */
+export declare class TransientWorkerPool implements WorkerPool, Disposable {
+    private requestId;
+    private readonly customWorkerURL?;
+    /**
+     * Create a new TransientWorkerPool.
+     *
+     * @param options - Configuration options for the pool
+     */
+    constructor(options?: TransientWorkerPoolOptions);
+    /**
+     * Get a worker instance.
+     * Always creates a new worker for transient usage.
+     *
+     * @param workerURL - Optional custom worker URL (overrides pool's workerURL)
+     * @returns A new worker instance
+     * @internal
+     */
+    getWorker(workerURL?: string | URL): Promise<Worker>;
+    /**
+     * Get the next request ID for this pool.
+     *
+     * @returns The next request ID
+     * @internal
+     */
+    getNextRequestId(): number;
+    /**
+     * Release a worker back to the pool.
+     * For TransientWorkerPool, this terminates the worker immediately.
+     *
+     * @param worker - The worker to release
+     * @internal
+     */
+    releaseWorker(worker: Worker): void;
+    /**
+     * Get the current number of workers in the pool.
+     * For TransientWorkerPool, this is always 0 as workers are not kept alive.
+     *
+     * @returns Always 0
+     */
+    get size(): number;
+    /**
+     * Check if the pool has reached its maximum capacity.
+     * For TransientWorkerPool, this is always false as workers are transient.
+     *
+     * @returns Always false
+     */
+    isFull(): boolean;
+    /**
+     * Terminate all workers in the pool.
+     * For TransientWorkerPool, this is a no-op as workers are not kept alive.
+     */
+    terminate(): void;
+    /**
+     * Dispose of the worker pool.
+     * For TransientWorkerPool, this is a no-op as workers are not kept alive.
+     */
+    [Symbol.dispose](): void;
+}

package/dist/execution/worker/helpers/WorkerManager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Get or create a worker instance from the default pool.
+ * If WorkerPool is provided in options, use it instead of default pool.
+ *
+ * @internal
+ */
+export declare function getWorker(workerURL?: string | URL): Promise<Worker>;
+/**
+ * Get next request ID for message tracking from the default pool.
+ *
+ * @internal
+ */
+export declare function getNextRequestId(): number;
+/**
+ * Release a worker back to the default pool.
+ * For the default transient pool, this terminates the worker.
+ *
+ * @internal
+ */
+export declare function releaseWorker(worker: Worker): void;
+/**
+ * Get the current size of the default pool.
+ * This is mainly for testing purposes.
+ *
+ * @internal
+ */
+export declare function getPoolSize(): number;

package/dist/execution/worker/helpers/WorkerPool.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Common interface for worker pools.
+ * Both ReusableWorkerPool and TransientWorkerPool implement this interface.
+ *
+ * @remarks
+ * This interface defines the contract for worker pool implementations.
+ * Users typically use {@link ReusableWorkerPool} for persistent worker pools,
+ * while the internal default pool uses {@link TransientWorkerPool} for automatic cleanup.
+ */
+export interface WorkerPool {
+    /**
+     * Get a worker instance from the pool.
+     *
+     * @param workerURL - Optional custom worker URL
+     * @returns A worker instance
+     */
+    getWorker(workerURL?: string | URL): Promise<Worker>;
+    /**
+     * Get the next request ID for this pool.
+     *
+     * @returns The next request ID
+     */
+    getNextRequestId(): number;
+    /**
+     * Release a worker back to the pool.
+     *
+     * @param worker - The worker to release
+     */
+    releaseWorker(worker: Worker): void;
+    /**
+     * Get the current number of workers in the pool.
+     *
+     * @returns The number of active workers
+     */
+    readonly size: number;
+    /**
+     * Check if the pool has reached its maximum capacity.
+     *
+     * @returns True if the pool is at maximum capacity, false otherwise
+     */
+    isFull(): boolean;
+    /**
+     * Terminate all workers in the pool and clean up resources.
+     */
+    terminate(): void;
+    /**
+     * Dispose of the worker pool, terminating all workers.
+     */
+    [Symbol.dispose](): void;
+}

package/dist/execution/worker/helpers/WorkerSession.d.ts

@@ -0,0 +1,78 @@
+import { WorkerPool } from './WorkerPool.ts';
+/**
+ * Options for creating a WorkerSession.
+ */
+export interface WorkerSessionOptions {
+    /**
+     * Custom worker URL.
+     */
+    workerURL?: string | URL;
+    /**
+     * Worker pool for reusable workers.
+     */
+    workerPool?: WorkerPool;
+}
+/**
+ * WorkerSession manages the lifecycle of a single worker instance.
+ *
+ * Hybrid approach:
+ * - If workerPool is provided: Use pool's worker (reusable, manual pool cleanup)
+ * - If workerPool is NOT provided: Create disposable worker (auto-cleanup on dispose)
+ *
+ * Use `using` syntax for automatic cleanup:
+ * ```typescript
+ * using session = await WorkerSession.create();
+ * const records = await sendWorkerMessage(session, { ... });
+ * // Worker is automatically terminated when leaving scope (if disposable)
+ * ```
+ *
+ * @example Disposable worker (one-time use)
+ * ```typescript
+ * using session = await WorkerSession.create();
+ * const records = await sendWorkerMessage(session.getWorker(), {
+ *   id: session.getNextRequestId(),
+ *   type: "parseString",
+ *   data: csv,
+ *   options: serializeOptions(options),
+ * });
+ * // Worker automatically terminated
+ * ```
+ *
+ * @example With WorkerPool (reusable)
+ * ```typescript
+ * using pool = new WorkerPool({ maxWorkers: 3 });
+ * using session = await WorkerSession.create({ workerPool: pool });
+ * const records1 = await sendWorkerMessage(session.getWorker(), { ... });
+ * const records2 = await sendWorkerMessage(session.getWorker(), { ... });
+ * // Worker returned to pool, pool cleanup happens when pool disposes
+ * ```
+ */
+export declare class WorkerSession implements Disposable {
+    private worker;
+    private requestIdCounter;
+    private readonly workerPool?;
+    private constructor();
+    /**
+     * Create a new WorkerSession.
+     *
+     * @param options Session options
+     * @returns Promise that resolves to a WorkerSession instance
+     */
+    static create(options?: WorkerSessionOptions): Promise<WorkerSession>;
+    /**
+     * Get the worker instance.
+     */
+    getWorker(): Worker;
+    /**
+     * Get the next request ID for this session.
+     * - If using WorkerPool: Delegates to pool's getNextRequestId()
+     * - If disposable: Uses internal counter
+     */
+    getNextRequestId(): number;
+    /**
+     * Dispose the session.
+     * - If using a pool: Releases the worker back to the pool (behavior depends on pool type)
+     * - If disposable: Terminates the worker
+     */
+    [Symbol.dispose](): void;
+}

package/dist/execution/worker/helpers/WorkerSession.js

@@ -0,0 +1,58 @@
+import { createWorker } from './createWorker.web.js';
+
+class WorkerSession {
+  worker;
+  requestIdCounter = 0;
+  workerPool;
+  constructor(worker, workerPool) {
+    this.worker = worker;
+    this.workerPool = workerPool;
+  }
+  /**
+   * Create a new WorkerSession.
+   *
+   * @param options Session options
+   * @returns Promise that resolves to a WorkerSession instance
+   */
+  static async create(options) {
+    let worker;
+    if (options?.workerPool) {
+      worker = await options.workerPool.getWorker(options.workerURL);
+      return new WorkerSession(worker, options.workerPool);
+    }
+    worker = await createWorker(options?.workerURL);
+    return new WorkerSession(worker);
+  }
+  /**
+   * Get the worker instance.
+   */
+  getWorker() {
+    return this.worker;
+  }
+  /**
+   * Get the next request ID for this session.
+   * - If using WorkerPool: Delegates to pool's getNextRequestId()
+   * - If disposable: Uses internal counter
+   */
+  getNextRequestId() {
+    if (this.workerPool) {
+      return this.workerPool.getNextRequestId();
+    }
+    return this.requestIdCounter++;
+  }
+  /**
+   * Dispose the session.
+   * - If using a pool: Releases the worker back to the pool (behavior depends on pool type)
+   * - If disposable: Terminates the worker
+   */
+  [Symbol.dispose]() {
+    if (this.workerPool) {
+      this.workerPool.releaseWorker(this.worker);
+    } else {
+      this.worker.terminate();
+    }
+  }
+}
+
+export { WorkerSession };
+//# sourceMappingURL=WorkerSession.js.map

package/dist/execution/worker/helpers/WorkerSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerSession.js","sources":["../../../../src/execution/worker/helpers/WorkerSession.ts"],"sourcesContent":["import { createWorker } from \"#execution/worker/createWorker.js\";\nimport type { WorkerPool } from \"./WorkerPool.ts\";\n\n/**\n * Options for creating a WorkerSession.\n */\nexport interface WorkerSessionOptions {\n  /**\n   * Custom worker URL.\n   */\n  workerURL?: string | URL;\n\n  /**\n   * Worker pool for reusable workers.\n   */\n  workerPool?: WorkerPool;\n}\n\n/**\n * WorkerSession manages the lifecycle of a single worker instance.\n *\n * Hybrid approach:\n * - If workerPool is provided: Use pool's worker (reusable, manual pool cleanup)\n * - If workerPool is NOT provided: Create disposable worker (auto-cleanup on dispose)\n *\n * Use `using` syntax for automatic cleanup:\n * ```typescript\n * using session = await WorkerSession.create();\n * const records = await sendWorkerMessage(session, { ... });\n * // Worker is automatically terminated when leaving scope (if disposable)\n * ```\n *\n * @example Disposable worker (one-time use)\n * ```typescript\n * using session = await WorkerSession.create();\n * const records = await sendWorkerMessage(session.getWorker(), {\n *   id: session.getNextRequestId(),\n *   type: \"parseString\",\n *   data: csv,\n *   options: serializeOptions(options),\n * });\n * // Worker automatically terminated\n * ```\n *\n * @example With WorkerPool (reusable)\n * ```typescript\n * using pool = new WorkerPool({ maxWorkers: 3 });\n * using session = await WorkerSession.create({ workerPool: pool });\n * const records1 = await sendWorkerMessage(session.getWorker(), { ... });\n * const records2 = await sendWorkerMessage(session.getWorker(), { ... });\n * // Worker returned to pool, pool cleanup happens when pool disposes\n * ```\n */\nexport class WorkerSession implements Disposable {\n  private worker: Worker;\n  private requestIdCounter = 0;\n  private readonly workerPool?: WorkerPool;\n\n  private constructor(worker: Worker, workerPool?: WorkerPool) {\n    this.worker = worker;\n    this.workerPool = workerPool;\n  }\n\n  /**\n   * Create a new WorkerSession.\n   *\n   * @param options Session options\n   * @returns Promise that resolves to a WorkerSession instance\n   */\n  static async create(options?: WorkerSessionOptions): Promise<WorkerSession> {\n    let worker: Worker;\n    if (options?.workerPool) {\n      // Use worker from pool\n      worker = await options.workerPool.getWorker(options.workerURL);\n      return new WorkerSession(worker, options.workerPool);\n    }\n    // Create disposable worker\n    worker = await createWorker(options?.workerURL);\n    return new WorkerSession(worker);\n  }\n\n  /**\n   * Get the worker instance.\n   */\n  getWorker(): Worker {\n    return this.worker;\n  }\n\n  /**\n   * Get the next request ID for this session.\n   * - If using WorkerPool: Delegates to pool's getNextRequestId()\n   * - If disposable: Uses internal counter\n   */\n  getNextRequestId(): number {\n    if (this.workerPool) {\n      return this.workerPool.getNextRequestId();\n    }\n    return this.requestIdCounter++;\n  }\n\n  /**\n   * Dispose the session.\n   * - If using a pool: Releases the worker back to the pool (behavior depends on pool type)\n   * - If disposable: Terminates the worker\n   */\n  [Symbol.dispose](): void {\n    if (this.workerPool) {\n      this.workerPool.releaseWorker(this.worker);\n    } else {\n      this.worker.terminate();\n    }\n  }\n}\n"],"names":[],"mappings":";;AAqDO,MAAM,aAAA,CAAoC;AAAA,EACvC,MAAA;AAAA,EACA,gBAAA,GAAmB,CAAA;AAAA,EACV,UAAA;AAAA,EAET,WAAA,CAAY,QAAgB,UAAA,EAAyB;AAC3D,IAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AACd,IAAA,IAAA,CAAK,UAAA,GAAa,UAAA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,aAAa,OAAO,OAAA,EAAwD;AAC1E,IAAA,IAAI,MAAA;AACJ,IAAA,IAAI,SAAS,UAAA,EAAY;AAEvB,MAAA,MAAA,GAAS,MAAM,OAAA,CAAQ,UAAA,CAAW,SAAA,CAAU,QAAQ,SAAS,CAAA;AAC7D,MAAA,OAAO,IAAI,aAAA,CAAc,MAAA,EAAQ,OAAA,CAAQ,UAAU,CAAA;AAAA,IACrD;AAEA,IAAA,MAAA,GAAS,MAAM,YAAA,CAAa,OAAA,EAAS,SAAS,CAAA;AAC9C,IAAA,OAAO,IAAI,cAAc,MAAM,CAAA;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GAAoB;AAClB,IAAA,OAAO,IAAA,CAAK,MAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,gBAAA,GAA2B;AACzB,IAAA,IAAI,KAAK,UAAA,EAAY;AACnB,MAAA,OAAO,IAAA,CAAK,WAAW,gBAAA,EAAiB;AAAA,IAC1C;AACA,IAAA,OAAO,IAAA,CAAK,gBAAA,EAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,CAAC,MAAA,CAAO,OAAO,CAAA,GAAU;AACvB,IAAA,IAAI,KAAK,UAAA,EAAY;AACnB,MAAA,IAAA,CAAK,UAAA,CAAW,aAAA,CAAc,IAAA,CAAK,MAAM,CAAA;AAAA,IAC3C,CAAA,MAAO;AACL,MAAA,IAAA,CAAK,OAAO,SAAA,EAAU;AAAA,IACxB;AAAA,EACF;AACF;;;;"}

package/dist/execution/worker/helpers/createWorker.node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a Worker instance for Node.js environment.
+ *
+ * @internal
+ * @param workerURL Custom worker URL or undefined to use bundled worker
+ * @returns Worker instance
+ */
+export declare function createWorker(workerURL?: string | URL): Promise<Worker>;

package/dist/execution/worker/helpers/createWorker.node.js

@@ -0,0 +1,15 @@
+async function createWorker(workerURL) {
+  const { Worker } = await import('node:worker_threads');
+  const { fileURLToPath } = await import('node:url');
+  const { dirname, join } = await import('node:path');
+  if (workerURL) {
+    return new Worker(workerURL, { type: "module" });
+  }
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFilePath);
+  const workerPath = join(currentDir, "worker.node.js");
+  return new Worker(workerPath, { type: "module" });
+}
+
+export { createWorker };
+//# sourceMappingURL=createWorker.node.js.map

package/dist/execution/worker/helpers/createWorker.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorker.node.js","sources":["../../../../src/execution/worker/helpers/createWorker.node.ts"],"sourcesContent":["/**\n * Create a Worker instance for Node.js environment.\n *\n * @internal\n * @param workerURL Custom worker URL or undefined to use bundled worker\n * @returns Worker instance\n */\nexport async function createWorker(workerURL?: string | URL): Promise<Worker> {\n  // Dynamic import for Node.js Worker and URL utilities\n  // @ts-ignore: node:worker_threads is only available in Node.js\n  const { Worker } = await import(\"node:worker_threads\");\n  // @ts-ignore: node:url is only available in Node.js\n  const { fileURLToPath } = await import(\"node:url\");\n  // @ts-ignore: node:path is only available in Node.js\n  const { dirname, join } = await import(\"node:path\");\n\n  if (workerURL) {\n    // Use provided worker URL\n    return new Worker(workerURL, { type: \"module\" });\n  }\n\n  // Compute worker.node.js path relative to this module\n  // In Node.js, import.meta.url is a file:// URL pointing to this module\n  const currentFilePath = fileURLToPath(import.meta.url);\n  const currentDir = dirname(currentFilePath);\n  const workerPath = join(currentDir, \"worker.node.js\");\n\n  // @ts-ignore\n  return new Worker(workerPath, { type: \"module\" });\n}\n"],"names":[],"mappings":"AAOA,eAAsB,aAAa,SAAA,EAA2C;AAG5E,EAAA,MAAM,EAAE,MAAA,EAAO,GAAI,MAAM,OAAO,qBAAqB,CAAA;AAErD,EAAA,MAAM,EAAE,aAAA,EAAc,GAAI,MAAM,OAAO,UAAU,CAAA;AAEjD,EAAA,MAAM,EAAE,OAAA,EAAS,IAAA,EAAK,GAAI,MAAM,OAAO,WAAW,CAAA;AAElD,EAAA,IAAI,SAAA,EAAW;AAEb,IAAA,OAAO,IAAI,MAAA,CAAO,SAAA,EAAW,EAAE,IAAA,EAAM,UAAU,CAAA;AAAA,EACjD;AAIA,EAAA,MAAM,eAAA,GAAkB,aAAA,CAAc,MAAA,CAAA,IAAA,CAAY,GAAG,CAAA;AACrD,EAAA,MAAM,UAAA,GAAa,QAAQ,eAAe,CAAA;AAC1C,EAAA,MAAM,UAAA,GAAa,IAAA,CAAK,UAAA,EAAY,gBAAgB,CAAA;AAGpD,EAAA,OAAO,IAAI,MAAA,CAAO,UAAA,EAAY,EAAE,IAAA,EAAM,UAAU,CAAA;AAClD;;;;"}

package/dist/execution/worker/helpers/createWorker.web.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a Worker instance for browser/Deno environment.
+ *
+ * @internal
+ * @param workerURL Custom worker URL or undefined to use bundled worker
+ * @returns Worker instance
+ */
+export declare function createWorker(workerURL?: string | URL): Promise<Worker>;

package/dist/execution/worker/helpers/createWorker.web.js

@@ -0,0 +1,11 @@
+async function createWorker(workerURL) {
+  const url = workerURL || new URL(
+    /* @vite-ignore */
+    "./worker.web.js",
+    import.meta.url
+  );
+  return new Worker(url, { type: "module" });
+}
+
+export { createWorker };
+//# sourceMappingURL=createWorker.web.js.map

package/dist/execution/worker/helpers/createWorker.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorker.web.js","sources":["../../../../src/execution/worker/helpers/createWorker.web.ts"],"sourcesContent":["/**\n * Create a Worker instance for browser/Deno environment.\n *\n * @internal\n * @param workerURL Custom worker URL or undefined to use bundled worker\n * @returns Worker instance\n */\nexport async function createWorker(workerURL?: string | URL): Promise<Worker> {\n  // Use @vite-ignore to prevent Vite from inlining the worker as a data URL\n  // In production, import.meta.url points to dist/execution/worker/helpers/createWorker.web.js\n  // so \"./worker.web.js\" correctly resolves to dist/execution/worker/helpers/worker.web.js\n  const url =\n    workerURL || new URL(/* @vite-ignore */ \"./worker.web.js\", import.meta.url);\n  return new Worker(url, { type: \"module\" });\n}\n"],"names":[],"mappings":"AAOA,eAAsB,aAAa,SAAA,EAA2C;AAI5E,EAAA,MAAM,GAAA,GACJ,aAAa,IAAI,GAAA;AAAA;AAAA,IAAuB,iBAAA;AAAA,IAAmB,MAAA,CAAA,IAAA,CAAY;AAAA,GAAG;AAC5E,EAAA,OAAO,IAAI,MAAA,CAAO,GAAA,EAAK,EAAE,IAAA,EAAM,UAAU,CAAA;AAC3C;;;;"}

package/dist/execution/worker/helpers/worker.node.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/execution/worker/helpers/worker.node.js

@@ -0,0 +1,11 @@
+import { parentPort } from 'node:worker_threads';
+import { createMessageHandler } from './worker.shared.js';
+
+if (!parentPort) {
+  throw new Error("This module must be run in a Worker Thread context");
+}
+const messageHandler = createMessageHandler(parentPort);
+parentPort.on("message", (message) => {
+  messageHandler(message);
+});
+//# sourceMappingURL=worker.node.js.map