@danielsimonjr/mathts-parallel 0.7.1 → 0.8.0

package/dist/ComputePool.d.ts

@@ -92,6 +92,21 @@ export declare const DEFAULT_THRESHOLD_BY_OP: Partial<Record<OpName, OpThreshold
  * Default ComputePool configuration
  */
 export declare const DEFAULT_POOL_CONFIG: ComputePoolConfig;
+/**
+ * Per-call dispatch override accepted by the `ComputePool` operations.
+ *
+ * - `forceSequential` computes inline whatever the size or threshold.
+ * - `forceParallel` skips the threshold checks and dispatches to the workers. It still needs
+ *   a ready pool: on a pool that was not initialized (or is disabled) the call runs inline.
+ *
+ * `forceSequential` wins when both are set.
+ */
+export interface DispatchOptions {
+    /** Force parallel execution regardless of threshold */
+    forceParallel?: boolean;
+    /** Force sequential execution regardless of threshold */
+    forceSequential?: boolean;
+}
 /**
  * Result of a parallel operation
  */
@@ -147,7 +162,7 @@ export declare class ComputePool {
      * is used.  When `op` is omitted the global threshold is always used (for
      * backward-compatibility with existing callers that don't know the op name).
      */
-    shouldParallelize(elementCount: number, op?: OpName): boolean;
+    shouldParallelize(elementCount: number, op?: OpName, force?: DispatchOptions): boolean;
     /**
      * Wrap a sequentially-computed reduction result in the `ParallelResult`
      * envelope. Used by the reduction methods below so that ops whose threshold
@@ -183,15 +198,15 @@ export declare class ComputePool {
     /**
      * Parallel sum of array elements
      */
-    sum(data: Float64Array): Promise<ParallelResult<number>>;
+    sum(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Parallel product of array elements
      */
-    prod(data: Float64Array): Promise<ParallelResult<number>>;
+    prod(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Parallel dot product
      */
-    dot(a: Float64Array, b: Float64Array): Promise<ParallelResult<number>>;
+    dot(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Pool options that apply `op`'s `thresholdByOp` entry to a call the pool decides itself.
      *
@@ -202,14 +217,19 @@ export declare class ComputePool {
      * `shouldParallelize` requires a ready pool, so `forceParallel` never reaches an idle one.
      */
     private poolOptions;
+    /**
+     * Task options that carry only the caller's force flags, for methods that already gated
+     * in `ComputePool` (the pool then makes the same decision) or that have no per-op threshold.
+     */
+    private forceTask;
     /**
      * Parallel element-wise operation
      */
-    elementwise(a: Float64Array, b: Float64Array, op: 'add' | 'subtract' | 'multiply' | 'divide'): Promise<ParallelResult<Float64Array>>;
+    elementwise(a: Float64Array, b: Float64Array, op: 'add' | 'subtract' | 'multiply' | 'divide', force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel scale operation
      */
-    scale(data: Float64Array, scalar: number): Promise<ParallelResult<Float64Array>>;
+    scale(data: Float64Array, scalar: number, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel matrix multiplication
      *
@@ -219,27 +239,27 @@ export declare class ComputePool {
      * @param b - Second matrix as flat Float64Array (row-major)
      * @param bCols - Number of columns in B
      */
-    matmul(a: Float64Array, aRows: number, aCols: number, b: Float64Array, bCols: number): Promise<ParallelResult<Float64Array>>;
+    matmul(a: Float64Array, aRows: number, aCols: number, b: Float64Array, bCols: number, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel matrix transpose
      */
-    transpose(data: Float64Array, rows: number, cols: number): Promise<ParallelResult<Float64Array>>;
+    transpose(data: Float64Array, rows: number, cols: number, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel map operation
      */
-    map<T, R>(data: T[], fn: (item: T) => R): Promise<ParallelResult<R[]>>;
+    map<T, R>(data: T[], fn: (item: T) => R, force?: DispatchOptions): Promise<ParallelResult<R[]>>;
     /**
      * Parallel reduce operation
      */
-    reduce<T, R>(data: T[], fn: (acc: R, item: T) => R, initial: R): Promise<ParallelResult<R>>;
+    reduce<T, R>(data: T[], fn: (acc: R, item: T) => R, initial: R, force?: DispatchOptions): Promise<ParallelResult<R>>;
     /**
      * Parallel filter operation
      */
-    filter<T>(data: T[], predicate: (item: T) => boolean): Promise<ParallelResult<T[]>>;
+    filter<T>(data: T[], predicate: (item: T) => boolean, force?: DispatchOptions): Promise<ParallelResult<T[]>>;
     /**
      * Find min and max values in parallel
      */
-    minMax(data: Float64Array): Promise<ParallelResult<{
+    minMax(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<{
         min: number;
         max: number;
         minIdx: number;
@@ -248,7 +268,7 @@ export declare class ComputePool {
     /**
      * Compute variance, mean, and standard deviation in parallel
      */
-    variance(data: Float64Array): Promise<ParallelResult<{
+    variance(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<{
         mean: number;
         variance: number;
         std: number;
@@ -256,19 +276,19 @@ export declare class ComputePool {
     /**
      * Compute norm (Euclidean length) in parallel
      */
-    norm(data: Float64Array): Promise<ParallelResult<number>>;
+    norm(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Compute Euclidean distance in parallel
      */
-    distance(a: Float64Array, b: Float64Array): Promise<ParallelResult<number>>;
+    distance(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Compute histogram in parallel
      */
-    histogram(data: Float64Array, bins: number, min?: number, max?: number): Promise<ParallelResult<number[]>>;
+    histogram(data: Float64Array, bins: number, min?: number, max?: number, force?: DispatchOptions): Promise<ParallelResult<number[]>>;
     /**
      * Apply unary function in parallel
      */
-    unary(data: Float64Array, fn: 'abs' | 'sqrt' | 'exp' | 'log' | 'sin' | 'cos' | 'tan' | 'negate' | 'square'): Promise<ParallelResult<Float64Array>>;
+    unary(data: Float64Array, fn: 'abs' | 'sqrt' | 'exp' | 'log' | 'sin' | 'cos' | 'tan' | 'negate' | 'square', force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Apply a caller-supplied unary numeric function in parallel.
      *
@@ -366,51 +386,51 @@ export declare class ComputePool {
     /**
      * Parallel absolute value
      */
-    abs(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    abs(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel square root
      */
-    sqrt(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    sqrt(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel exponential
      */
-    exp(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    exp(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel natural log
      */
-    log(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    log(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel sine
      */
-    sin(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    sin(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel cosine
      */
-    cos(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    cos(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel tangent
      */
-    tan(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    tan(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel negation
      */
-    negate(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    negate(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel square
      */
-    square(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    square(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel matrix-vector multiplication
      */
-    matvec(matrix: Float64Array, rows: number, cols: number, vector: Float64Array): Promise<ParallelResult<Float64Array>>;
+    matvec(matrix: Float64Array, rows: number, cols: number, vector: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel outer product
      */
-    outer(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    outer(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel find operation
      */
-    find<T>(data: T[], predicate: (item: T) => boolean): Promise<ParallelResult<{
+    find<T>(data: T[], predicate: (item: T) => boolean, force?: DispatchOptions): Promise<ParallelResult<{
         found: boolean;
         value?: T;
         index?: number;
@@ -418,23 +438,23 @@ export declare class ComputePool {
     /**
      * Parallel sort operation
      */
-    sort<T>(data: T[], compare?: (a: T, b: T) => number): Promise<ParallelResult<T[]>>;
+    sort<T>(data: T[], compare?: (a: T, b: T) => number, force?: DispatchOptions): Promise<ParallelResult<T[]>>;
     /**
      * Parallel addition of two arrays
      */
-    add(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    add(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel subtraction of two arrays
      */
-    subtract(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    subtract(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel element-wise multiplication
      */
-    multiply(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    multiply(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel element-wise division
      */
-    divide(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    divide(a: Float64Array, b: Float64Array, force?: DispatchOptions): Promise<ParallelResult<Float64Array>>;
     /**
      * Parallel element-wise exponentiation.
      *
@@ -481,19 +501,19 @@ export declare class ComputePool {
     /**
      * Compute mean in parallel (uses variance internally)
      */
-    mean(data: Float64Array): Promise<ParallelResult<number>>;
+    mean(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Compute standard deviation in parallel
      */
-    std(data: Float64Array): Promise<ParallelResult<number>>;
+    std(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Find minimum value in parallel
      */
-    min(data: Float64Array): Promise<ParallelResult<number>>;
+    min(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Find maximum value in parallel
      */
-    max(data: Float64Array): Promise<ParallelResult<number>>;
+    max(data: Float64Array, force?: DispatchOptions): Promise<ParallelResult<number>>;
     /**
      * Element-wise bitwise AND on two `Int32Array`s.
      */

package/dist/ComputePool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputePool.d.ts","sourceRoot":"","sources":["../src/ComputePool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ComputePool.d.ts","sourceRoot":"","sources":["../src/ComputePool.ts"],"names":[],"mappings":"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"}

package/dist/WorkerPool.d.ts

@@ -8,7 +8,9 @@
  * The pool uses `worker_threads` when `process.versions.node` is defined, and
  * module Web Workers otherwise. When the caller gives no worker count, the
  * count is `navigator.hardwareConcurrency - 1` (minimum 2), or 4 when that
- * value is not available. A worker error rejects all active tasks.
+ * value is not available. A worker error rejects only the tasks that worker was
+ * running; the crashed worker is terminated, evicted and replaced so the pool keeps
+ * its capacity, and the other workers are untouched.
  * `terminate` rejects all queued and active tasks and stops all workers.
  */
 export declare class WorkerPool {
@@ -20,12 +22,24 @@ export declare class WorkerPool {
     private workerScript;
     private isNode;
     private terminated;
+    /** Workers that have delivered at least one message (so their script loads). */
+    private readyWorkers;
+    /** Consecutive crashes of workers that never became ready. */
+    private startupFailures;
     constructor(workerScript: string, maxWorkers?: number);
     private getOptimalWorkerCount;
     private initialize;
+    /** `worker_threads`, imported once per pool and shared by every concurrent spawn. */
+    private workerThreadsModule?;
+    private nodeWorkerThreads;
     protected createWorker(): Promise<Worker>;
     private handleWorkerMessage;
     private handleWorkerError;
+    /** Consecutive never-ready worker crashes tolerated before the pool stops respawning. */
+    static readonly MAX_STARTUP_FAILURES = 3;
+    private isBusy;
+    /** Terminate a crashed worker, drop it from the roster and spawn a replacement. */
+    private evictAndReplace;
     private processQueue;
     private executeTask;
     /**

package/dist/WorkerPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkerPool.d.ts","sourceRoot":"","sources":["../src/WorkerPool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA2BH;;;;;;;;GAQG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAS;IAE3B,YAAY,YAAY,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAKpD;IAED,OAAO,CAAC,qBAAqB;YAOf,UAAU;IAkBxB,UAAgB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAyC9C;IAED,OAAO,CAAC,mBAAmB;IAqB3B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,WAAW;IAiBnB;;;;OAIG;YACW,iBAAiB;IA2C/B;;;;;;;;;OASG;IACU,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAC3C,IAAI,EAAE,CAAC,EACP,aAAa,CAAC,EAAE,YAAY,EAAE,EAC9B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CA8BZ;IAED,OAAO,CAAC,cAAc;IAIT,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBtC;IAED,OAAO,CAAC,cAAc;IAOtB,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;CACF"}
+{"version":3,"file":"WorkerPool.d.ts","sourceRoot":"","sources":["../src/WorkerPool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8BH;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,gBAAgB,CAAgB;IAGxC,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,gFAAgF;IAChF,OAAO,CAAC,YAAY,CAAyB;IAC7C,8DAA8D;IAC9D,OAAO,CAAC,eAAe,CAAK;IAE5B,YAAY,YAAY,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAWpD;IAED,OAAO,CAAC,qBAAqB;YAOf,UAAU;IAqBxB,qFAAqF;IACrF,OAAO,CAAC,mBAAmB,CAAC,CAA2C;IAEvE,OAAO,CAAC,iBAAiB;IAKzB,UAAgB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAyC9C;IAED,OAAO,CAAC,mBAAmB;IAoC3B,OAAO,CAAC,iBAAiB;IAqCzB,yFAAyF;IACzF,MAAM,CAAC,QAAQ,CAAC,oBAAoB,KAAK;IAEzC,OAAO,CAAC,MAAM;IAOd,mFAAmF;YACrE,eAAe;IAuB7B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,WAAW;IAiBnB;;;;OAIG;YACW,iBAAiB;IA2C/B;;;;;;;;;OASG;IACU,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAC3C,IAAI,EAAE,CAAC,EACP,aAAa,CAAC,EAAE,YAAY,EAAE,EAC9B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CA8BZ;IAED,OAAO,CAAC,cAAc;IAIT,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBtC;IAED,OAAO,CAAC,cAAc;IAOtB,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;CACF"}

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  */
 export { ComputePool, computePool, Transfer, DEFAULT_POOL_CONFIG, DEFAULT_THRESHOLD_BY_OP, resolveOpThreshold, } from './ComputePool.js';
 export { WorkerPool } from './WorkerPool.js';
-export type { ComputePoolConfig, ParallelResult, OpName, OpThreshold } from './ComputePool.js';
+export type { ComputePoolConfig, ParallelResult, OpName, OpThreshold, DispatchOptions, } from './ComputePool.js';
 export { parallelMatmul, parallelMatvec, parallelTranspose, parallelOuter, parallelDot, parallelAdd, parallelSubtract, parallelMultiply, parallelDivide, parallelScale, parallelAbs, parallelNegate, parallelSquare, parallelSqrt, parallelExp, parallelLog, parallelSin, parallelCos, parallelTan, parallelElementwise, parallelUnary, parallelSum, parallelMean, parallelMin, parallelMax, parallelMinMax, parallelVariance, parallelStd, parallelNorm, parallelDistance, parallelHistogram, parallelReduce, parallelMap, parallelFilter, parallelFind, parallelSort, parallelForEach, parallelSome, parallelEvery, parallelCount, } from './operations/index.js';
 export type { MatmulOptions, ElementwiseOptions, ReduceOptions, MapOptions, } from './operations/index.js';
 export { bitAnd, bitOr, bitXor, bitNot, leftShift, rightArithShift, rightLogShift, } from './ops/bitwise.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,EACL,WAAW,EACX,WAAW,EACX,QAAQ,EACR,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAM/F,OAAO,EAEL,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,WAAW,EAGX,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,WAAW,EACX,cAAc,EACd,cAAc,EACd,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,aAAa,EAGb,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EAGd,WAAW,EACX,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,UAAU,GACX,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EACL,MAAM,EACN,KAAK,EACL,MAAM,EACN,MAAM,EACN,SAAS,EACT,eAAe,EACf,aAAa,GACd,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMxD,OAAO,EAEL,sBAAsB,EACtB,iBAAiB,EACjB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,EACd,WAAW,EAGX,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,YAAY,EACZ,WAAW,EACX,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC;AAU/B,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,EACL,WAAW,EACX,WAAW,EACX,QAAQ,EACR,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,YAAY,EACV,iBAAiB,EACjB,cAAc,EACd,MAAM,EACN,WAAW,EACX,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAM1B,OAAO,EAEL,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,WAAW,EAGX,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,WAAW,EACX,cAAc,EACd,cAAc,EACd,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,aAAa,EAGb,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EAGd,WAAW,EACX,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,UAAU,GACX,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EACL,MAAM,EACN,KAAK,EACL,MAAM,EACN,MAAM,EACN,SAAS,EACT,eAAe,EACf,aAAa,GACd,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMxD,OAAO,EAEL,sBAAsB,EACtB,iBAAiB,EACjB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,EACd,WAAW,EAGX,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,YAAY,EACZ,WAAW,EACX,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC;AAU/B,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -1,5 +1,15 @@
 import { norm2, pairwiseDot, pairwiseSum, scaledDistance, sumSquaredDeviations } from "@danielsimonjr/mathts-core";
 import { MathWorkerPool, Transfer, tensordotRange } from "@danielsimonjr/mathts-workerpool";
+//#region src/validate.ts
+function assertSameLength(op, a, b) {
+	if (a !== b) throw new Error(`${op}: lengths must match (${a} vs ${b})`);
+}
+function assertMatmulShape(op, aLength, aRows, aCols, bLength, bRows, bCols) {
+	if (aCols !== bRows) throw new Error(`${op}: inner dimensions must match (aCols ${aCols} vs bRows ${bRows})`);
+	if (aLength !== aRows * aCols) throw new Error(`${op}: a has ${aLength} elements, expected ${aRows}x${aCols}`);
+	if (bLength !== bRows * bCols) throw new Error(`${op}: b has ${bLength} elements, expected ${bRows}x${bCols}`);
+}
+//#endregion
 //#region src/strategies/chunk.ts
 const DEFAULT_CHUNK_OPTIONS = {
 	minChunkSize: 1e3,
@@ -168,7 +178,7 @@ function applyBinaryChunk(a, b, out, start, length, outStart, op) {
 	}
 }
 function runBinary(a, b, op, options = {}) {
-	if (a.length !== b.length) throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
+	assertSameLength(op, a.length, b.length);
 	const out = new Int32Array(a.length);
 	if (a.length === 0) return out;
 	const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
@@ -336,6 +346,9 @@ function mergeThresholds(base, override) {
 		...override
 	};
 }
+function exactBuffer(x) {
+	return (x.byteOffset === 0 && x.buffer.byteLength === x.byteLength ? x : x.slice()).buffer;
+}
 function toParallelResult(result) {
 	return {
 		result: result.result,
@@ -373,7 +386,9 @@ var ComputePool = class {
 	isReady() {
 		return this.workerPool.isReady();
 	}
-	shouldParallelize(elementCount, op) {
+	shouldParallelize(elementCount, op, force) {
+		if (force?.forceSequential) return false;
+		if (force?.forceParallel) return this.config.enabled && this.workerPool.isReady();
 		const byOp = this.config.thresholdByOp;
 		if (op !== void 0 && byOp !== void 0 && op in byOp) {
 			const raw = byOp[op];
@@ -393,14 +408,12 @@ var ComputePool = class {
 		};
 	}
 	async gatedBinary(a, b, options) {
-		if (!this.shouldParallelize(a.length, options.op)) {
-			if (a.length !== b.length) throw new Error(`${options.op}: vectors must have the same length`);
-			return this.seqResult(options.sequential(a, b));
-		}
+		assertSameLength(options.op, a.length, b.length);
+		if (!this.shouldParallelize(a.length, options.op, options.force)) return this.seqResult(options.sequential(a, b));
 		return toParallelResult(await options.worker(a, b));
 	}
 	async bitwiseBinary(a, b, options) {
-		if (a.length !== b.length) throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
+		assertSameLength(options.op, a.length, b.length);
 		if (this.shouldParallelize(a.length, options.op)) return toParallelResult(await this.workerPool.bitwiseBinary(a, b, options.op));
 		const start = performance.now();
 		return {
@@ -411,7 +424,7 @@ var ComputePool = class {
 		};
 	}
 	async bitwiseShift(a, b, options) {
-		if (typeof b !== "number" && a.length !== b.length) throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
+		if (typeof b !== "number") assertSameLength(options.op, a.length, b.length);
 		if (this.shouldParallelize(a.length, options.op)) return toParallelResult(typeof b === "number" ? await this.workerPool.bitwiseScalar(a, b, options.op) : await this.workerPool.bitwiseBinary(a, b, options.op));
 		const start = performance.now();
 		return {
@@ -427,57 +440,64 @@ var ComputePool = class {
 	stats() {
 		return this.workerPool.stats();
 	}
-	async sum(data) {
-		if (!this.shouldParallelize(data.length, "sum")) return this.seqResult(pairwiseSum(data));
-		return toParallelResult(await this.workerPool.sum(data));
+	async sum(data, force) {
+		if (!this.shouldParallelize(data.length, "sum", force)) return this.seqResult(pairwiseSum(data));
+		return toParallelResult(await this.workerPool.sum(data, this.forceTask(force)));
 	}
-	async prod(data) {
-		if (!this.shouldParallelize(data.length, "prod")) {
+	async prod(data, force) {
+		if (!this.shouldParallelize(data.length, "prod", force)) {
 			let p = 1;
 			for (let i = 0; i < data.length; i++) p *= data[i];
 			return this.seqResult(p);
 		}
-		return toParallelResult(await this.workerPool.prod(data));
+		return toParallelResult(await this.workerPool.prod(data, this.forceTask(force)));
 	}
-	async dot(a, b) {
+	async dot(a, b, force) {
 		return this.gatedBinary(a, b, {
 			op: "dot",
+			force,
 			sequential: pairwiseDot,
-			worker: (x, y) => this.workerPool.dot(x, y)
+			worker: (x, y) => this.workerPool.dot(x, y, this.forceTask(force))
 		});
 	}
-	poolOptions(elementCount, op) {
-		return this.shouldParallelize(elementCount, op) ? { forceParallel: true } : { forceSequential: true };
+	poolOptions(elementCount, op, force) {
+		return this.shouldParallelize(elementCount, op, force) ? { forceParallel: true } : { forceSequential: true };
+	}
+	forceTask(force) {
+		if (force === void 0) return void 0;
+		if (force.forceSequential) return { forceSequential: true };
+		if (force.forceParallel) return this.shouldParallelize(0, void 0, force) ? { forceParallel: true } : { forceSequential: true };
 	}
-	async elementwise(a, b, op) {
-		return toParallelResult(await this.workerPool.elementwise(a, b, op, this.poolOptions(a.length, op)));
+	async elementwise(a, b, op, force) {
+		return toParallelResult(await this.workerPool.elementwise(a, b, op, this.poolOptions(a.length, op, force)));
 	}
-	async scale(data, scalar) {
-		return toParallelResult(await this.workerPool.scale(data, scalar, this.poolOptions(data.length, "scale")));
+	async scale(data, scalar, force) {
+		return toParallelResult(await this.workerPool.scale(data, scalar, this.poolOptions(data.length, "scale", force)));
 	}
-	async matmul(a, aRows, aCols, b, bCols) {
-		return toParallelResult(await this.workerPool.matmul(a, aRows, aCols, b, bCols, this.poolOptions(aRows * bCols, "matmul")));
+	async matmul(a, aRows, aCols, b, bCols, force) {
+		assertMatmulShape("matmul", a.length, aRows, aCols, b.length, aCols, bCols);
+		return toParallelResult(await this.workerPool.matmul(a, aRows, aCols, b, bCols, this.poolOptions(aRows * bCols, "matmul", force)));
 	}
-	async transpose(data, rows, cols) {
-		if (!this.shouldParallelize(data.length, "transpose")) {
-			if (data.length !== rows * cols) throw new Error(`transpose: data length ${data.length} !== rows*cols (${rows * cols})`);
+	async transpose(data, rows, cols, force) {
+		if (data.length !== rows * cols) throw new Error(`transpose: data length ${data.length} !== rows*cols (${rows * cols})`);
+		if (!this.shouldParallelize(data.length, "transpose", force)) {
 			const out = new Float64Array(rows * cols);
 			for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) out[j * rows + i] = data[i * cols + j];
 			return this.seqResult(out);
 		}
-		return toParallelResult(await this.workerPool.transpose(data, rows, cols));
+		return toParallelResult(await this.workerPool.transpose(data, rows, cols, this.forceTask(force)));
 	}
-	async map(data, fn) {
-		return toParallelResult(await this.workerPool.map(data, fn));
+	async map(data, fn, force) {
+		return toParallelResult(await this.workerPool.map(data, fn, this.forceTask(force)));
 	}
-	async reduce(data, fn, initial) {
-		return toParallelResult(await this.workerPool.reduce(data, fn, initial));
+	async reduce(data, fn, initial, force) {
+		return toParallelResult(await this.workerPool.reduce(data, fn, initial, this.forceTask(force)));
 	}
-	async filter(data, predicate) {
-		return toParallelResult(await this.workerPool.filter(data, predicate));
+	async filter(data, predicate, force) {
+		return toParallelResult(await this.workerPool.filter(data, predicate, this.forceTask(force)));
 	}
-	async minMax(data) {
-		if (!this.shouldParallelize(data.length, "minMax") && !this.shouldParallelize(data.length, "min")) {
+	async minMax(data, force) {
+		if (!this.shouldParallelize(data.length, "minMax", force) && !this.shouldParallelize(data.length, "min", force)) {
 			let min = Infinity;
 			let max = -Infinity;
 			let minIdx = -1;
@@ -499,10 +519,10 @@ var ComputePool = class {
 				maxIdx
 			});
 		}
-		return toParallelResult(await this.workerPool.minMax(data));
+		return toParallelResult(await this.workerPool.minMax(data, this.forceTask(force)));
 	}
-	async variance(data) {
-		if (!this.shouldParallelize(data.length, "variance")) {
+	async variance(data, force) {
+		if (!this.shouldParallelize(data.length, "variance", force)) {
 			const n = data.length;
 			const mean = n > 0 ? pairwiseSum(data) / n : 0;
 			const variance = n > 0 ? sumSquaredDeviations(data) / n : 0;
@@ -512,45 +532,51 @@ var ComputePool = class {
 				std: Math.sqrt(variance)
 			});
 		}
-		return toParallelResult(await this.workerPool.variance(data));
+		return toParallelResult(await this.workerPool.variance(data, this.forceTask(force)));
 	}
-	async norm(data) {
-		if (!this.shouldParallelize(data.length, "norm")) return this.seqResult(norm2(data));
-		return toParallelResult(await this.workerPool.norm(data));
+	async norm(data, force) {
+		if (!this.shouldParallelize(data.length, "norm", force)) return this.seqResult(norm2(data));
+		return toParallelResult(await this.workerPool.norm(data, this.forceTask(force)));
 	}
-	async distance(a, b) {
+	async distance(a, b, force) {
 		return this.gatedBinary(a, b, {
 			op: "distance",
+			force,
 			sequential: scaledDistance,
-			worker: (x, y) => this.workerPool.distance(x, y)
+			worker: (x, y) => this.workerPool.distance(x, y, this.forceTask(force))
 		});
 	}
-	async histogram(data, bins, min, max) {
-		if (!this.shouldParallelize(data.length, "histogram")) {
+	async histogram(data, bins, min, max, force) {
+		if (!Number.isInteger(bins) || bins <= 0) throw new RangeError(`histogram: bins must be a positive integer (got ${bins})`);
+		if (!this.shouldParallelize(data.length, "histogram", force)) {
 			let lo = min;
 			let hi = max;
 			if (lo === void 0 || hi === void 0) {
 				lo = Infinity;
 				hi = -Infinity;
 				for (let i = 0; i < data.length; i++) {
-					if (data[i] < lo) lo = data[i];
-					if (data[i] > hi) hi = data[i];
+					const v = data[i];
+					if (!Number.isFinite(v)) continue;
+					if (v < lo) lo = v;
+					if (v > hi) hi = v;
 				}
 			}
 			const counts = new Array(bins).fill(0);
-			const width = (hi - lo) / bins || 1;
+			const width = hi > lo ? (hi - lo) / bins : 1;
 			for (let i = 0; i < data.length; i++) {
-				let b = Math.floor((data[i] - lo) / width);
+				const v = data[i];
+				if (!Number.isFinite(v)) continue;
+				let b = Math.floor((v - lo) / width);
 				if (b >= bins) b = bins - 1;
 				if (b < 0) b = 0;
 				counts[b]++;
 			}
 			return this.seqResult(counts);
 		}
-		return toParallelResult(await this.workerPool.histogram(data, bins, min, max));
+		return toParallelResult(await this.workerPool.histogram(data, bins, min, max, this.forceTask(force)));
 	}
-	async unary(data, fn) {
-		return toParallelResult(await this.workerPool.unary(data, fn, this.poolOptions(data.length, fn)));
+	async unary(data, fn, force) {
+		return toParallelResult(await this.workerPool.unary(data, fn, this.poolOptions(data.length, fn, force)));
 	}
 	async applyKernel(data, fnSource) {
 		return toParallelResult(await this.workerPool.applyKernel(data, fnSource));
@@ -604,37 +630,37 @@ var ComputePool = class {
 	async distanceMatrix(points, n, dim) {
 		return toParallelResult(await this.workerPool.distanceMatrix(points, n, dim));
 	}
-	async abs(data) {
-		return this.unary(data, "abs");
+	async abs(data, force) {
+		return this.unary(data, "abs", force);
 	}
-	async sqrt(data) {
-		return this.unary(data, "sqrt");
+	async sqrt(data, force) {
+		return this.unary(data, "sqrt", force);
 	}
-	async exp(data) {
-		return this.unary(data, "exp");
+	async exp(data, force) {
+		return this.unary(data, "exp", force);
 	}
-	async log(data) {
-		return this.unary(data, "log");
+	async log(data, force) {
+		return this.unary(data, "log", force);
 	}
-	async sin(data) {
-		return this.unary(data, "sin");
+	async sin(data, force) {
+		return this.unary(data, "sin", force);
 	}
-	async cos(data) {
-		return this.unary(data, "cos");
+	async cos(data, force) {
+		return this.unary(data, "cos", force);
 	}
-	async tan(data) {
-		return this.unary(data, "tan");
+	async tan(data, force) {
+		return this.unary(data, "tan", force);
 	}
-	async negate(data) {
-		return this.unary(data, "negate");
+	async negate(data, force) {
+		return this.unary(data, "negate", force);
 	}
-	async square(data) {
-		return this.unary(data, "square");
+	async square(data, force) {
+		return this.unary(data, "square", force);
 	}
-	async matvec(matrix, rows, cols, vector) {
-		if (!this.shouldParallelize(matrix.length, "matvec")) {
-			if (matrix.length !== rows * cols) throw new Error(`matvec: matrix length ${matrix.length} !== rows*cols (${rows * cols})`);
-			if (vector.length !== cols) throw new Error(`matvec: vector length ${vector.length} !== cols (${cols})`);
+	async matvec(matrix, rows, cols, vector, force) {
+		if (matrix.length !== rows * cols) throw new Error(`matvec: matrix length ${matrix.length} !== rows*cols (${rows * cols})`);
+		if (vector.length !== cols) throw new Error(`matvec: vector length ${vector.length} !== cols (${cols})`);
+		if (!this.shouldParallelize(matrix.length, "matvec", force)) {
 			const out = new Float64Array(rows);
 			for (let i = 0; i < rows; i++) {
 				let s = 0;
@@ -643,36 +669,36 @@ var ComputePool = class {
 			}
 			return this.seqResult(out);
 		}
-		return toParallelResult(await this.workerPool.matvec(matrix, rows, cols, vector));
+		return toParallelResult(await this.workerPool.matvec(matrix, rows, cols, vector, this.forceTask(force)));
 	}
-	async outer(a, b) {
-		if (!this.shouldParallelize(a.length * b.length, "outer")) {
+	async outer(a, b, force) {
+		if (!this.shouldParallelize(a.length * b.length, "outer", force)) {
 			const out = new Float64Array(a.length * b.length);
 			for (let i = 0; i < a.length; i++) for (let j = 0; j < b.length; j++) out[i * b.length + j] = a[i] * b[j];
 			return this.seqResult(out);
 		}
-		return toParallelResult(await this.workerPool.outer(a, b));
+		return toParallelResult(await this.workerPool.outer(a, b, this.forceTask(force)));
 	}
-	async find(data, predicate) {
-		return toParallelResult(await this.workerPool.find(data, predicate));
+	async find(data, predicate, force) {
+		return toParallelResult(await this.workerPool.find(data, predicate, this.forceTask(force)));
 	}
-	async sort(data, compare) {
-		return toParallelResult(await this.workerPool.sort(data, compare));
+	async sort(data, compare, force) {
+		return toParallelResult(await this.workerPool.sort(data, compare, this.forceTask(force)));
 	}
-	async add(a, b) {
-		return this.elementwise(a, b, "add");
+	async add(a, b, force) {
+		return this.elementwise(a, b, "add", force);
 	}
-	async subtract(a, b) {
-		return this.elementwise(a, b, "subtract");
+	async subtract(a, b, force) {
+		return this.elementwise(a, b, "subtract", force);
 	}
-	async multiply(a, b) {
-		return this.elementwise(a, b, "multiply");
+	async multiply(a, b, force) {
+		return this.elementwise(a, b, "multiply", force);
 	}
-	async divide(a, b) {
-		return this.elementwise(a, b, "divide");
+	async divide(a, b, force) {
+		return this.elementwise(a, b, "divide", force);
 	}
 	async pow(a, b) {
-		if (a.length !== b.length) throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
+		assertSameLength("pow", a.length, b.length);
 		if (this.shouldParallelize(a.length, "pow")) return this.applyKernel2(a, b, "(a, b) => Math.pow(a, b)");
 		const start = performance.now();
 		const result = new Float64Array(a.length);
@@ -725,10 +751,12 @@ var ComputePool = class {
 			const bShapeArr = Array.from(bShape);
 			const axesAArr = Array.from(axesA);
 			const axesBArr = Array.from(axesB);
+			const aBuffer = exactBuffer(a);
+			const bBuffer = exactBuffer(b);
 			const chunkResults = await Promise.all(chunks.map(([outStart, outEnd]) => this.workerPool.exec("tensordotChunk", [
-				a.buffer,
+				aBuffer,
 				aShapeArr,
-				b.buffer,
+				bBuffer,
 				bShapeArr,
 				axesAArr,
 				axesBArr,
@@ -763,29 +791,29 @@ var ComputePool = class {
 			parallelized: false
 		};
 	}
-	async mean(data) {
-		const result = await this.variance(data);
+	async mean(data, force) {
+		const result = await this.variance(data, force);
 		return {
 			...result,
 			result: result.result.mean
 		};
 	}
-	async std(data) {
-		const result = await this.variance(data);
+	async std(data, force) {
+		const result = await this.variance(data, force);
 		return {
 			...result,
 			result: result.result.std
 		};
 	}
-	async min(data) {
-		const result = await this.minMax(data);
+	async min(data, force) {
+		const result = await this.minMax(data, force);
 		return {
 			...result,
 			result: result.result.min
 		};
 	}
-	async max(data) {
-		const result = await this.minMax(data);
+	async max(data, force) {
+		const result = await this.minMax(data, force);
 		return {
 			...result,
 			result: result.result.max
@@ -861,7 +889,8 @@ var ComputePool = class {
 const computePool = new ComputePool();
 //#endregion
 //#region src/WorkerPool.ts
-var WorkerPool = class {
+let taskCounter = 0;
+var WorkerPool = class WorkerPool {
 	workers = [];
 	availableWorkers = [];
 	taskQueue = [];
@@ -870,7 +899,10 @@ var WorkerPool = class {
 	workerScript;
 	isNode;
 	terminated = false;
+	readyWorkers = /* @__PURE__ */ new WeakSet();
+	startupFailures = 0;
 	constructor(workerScript, maxWorkers) {
+		if (maxWorkers !== void 0 && (!Number.isInteger(maxWorkers) || maxWorkers < 0)) throw new RangeError(`WorkerPool: maxWorkers must be a non-negative integer, 0 for auto (got ${maxWorkers})`);
 		this.workerScript = workerScript;
 		this.maxWorkers = maxWorkers || this.getOptimalWorkerCount();
 		this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
@@ -881,7 +913,7 @@ var WorkerPool = class {
 		return 4;
 	}
 	async initialize() {
-		for (let i = 0; i < this.maxWorkers; i++) {
+		await Promise.all(Array.from({ length: this.maxWorkers }, async () => {
 			const worker = await this.createWorker();
 			if (this.terminated) {
 				worker.terminate();
@@ -890,12 +922,17 @@ var WorkerPool = class {
 			this.workers.push(worker);
 			this.availableWorkers.push(worker);
 			this.processQueue();
-		}
+		}));
+	}
+	workerThreadsModule;
+	nodeWorkerThreads() {
+		this.workerThreadsModule ??= import("worker_threads");
+		return this.workerThreadsModule;
 	}
 	async createWorker() {
 		let worker;
 		if (this.isNode) {
-			const { Worker: NodeWorker } = await import("worker_threads");
+			const { Worker: NodeWorker } = await this.nodeWorkerThreads();
 			const nodeWorker = new NodeWorker(this.workerScript.startsWith("file://") ? new URL(this.workerScript) : this.workerScript);
 			nodeWorker.on("message", (data) => {
 				this.handleWorkerMessage(worker, data);
@@ -916,8 +953,16 @@ var WorkerPool = class {
 		return worker;
 	}
 	handleWorkerMessage(worker, message) {
+		this.readyWorkers.add(worker);
+		this.startupFailures = 0;
 		const task = this.activeTasks.get(message.id);
-		if (!task) return;
+		if (!task) {
+			if (this.workers.includes(worker) && !this.availableWorkers.includes(worker) && !this.isBusy(worker)) {
+				this.availableWorkers.push(worker);
+				this.processQueue();
+			}
+			return;
+		}
 		this.activeTasks.delete(message.id);
 		if (task.timeoutHandle) {
 			clearTimeout(task.timeoutHandle);
@@ -930,11 +975,54 @@ var WorkerPool = class {
 	}
 	handleWorkerError(worker, error) {
 		console.error("Worker error:", error);
-		for (const [id, task] of this.activeTasks) if (this.workers.includes(worker)) {
+		if (!this.workers.includes(worker)) return;
+		for (const [id, task] of this.activeTasks) if (task.worker === worker) {
 			this.activeTasks.delete(id);
 			this.clearTaskTimer(task);
 			task.reject(/* @__PURE__ */ new Error(`Worker error: ${error.message}`));
 		}
+		if (!this.readyWorkers.has(worker)) {
+			this.startupFailures++;
+			if (this.startupFailures >= WorkerPool.MAX_STARTUP_FAILURES) {
+				this.workers = this.workers.filter((w) => w !== worker);
+				this.availableWorkers = this.availableWorkers.filter((w) => w !== worker);
+				try {
+					worker.terminate();
+				} catch {}
+				const reason = /* @__PURE__ */ new Error(`WorkerPool: ${this.startupFailures} consecutive workers failed before becoming ready (${error.message}); not respawning`);
+				for (const task of this.taskQueue.splice(0)) {
+					this.clearTaskTimer(task);
+					task.reject(reason);
+				}
+				return;
+			}
+		}
+		this.evictAndReplace(worker);
+	}
+	static MAX_STARTUP_FAILURES = 3;
+	isBusy(worker) {
+		for (const task of this.activeTasks.values()) if (task.worker === worker) return true;
+		return false;
+	}
+	async evictAndReplace(dead) {
+		try {
+			dead.terminate();
+		} catch {}
+		this.workers = this.workers.filter((w) => w !== dead);
+		this.availableWorkers = this.availableWorkers.filter((w) => w !== dead);
+		if (this.terminated) return;
+		try {
+			const replacement = await this.createWorker();
+			if (this.terminated) {
+				replacement.terminate();
+				return;
+			}
+			this.workers.push(replacement);
+			this.availableWorkers.push(replacement);
+			this.processQueue();
+		} catch (err) {
+			console.error("WorkerPool: failed to spawn replacement worker:", err);
+		}
 	}
 	processQueue() {
 		while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
@@ -1009,7 +1097,7 @@ var WorkerPool = class {
 		});
 	}
 	generateTaskId() {
-		return `task_${Date.now()}_${globalThis.crypto.randomUUID()}`;
+		return `task_${++taskCounter}`;
 	}
 	async terminate() {
 		this.terminated = true;
@@ -1046,137 +1134,137 @@ var WorkerPool = class {
 //#endregion
 //#region src/operations/matmul.ts
 async function parallelMatmul(a, aRows, aCols, b, bCols, options = {}) {
-	return (options.pool ?? computePool).matmul(a, aRows, aCols, b, bCols);
+	return (options.pool ?? computePool).matmul(a, aRows, aCols, b, bCols, options);
 }
 async function parallelMatvec(matrix, rows, cols, vector, options = {}) {
-	return (options.pool ?? computePool).matvec(matrix, rows, cols, vector);
+	return (options.pool ?? computePool).matvec(matrix, rows, cols, vector, options);
 }
 async function parallelTranspose(data, rows, cols, options = {}) {
-	return (options.pool ?? computePool).transpose(data, rows, cols);
+	return (options.pool ?? computePool).transpose(data, rows, cols, options);
 }
 async function parallelOuter(a, b, options = {}) {
-	return (options.pool ?? computePool).outer(a, b);
+	return (options.pool ?? computePool).outer(a, b, options);
 }
 async function parallelDot(a, b, options = {}) {
-	return (options.pool ?? computePool).dot(a, b);
+	return (options.pool ?? computePool).dot(a, b, options);
 }
 //#endregion
 //#region src/operations/elementwise.ts
 async function parallelAdd(a, b, options = {}) {
-	return (options.pool ?? computePool).add(a, b);
+	return (options.pool ?? computePool).add(a, b, options);
 }
 async function parallelSubtract(a, b, options = {}) {
-	return (options.pool ?? computePool).subtract(a, b);
+	return (options.pool ?? computePool).subtract(a, b, options);
 }
 async function parallelMultiply(a, b, options = {}) {
-	return (options.pool ?? computePool).multiply(a, b);
+	return (options.pool ?? computePool).multiply(a, b, options);
 }
 async function parallelDivide(a, b, options = {}) {
-	return (options.pool ?? computePool).divide(a, b);
+	return (options.pool ?? computePool).divide(a, b, options);
 }
 async function parallelScale(data, scalar, options = {}) {
-	return (options.pool ?? computePool).scale(data, scalar);
+	return (options.pool ?? computePool).scale(data, scalar, options);
 }
 async function parallelAbs(data, options = {}) {
-	return (options.pool ?? computePool).abs(data);
+	return (options.pool ?? computePool).abs(data, options);
 }
 async function parallelNegate(data, options = {}) {
-	return (options.pool ?? computePool).negate(data);
+	return (options.pool ?? computePool).negate(data, options);
 }
 async function parallelSquare(data, options = {}) {
-	return (options.pool ?? computePool).square(data);
+	return (options.pool ?? computePool).square(data, options);
 }
 async function parallelSqrt(data, options = {}) {
-	return (options.pool ?? computePool).sqrt(data);
+	return (options.pool ?? computePool).sqrt(data, options);
 }
 async function parallelExp(data, options = {}) {
-	return (options.pool ?? computePool).exp(data);
+	return (options.pool ?? computePool).exp(data, options);
 }
 async function parallelLog(data, options = {}) {
-	return (options.pool ?? computePool).log(data);
+	return (options.pool ?? computePool).log(data, options);
 }
 async function parallelSin(data, options = {}) {
-	return (options.pool ?? computePool).sin(data);
+	return (options.pool ?? computePool).sin(data, options);
 }
 async function parallelCos(data, options = {}) {
-	return (options.pool ?? computePool).cos(data);
+	return (options.pool ?? computePool).cos(data, options);
 }
 async function parallelTan(data, options = {}) {
-	return (options.pool ?? computePool).tan(data);
+	return (options.pool ?? computePool).tan(data, options);
 }
 async function parallelElementwise(a, b, op, options = {}) {
-	return (options.pool ?? computePool).elementwise(a, b, op);
+	return (options.pool ?? computePool).elementwise(a, b, op, options);
 }
 async function parallelUnary(data, fn, options = {}) {
-	return (options.pool ?? computePool).unary(data, fn);
+	return (options.pool ?? computePool).unary(data, fn, options);
 }
 //#endregion
 //#region src/operations/reduce.ts
 async function parallelSum(data, options = {}) {
-	return (options.pool ?? computePool).sum(data);
+	return (options.pool ?? computePool).sum(data, options);
 }
 async function parallelMean(data, options = {}) {
-	return (options.pool ?? computePool).mean(data);
+	return (options.pool ?? computePool).mean(data, options);
 }
 async function parallelMin(data, options = {}) {
-	return (options.pool ?? computePool).min(data);
+	return (options.pool ?? computePool).min(data, options);
 }
 async function parallelMax(data, options = {}) {
-	return (options.pool ?? computePool).max(data);
+	return (options.pool ?? computePool).max(data, options);
 }
 async function parallelMinMax(data, options = {}) {
-	return (options.pool ?? computePool).minMax(data);
+	return (options.pool ?? computePool).minMax(data, options);
 }
 async function parallelVariance(data, options = {}) {
-	return (options.pool ?? computePool).variance(data);
+	return (options.pool ?? computePool).variance(data, options);
 }
 async function parallelStd(data, options = {}) {
-	return (options.pool ?? computePool).std(data);
+	return (options.pool ?? computePool).std(data, options);
 }
 async function parallelNorm(data, options = {}) {
-	return (options.pool ?? computePool).norm(data);
+	return (options.pool ?? computePool).norm(data, options);
 }
 async function parallelDistance(a, b, options = {}) {
-	return (options.pool ?? computePool).distance(a, b);
+	return (options.pool ?? computePool).distance(a, b, options);
 }
 async function parallelHistogram(data, bins, min, max, options = {}) {
-	return (options.pool ?? computePool).histogram(data, bins, min, max);
+	return (options.pool ?? computePool).histogram(data, bins, min, max, options);
 }
 async function parallelReduce(data, fn, initial, options = {}) {
-	return (options.pool ?? computePool).reduce(data, fn, initial);
+	return (options.pool ?? computePool).reduce(data, fn, initial, options);
 }
 //#endregion
 //#region src/operations/map.ts
 async function parallelMap(data, fn, options = {}) {
-	return (options.pool ?? computePool).map(data, fn);
+	return (options.pool ?? computePool).map(data, fn, options);
 }
 async function parallelFilter(data, predicate, options = {}) {
-	return (options.pool ?? computePool).filter(data, predicate);
+	return (options.pool ?? computePool).filter(data, predicate, options);
 }
 async function parallelFind(data, predicate, options = {}) {
-	return (options.pool ?? computePool).find(data, predicate);
+	return (options.pool ?? computePool).find(data, predicate, options);
 }
 async function parallelSort(data, compare, options = {}) {
-	return (options.pool ?? computePool).sort(data, compare);
+	return (options.pool ?? computePool).sort(data, compare, options);
 }
 async function parallelForEach(data, fn, options = {}) {
 	const result = await (options.pool ?? computePool).map(data, (item) => {
 		fn(item);
-	});
+	}, options);
 	return {
 		...result,
 		result: result.result
 	};
 }
 async function parallelSome(data, predicate, options = {}) {
-	const findResult = await (options.pool ?? computePool).find(data, predicate);
+	const findResult = await (options.pool ?? computePool).find(data, predicate, options);
 	return {
 		...findResult,
 		result: findResult.result.found
 	};
 }
 async function parallelEvery(data, predicate, options = {}) {
-	const findResult = await (options.pool ?? computePool).find(data, (item) => !predicate(item));
+	const findResult = await (options.pool ?? computePool).find(data, (item) => !predicate(item), options);
 	return {
 		...findResult,
 		result: !findResult.result.found
@@ -1190,7 +1278,7 @@ async function parallelCount(data, predicate, options = {}) {
 		chunks: 1,
 		parallelized: false
 	};
-	const filterResult = await pool.filter(data, predicate);
+	const filterResult = await pool.filter(data, predicate, options);
 	return {
 		...filterResult,
 		result: filterResult.result.length

package/dist/operations/map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/operations/map.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,uDAAuD;IACvD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,CAAC,EACpC,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAClB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAGxE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAChC,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,EACrB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,CAUjC;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAOlC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAQlC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAChC,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAkBjC"}
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/operations/map.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,uDAAuD;IACvD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,CAAC,EACpC,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAClB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAGxE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAChC,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,EACrB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,CAcjC;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAOlC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAQlC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAChC,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAkBjC"}

package/dist/ops/bitwise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/ops/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEnF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GACzB,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAwEpF;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEvF;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEtF;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEvF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,UAAU,CAiB5E"}
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/ops/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGnF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GACzB,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAsEpF;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEvF;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEtF;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEvF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,UAAU,CAiB5E"}

package/dist/validate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Argument validation shared by the parallel operations.
+ *
+ * Every check throws one message shape per kind of mistake, so callers and tests can match a
+ * single text whatever the size of the input or the path (inline or workers) it would take.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Length check for binary element-wise operations: `<op>: lengths must match (<a> vs <b>)`.
+ * @internal
+ */
+export declare function assertSameLength(op: string, a: number, b: number): void;
+/**
+ * Shape check for a row-major `aRows x aCols` times `bRows x bCols` product. Checks the inner
+ * dimensions and that both buffers hold exactly the elements their shapes claim.
+ * @internal
+ */
+export declare function assertMatmulShape(op: string, aLength: number, aRows: number, aCols: number, bLength: number, bRows: number, bCols: number): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,IAAI,CAUN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-parallel",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "WebWorker parallelization for MathTS computations",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -42,8 +42,8 @@
     }
   },
   "dependencies": {
-    "@danielsimonjr/mathts-workerpool": "^0.2.7",
-    "@danielsimonjr/mathts-core": "^0.21.0"
+    "@danielsimonjr/mathts-workerpool": "^0.3.0",
+    "@danielsimonjr/mathts-core": "^0.21.1"
   },
   "devDependencies": {
     "@types/node": "^26.4.0",