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

package/dist/execution/InternalEngineConfig.d.ts

@@ -0,0 +1,89 @@
+import { EngineConfig, EngineFallbackInfo, WorkerCommunicationStrategy } from '../common/types.ts';
+import { WorkerPool } from './worker/helpers/WorkerPool.ts';
+/**
+ * Engine flags bitmask (internal use).
+ * @internal
+ */
+export declare enum EngineFlags {
+    WORKER = 1,// 0b00001 = 1
+    WASM = 2,// 0b00010 = 2
+    STREAM_TRANSFER = 4,// 0b00100 = 4
+    MESSAGE_STREAMING = 8,// 0b01000 = 8
+    STRICT = 16
+}
+/**
+ * Internal engine configuration manager.
+ *
+ * Manages engine configuration using bitmask for efficient flag operations.
+ *
+ * @internal
+ */
+export declare class InternalEngineConfig {
+    private bitmask;
+    readonly workerURL?: string | URL;
+    readonly workerPool?: WorkerPool;
+    readonly onFallback?: (info: EngineFallbackInfo) => void;
+    constructor(config?: EngineConfig);
+    /**
+     * Private constructor for cloning.
+     */
+    private static fromBitmask;
+    private parse;
+    private applyDefaults;
+    private validate;
+    /**
+     * Check if a flag is set.
+     */
+    private hasFlag;
+    /**
+     * Add a flag.
+     */
+    private addFlag;
+    /**
+     * Remove a flag.
+     */
+    private removeFlag;
+    /**
+     * Check if worker execution is enabled.
+     */
+    hasWorker(): boolean;
+    /**
+     * Check if WASM is enabled.
+     */
+    hasWasm(): boolean;
+    /**
+     * Check if stream transfer is enabled.
+     */
+    hasStreamTransfer(): boolean;
+    /**
+     * Check if message streaming is enabled.
+     */
+    hasMessageStreaming(): boolean;
+    /**
+     * Check if strict mode is enabled.
+     */
+    hasStrict(): boolean;
+    /**
+     * Get worker communication strategy.
+     */
+    getWorkerStrategy(): WorkerCommunicationStrategy | undefined;
+    /**
+     * Create a fallback configuration.
+     *
+     * Converts stream-transfer to message-streaming and disables strict mode.
+     */
+    createFallbackConfig(): InternalEngineConfig;
+    /**
+     * Convert to EngineConfig.
+     */
+    toConfig(): EngineConfig;
+    /**
+     * Get bitmask for debugging.
+     * @internal
+     */
+    getBitmask(): number;
+    /**
+     * String representation for debugging.
+     */
+    toString(): string;
+}

package/dist/execution/InternalEngineConfig.js

@@ -0,0 +1,175 @@
+class InternalEngineConfig {
+  bitmask = 0;
+  workerURL;
+  workerPool;
+  onFallback;
+  constructor(config) {
+    if (config) {
+      this.workerURL = config.workerURL;
+      this.workerPool = config.workerPool;
+      this.onFallback = config.onFallback;
+      this.parse(config);
+    }
+    this.applyDefaults();
+    this.validate();
+  }
+  /**
+   * Private constructor for cloning.
+   */
+  static fromBitmask(bitmask, workerURL, workerPool, onFallback) {
+    const instance = Object.create(InternalEngineConfig.prototype);
+    instance.bitmask = bitmask;
+    instance.workerURL = workerURL;
+    instance.workerPool = workerPool;
+    instance.onFallback = onFallback;
+    return instance;
+  }
+  parse(config) {
+    if (config.worker) {
+      this.bitmask |= 1 /* WORKER */;
+    }
+    if (config.wasm) {
+      this.bitmask |= 2 /* WASM */;
+    }
+    if (config.workerStrategy === "stream-transfer") {
+      this.bitmask |= 4 /* STREAM_TRANSFER */;
+    } else if (config.workerStrategy === "message-streaming") {
+      this.bitmask |= 8 /* MESSAGE_STREAMING */;
+    }
+    if (config.strict) {
+      this.bitmask |= 16 /* STRICT */;
+    }
+  }
+  applyDefaults() {
+    if (this.hasWorker() && !this.hasStreamTransfer() && !this.hasMessageStreaming()) {
+      this.bitmask |= 8 /* MESSAGE_STREAMING */;
+    }
+  }
+  validate() {
+    if ((this.hasStreamTransfer() || this.hasMessageStreaming()) && !this.hasWorker()) {
+      throw new Error("workerStrategy requires worker: true in engine config");
+    }
+    if (this.hasStrict() && !this.hasStreamTransfer()) {
+      throw new Error(
+        'strict requires workerStrategy: "stream-transfer" in engine config'
+      );
+    }
+  }
+  /**
+   * Check if a flag is set.
+   */
+  hasFlag(flag) {
+    return (this.bitmask & flag) !== 0;
+  }
+  /**
+   * Add a flag.
+   */
+  addFlag(flag) {
+    this.bitmask |= flag;
+  }
+  /**
+   * Remove a flag.
+   */
+  removeFlag(flag) {
+    this.bitmask &= ~flag;
+  }
+  /**
+   * Check if worker execution is enabled.
+   */
+  hasWorker() {
+    return this.hasFlag(1 /* WORKER */);
+  }
+  /**
+   * Check if WASM is enabled.
+   */
+  hasWasm() {
+    return this.hasFlag(2 /* WASM */);
+  }
+  /**
+   * Check if stream transfer is enabled.
+   */
+  hasStreamTransfer() {
+    return this.hasFlag(4 /* STREAM_TRANSFER */);
+  }
+  /**
+   * Check if message streaming is enabled.
+   */
+  hasMessageStreaming() {
+    return this.hasFlag(8 /* MESSAGE_STREAMING */);
+  }
+  /**
+   * Check if strict mode is enabled.
+   */
+  hasStrict() {
+    return this.hasFlag(16 /* STRICT */);
+  }
+  /**
+   * Get worker communication strategy.
+   */
+  getWorkerStrategy() {
+    if (this.hasStreamTransfer()) {
+      return "stream-transfer";
+    }
+    if (this.hasMessageStreaming()) {
+      return "message-streaming";
+    }
+    return void 0;
+  }
+  /**
+   * Create a fallback configuration.
+   *
+   * Converts stream-transfer to message-streaming and disables strict mode.
+   */
+  createFallbackConfig() {
+    let fallbackBitmask = this.bitmask;
+    if ((fallbackBitmask & 4 /* STREAM_TRANSFER */) !== 0) {
+      fallbackBitmask &= -5 /* STREAM_TRANSFER */;
+      fallbackBitmask |= 8 /* MESSAGE_STREAMING */;
+    }
+    if ((fallbackBitmask & 16 /* STRICT */) !== 0) {
+      fallbackBitmask &= -17 /* STRICT */;
+    }
+    return InternalEngineConfig.fromBitmask(
+      fallbackBitmask,
+      this.workerURL,
+      this.workerPool,
+      this.onFallback
+    );
+  }
+  /**
+   * Convert to EngineConfig.
+   */
+  toConfig() {
+    return {
+      worker: this.hasWorker() || void 0,
+      workerURL: this.workerURL,
+      workerPool: this.workerPool,
+      wasm: this.hasWasm() || void 0,
+      workerStrategy: this.getWorkerStrategy(),
+      strict: this.hasStrict() || void 0,
+      onFallback: this.onFallback
+    };
+  }
+  /**
+   * Get bitmask for debugging.
+   * @internal
+   */
+  getBitmask() {
+    return this.bitmask;
+  }
+  /**
+   * String representation for debugging.
+   */
+  toString() {
+    const parts = [];
+    if (this.hasWorker()) parts.push("worker");
+    if (this.hasWasm()) parts.push("wasm");
+    if (this.hasStreamTransfer()) parts.push("stream-transfer");
+    if (this.hasMessageStreaming()) parts.push("message-streaming");
+    if (this.hasStrict()) parts.push("strict");
+    return parts.join(" + ") || "main";
+  }
+}
+
+export { InternalEngineConfig };
+//# sourceMappingURL=InternalEngineConfig.js.map

package/dist/execution/InternalEngineConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalEngineConfig.js","sources":["../../src/execution/InternalEngineConfig.ts"],"sourcesContent":["import type {\n  EngineConfig,\n  EngineFallbackInfo,\n  WorkerCommunicationStrategy,\n} from \"../common/types.ts\";\nimport type { WorkerPool } from \"./worker/helpers/WorkerPool.ts\";\n\n/**\n * Engine flags bitmask (internal use).\n * @internal\n */\nexport enum EngineFlags {\n  WORKER = 1 << 0, // 0b00001 = 1\n  WASM = 1 << 1, // 0b00010 = 2\n  STREAM_TRANSFER = 1 << 2, // 0b00100 = 4\n  MESSAGE_STREAMING = 1 << 3, // 0b01000 = 8\n  STRICT = 1 << 4, // 0b10000 = 16\n}\n\n/**\n * Internal engine configuration manager.\n *\n * Manages engine configuration using bitmask for efficient flag operations.\n *\n * @internal\n */\nexport class InternalEngineConfig {\n  private bitmask = 0;\n  readonly workerURL?: string | URL;\n  readonly workerPool?: WorkerPool;\n  readonly onFallback?: (info: EngineFallbackInfo) => void;\n\n  constructor(config?: EngineConfig) {\n    if (config) {\n      this.workerURL = config.workerURL;\n      this.workerPool = config.workerPool;\n      this.onFallback = config.onFallback;\n      this.parse(config);\n    }\n\n    this.applyDefaults();\n    this.validate();\n  }\n\n  /**\n   * Private constructor for cloning.\n   */\n  private static fromBitmask(\n    bitmask: number,\n    workerURL?: string | URL,\n    workerPool?: WorkerPool,\n    onFallback?: (info: EngineFallbackInfo) => void,\n  ): InternalEngineConfig {\n    const instance = Object.create(InternalEngineConfig.prototype);\n    instance.bitmask = bitmask;\n    (instance as { workerURL?: string | URL }).workerURL = workerURL;\n    (instance as { workerPool?: WorkerPool }).workerPool = workerPool;\n    (\n      instance as { onFallback?: (info: EngineFallbackInfo) => void }\n    ).onFallback = onFallback;\n    return instance;\n  }\n\n  private parse(config: EngineConfig): void {\n    if (config.worker) {\n      this.bitmask |= EngineFlags.WORKER;\n    }\n\n    if (config.wasm) {\n      this.bitmask |= EngineFlags.WASM;\n    }\n\n    if (config.workerStrategy === \"stream-transfer\") {\n      this.bitmask |= EngineFlags.STREAM_TRANSFER;\n    } else if (config.workerStrategy === \"message-streaming\") {\n      this.bitmask |= EngineFlags.MESSAGE_STREAMING;\n    }\n\n    if (config.strict) {\n      this.bitmask |= EngineFlags.STRICT;\n    }\n  }\n\n  private applyDefaults(): void {\n    // Worker without explicit strategy -> default to message-streaming\n    if (\n      this.hasWorker() &&\n      !this.hasStreamTransfer() &&\n      !this.hasMessageStreaming()\n    ) {\n      this.bitmask |= EngineFlags.MESSAGE_STREAMING;\n    }\n  }\n\n  private validate(): void {\n    // workerStrategy requires worker\n    if (\n      (this.hasStreamTransfer() || this.hasMessageStreaming()) &&\n      !this.hasWorker()\n    ) {\n      throw new Error(\"workerStrategy requires worker: true in engine config\");\n    }\n\n    // strict requires stream-transfer\n    if (this.hasStrict() && !this.hasStreamTransfer()) {\n      throw new Error(\n        'strict requires workerStrategy: \"stream-transfer\" in engine config',\n      );\n    }\n  }\n\n  /**\n   * Check if a flag is set.\n   */\n  private hasFlag(flag: EngineFlags): boolean {\n    return (this.bitmask & flag) !== 0;\n  }\n\n  /**\n   * Add a flag.\n   */\n  private addFlag(flag: EngineFlags): void {\n    this.bitmask |= flag;\n  }\n\n  /**\n   * Remove a flag.\n   */\n  private removeFlag(flag: EngineFlags): void {\n    this.bitmask &= ~flag;\n  }\n\n  /**\n   * Check if worker execution is enabled.\n   */\n  hasWorker(): boolean {\n    return this.hasFlag(EngineFlags.WORKER);\n  }\n\n  /**\n   * Check if WASM is enabled.\n   */\n  hasWasm(): boolean {\n    return this.hasFlag(EngineFlags.WASM);\n  }\n\n  /**\n   * Check if stream transfer is enabled.\n   */\n  hasStreamTransfer(): boolean {\n    return this.hasFlag(EngineFlags.STREAM_TRANSFER);\n  }\n\n  /**\n   * Check if message streaming is enabled.\n   */\n  hasMessageStreaming(): boolean {\n    return this.hasFlag(EngineFlags.MESSAGE_STREAMING);\n  }\n\n  /**\n   * Check if strict mode is enabled.\n   */\n  hasStrict(): boolean {\n    return this.hasFlag(EngineFlags.STRICT);\n  }\n\n  /**\n   * Get worker communication strategy.\n   */\n  getWorkerStrategy(): WorkerCommunicationStrategy | undefined {\n    if (this.hasStreamTransfer()) {\n      return \"stream-transfer\";\n    }\n    if (this.hasMessageStreaming()) {\n      return \"message-streaming\";\n    }\n    return undefined;\n  }\n\n  /**\n   * Create a fallback configuration.\n   *\n   * Converts stream-transfer to message-streaming and disables strict mode.\n   */\n  createFallbackConfig(): InternalEngineConfig {\n    let fallbackBitmask = this.bitmask;\n\n    // Stream transfer -> message streaming\n    if ((fallbackBitmask & EngineFlags.STREAM_TRANSFER) !== 0) {\n      fallbackBitmask &= ~EngineFlags.STREAM_TRANSFER;\n      fallbackBitmask |= EngineFlags.MESSAGE_STREAMING;\n    }\n\n    // Disable strict mode\n    if ((fallbackBitmask & EngineFlags.STRICT) !== 0) {\n      fallbackBitmask &= ~EngineFlags.STRICT;\n    }\n\n    return InternalEngineConfig.fromBitmask(\n      fallbackBitmask,\n      this.workerURL,\n      this.workerPool,\n      this.onFallback,\n    );\n  }\n\n  /**\n   * Convert to EngineConfig.\n   */\n  toConfig(): EngineConfig {\n    return {\n      worker: this.hasWorker() || undefined,\n      workerURL: this.workerURL,\n      workerPool: this.workerPool,\n      wasm: this.hasWasm() || undefined,\n      workerStrategy: this.getWorkerStrategy(),\n      strict: this.hasStrict() || undefined,\n      onFallback: this.onFallback,\n    };\n  }\n\n  /**\n   * Get bitmask for debugging.\n   * @internal\n   */\n  getBitmask(): number {\n    return this.bitmask;\n  }\n\n  /**\n   * String representation for debugging.\n   */\n  toString(): string {\n    const parts: string[] = [];\n    if (this.hasWorker()) parts.push(\"worker\");\n    if (this.hasWasm()) parts.push(\"wasm\");\n    if (this.hasStreamTransfer()) parts.push(\"stream-transfer\");\n    if (this.hasMessageStreaming()) parts.push(\"message-streaming\");\n    if (this.hasStrict()) parts.push(\"strict\");\n    return parts.join(\" + \") || \"main\";\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/execution/main/parseBinaryInMain.d.ts

@@ -0,0 +1,12 @@
+import { CSVRecord, ParseBinaryOptions } from '../../common/types.ts';
+import { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from '../../constants.ts';
+/**
+ * Parse CSV binary in main thread.
+ * This is the default binary parsing implementation.
+ *
+ * @internal
+ * @param binary CSV binary to parse (Uint8Array or ArrayBuffer)
+ * @param options Parsing options
+ * @returns Async iterable iterator of records
+ */
+export declare function parseBinaryInMain<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = DEFAULT_QUOTATION>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): AsyncIterableIterator<CSVRecord<Header>>;

package/dist/execution/main/parseStreamInMain.d.ts

@@ -0,0 +1,12 @@
+import { CSVRecord, ParseOptions } from '../../common/types.ts';
+import { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from '../../constants.ts';
+/**
+ * Parse CSV stream in main thread.
+ * This is the default streaming implementation.
+ *
+ * @internal
+ * @param stream CSV string stream to parse
+ * @param options Parsing options
+ * @returns Async iterable iterator of records
+ */
+export declare function parseStreamInMain<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = DEFAULT_QUOTATION>(stream: ReadableStream<string>, options?: ParseOptions<Header, Delimiter, Quotation>): AsyncIterableIterator<CSVRecord<Header>>;

package/dist/execution/main/parseStringInMain.d.ts

@@ -0,0 +1,12 @@
+import { CSVRecord, ParseOptions } from '../../common/types.ts';
+import { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from '../../constants.ts';
+/**
+ * Parse CSV string in main thread.
+ * This is the default implementation.
+ *
+ * @internal
+ * @param csv CSV string to parse
+ * @param options Parsing options
+ * @returns Async iterable iterator of records
+ */
+export declare function parseStringInMain<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = DEFAULT_QUOTATION>(csv: string, options?: ParseOptions<Header, Delimiter, Quotation>): AsyncIterableIterator<CSVRecord<Header>>;

package/dist/execution/main/parseUint8ArrayStreamInMain.d.ts

@@ -0,0 +1,12 @@
+import { CSVRecord, ParseBinaryOptions } from '../../common/types.ts';
+import { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from '../../constants.ts';
+/**
+ * Parse CSV Uint8Array stream in main thread.
+ * This is the default streaming implementation.
+ *
+ * @internal
+ * @param stream CSV Uint8Array stream to parse
+ * @param options Parsing options
+ * @returns Async iterable iterator of records
+ */
+export declare function parseUint8ArrayStreamInMain<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = DEFAULT_QUOTATION>(stream: ReadableStream<Uint8Array>, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): AsyncIterableIterator<CSVRecord<Header>>;

package/dist/execution/wasm/parseBinaryInWASM.d.ts

@@ -0,0 +1,18 @@
+import { CSVRecord, ParseBinaryOptions } from '../../common/types.ts';
+/**
+ * Parse CSV binary using WebAssembly in main thread.
+ *
+ * @internal
+ * @param binary CSV binary to parse
+ * @param options Parsing options
+ * @returns Async iterable iterator of records
+ * @throws {RangeError} If the binary size exceeds maxBinarySize limit or charset is not supported.
+ * @throws {TypeError} If the encoded data is not valid for the specified charset.
+ *
+ * @remarks
+ * Converts binary to string then uses WASM parser.
+ * WASM parser has limitations:
+ * - Only supports UTF-8 encoding
+ * - Only supports double-quote (") as quotation character
+ */
+export declare function parseBinaryInWASM<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;

package/dist/execution/wasm/parseBinaryInWASM.js

@@ -0,0 +1,15 @@
+import { parseStringToArraySyncWASM } from '../../parseStringToArraySyncWASM.js';
+import { convertBinaryToString } from '../../utils/convertBinaryToString.js';
+
+function parseBinaryInWASM(binary, options) {
+  const csv = convertBinaryToString(binary, options ?? {});
+  const records = parseStringToArraySyncWASM(csv, options);
+  return (async function* () {
+    for (const record of records) {
+      yield record;
+    }
+  })();
+}
+
+export { parseBinaryInWASM };
+//# sourceMappingURL=parseBinaryInWASM.js.map

package/dist/execution/wasm/parseBinaryInWASM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBinaryInWASM.js","sources":["../../../src/execution/wasm/parseBinaryInWASM.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"../../common/types.ts\";\nimport { parseStringToArraySyncWASM } from \"../../parseStringToArraySyncWASM.ts\";\nimport { convertBinaryToString } from \"../../utils/convertBinaryToString.ts\";\n\n/**\n * Parse CSV binary using WebAssembly in main thread.\n *\n * @internal\n * @param binary CSV binary to parse\n * @param options Parsing options\n * @returns Async iterable iterator of records\n * @throws {RangeError} If the binary size exceeds maxBinarySize limit or charset is not supported.\n * @throws {TypeError} If the encoded data is not valid for the specified charset.\n *\n * @remarks\n * Converts binary to string then uses WASM parser.\n * WASM parser has limitations:\n * - Only supports UTF-8 encoding\n * - Only supports double-quote (\") as quotation character\n */\nexport function parseBinaryInWASM<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  // Convert binary to string with proper option handling\n  const csv = convertBinaryToString(binary, options ?? {});\n\n  // Use WASM parser\n  const records = parseStringToArraySyncWASM(csv, options);\n\n  // Convert array to async iterator\n  return (async function* () {\n    for (const record of records) {\n      yield record;\n    }\n  })();\n}\n"],"names":[],"mappings":";;;AAoBO,SAAS,iBAAA,CACd,QACA,OAAA,EAC0C;AAE1C,EAAA,MAAM,GAAA,GAAM,qBAAA,CAAsB,MAAA,EAAQ,OAAA,IAAW,EAAE,CAAA;AAGvD,EAAA,MAAM,OAAA,GAAU,0BAAA,CAA2B,GAAA,EAAK,OAAO,CAAA;AAGvD,EAAA,OAAA,CAAQ,mBAAmB;AACzB,IAAA,KAAA,MAAW,UAAU,OAAA,EAAS;AAC5B,MAAA,MAAM,MAAA;AAAA,IACR;AAAA,EACF,CAAA,GAAG;AACL;;;;"}

package/dist/execution/wasm/parseStringInWASM.d.ts

@@ -0,0 +1,16 @@
+import { CSVRecord, ParseOptions } from '../../common/types.ts';
+/**
+ * Parse CSV string using WebAssembly in main thread.
+ *
+ * @internal
+ * @param csv CSV string to parse
+ * @param options Parsing options
+ * @returns Async iterable iterator of records
+ *
+ * @remarks
+ * WASM parser has limitations:
+ * - Only supports UTF-8 encoding
+ * - Only supports double-quote (") as quotation character
+ * - Synchronous operation (no streaming)
+ */
+export declare function parseStringInWASM<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;

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

@@ -0,0 +1,152 @@
+import { WorkerPool } from './WorkerPool.ts';
+/**
+ * Options for configuring the ReusableWorkerPool.
+ */
+export interface ReusableWorkerPoolOptions {
+    /**
+     * Maximum number of worker instances in the pool.
+     *
+     * @default 1
+     *
+     * @remarks
+     * **Security Recommendation:**
+     * For production applications that accept user uploads, set this to a reasonable limit (e.g., 2-4)
+     * to prevent resource exhaustion attacks. Without limits, malicious users could spawn unlimited
+     * workers by uploading multiple large CSV files simultaneously, leading to memory exhaustion and DoS.
+     *
+     * @example
+     * ```ts
+     * // Recommended for production
+     * const pool = new ReusableReusableWorkerPool({ maxWorkers: 4 });
+     * ```
+     */
+    maxWorkers?: number;
+    /**
+     * Custom worker URL to use for all workers in the pool.
+     */
+    workerURL?: string | URL;
+}
+export declare class ReusableWorkerPool implements WorkerPool, Disposable {
+    private workers;
+    private requestId;
+    private currentWorkerIndex;
+    private readonly maxWorkers;
+    private readonly customWorkerURL?;
+    private pendingWorkerCreations;
+    private pendingCreationsByURL;
+    private disposed;
+    private nextPendingId;
+    /**
+     * Create a new ReusableWorkerPool.
+     *
+     * @param options - Configuration options for the pool
+     */
+    constructor(options?: ReusableWorkerPoolOptions);
+    /**
+     * 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
+     */
+    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 ReusableWorkerPool, this does nothing as workers are kept alive and reused.
+     *
+     * @param _worker - The worker to release
+     * @internal
+     */
+    releaseWorker(_worker: Worker): void;
+    /**
+     * Get the current number of workers in the pool.
+     *
+     * @returns The number of active workers
+     */
+    get size(): number;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): void;
+    /**
+     * 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](): void;
+}