@danielsimonjr/mathts-parallel 0.6.10 → 0.7.0

package/dist/index.js

@@ -1,1885 +1,1292 @@
-// src/ComputePool.ts
-import {
-  pairwiseSum,
-  norm2,
-  pairwiseDot,
-  scaledDistance,
-  sumSquaredDeviations
-} from "@danielsimonjr/mathts-core";
-import {
-  MathWorkerPool,
-  Transfer
-} from "@danielsimonjr/mathts-workerpool";
-
-// src/strategies/chunk.ts
-var DEFAULT_CHUNK_OPTIONS = {
-  minChunkSize: 1e3,
-  maxChunks: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4,
-  targetChunkSize: 0,
-  // 0 = auto
-  balanced: true
+import { norm2, pairwiseDot, pairwiseSum, scaledDistance, sumSquaredDeviations } from "@danielsimonjr/mathts-core";
+import { MathWorkerPool, Transfer, tensordotRange } from "@danielsimonjr/mathts-workerpool";
+//#region src/strategies/chunk.ts
+const DEFAULT_CHUNK_OPTIONS = {
+	minChunkSize: 1e3,
+	maxChunks: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4,
+	targetChunkSize: 0,
+	balanced: true
 };
+function planChunks(totalElements, options = {}, unbalancedChunkMin = 0) {
+	const { balanced } = {
+		...DEFAULT_CHUNK_OPTIONS,
+		...options
+	};
+	if (totalElements === 0) return [];
+	const numChunks = calculateOptimalChunks(totalElements, options);
+	if (numChunks <= 1) return [{
+		startIndex: 0,
+		endIndex: totalElements,
+		length: totalElements,
+		chunkIndex: 0
+	}];
+	const chunkInfo = [];
+	if (balanced) {
+		const baseChunkSize = Math.floor(totalElements / numChunks);
+		const remainder = totalElements % numChunks;
+		let currentIndex = 0;
+		for (let i = 0; i < numChunks; i++) {
+			const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
+			const endIndex = currentIndex + thisChunkSize;
+			chunkInfo.push({
+				startIndex: currentIndex,
+				endIndex,
+				length: thisChunkSize,
+				chunkIndex: i
+			});
+			currentIndex = endIndex;
+		}
+	} else {
+		const chunkSize = Math.max(unbalancedChunkMin, Math.ceil(totalElements / numChunks));
+		let currentIndex = 0;
+		let chunkIndex = 0;
+		while (currentIndex < totalElements) {
+			const endIndex = Math.min(currentIndex + chunkSize, totalElements);
+			const thisChunkSize = endIndex - currentIndex;
+			chunkInfo.push({
+				startIndex: currentIndex,
+				endIndex,
+				length: thisChunkSize,
+				chunkIndex
+			});
+			currentIndex = endIndex;
+			chunkIndex++;
+		}
+	}
+	return chunkInfo;
+}
 function calculateOptimalChunks(totalElements, options = {}) {
-  const { minChunkSize, maxChunks, targetChunkSize } = {
-    ...DEFAULT_CHUNK_OPTIONS,
-    ...options
-  };
-  if (totalElements === 0) return 0;
-  if (targetChunkSize > 0) {
-    return Math.min(maxChunks, Math.ceil(totalElements / targetChunkSize));
-  }
-  const maxPossibleChunks = Math.floor(totalElements / minChunkSize);
-  return Math.max(1, Math.min(maxChunks, maxPossibleChunks));
+	const { minChunkSize, maxChunks, targetChunkSize } = {
+		...DEFAULT_CHUNK_OPTIONS,
+		...options
+	};
+	if (totalElements === 0) return 0;
+	if (targetChunkSize > 0) return Math.min(maxChunks, Math.ceil(totalElements / targetChunkSize));
+	const maxPossibleChunks = Math.floor(totalElements / minChunkSize);
+	return Math.max(1, Math.min(maxChunks, maxPossibleChunks));
+}
+function assembleChunks(totalElements, options, minChunkSizeForPlan, whole, materialize) {
+	if (totalElements === 0) return {
+		chunks: [],
+		chunkInfo: [],
+		totalElements: 0,
+		numChunks: 0
+	};
+	const planned = calculateOptimalChunks(totalElements, options);
+	const chunkInfo = planChunks(totalElements, options, minChunkSizeForPlan);
+	if (planned <= 1) return {
+		chunks: [whole],
+		chunkInfo,
+		totalElements,
+		numChunks: 1
+	};
+	const chunks = chunkInfo.map((info) => materialize(info.startIndex, info.endIndex));
+	return {
+		chunks,
+		chunkInfo,
+		totalElements,
+		numChunks: chunks.length
+	};
 }
 function chunkFloat64Array(data, options = {}) {
-  const { minChunkSize, balanced } = { ...DEFAULT_CHUNK_OPTIONS, ...options };
-  const totalElements = data.length;
-  if (totalElements === 0) {
-    return {
-      chunks: [],
-      chunkInfo: [],
-      totalElements: 0,
-      numChunks: 0
-    };
-  }
-  const numChunks = calculateOptimalChunks(totalElements, options);
-  if (numChunks <= 1) {
-    return {
-      chunks: [data],
-      chunkInfo: [
-        {
-          startIndex: 0,
-          endIndex: totalElements,
-          length: totalElements,
-          chunkIndex: 0
-        }
-      ],
-      totalElements,
-      numChunks: 1
-    };
-  }
-  const chunks = [];
-  const chunkInfo = [];
-  if (balanced) {
-    const baseChunkSize = Math.floor(totalElements / numChunks);
-    const remainder = totalElements % numChunks;
-    let currentIndex = 0;
-    for (let i = 0; i < numChunks; i++) {
-      const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
-      const endIndex = currentIndex + thisChunkSize;
-      chunks.push(data.subarray(currentIndex, endIndex));
-      chunkInfo.push({
-        startIndex: currentIndex,
-        endIndex,
-        length: thisChunkSize,
-        chunkIndex: i
-      });
-      currentIndex = endIndex;
-    }
-  } else {
-    const chunkSize = Math.max(minChunkSize, Math.ceil(totalElements / numChunks));
-    let currentIndex = 0;
-    let chunkIndex = 0;
-    while (currentIndex < totalElements) {
-      const endIndex = Math.min(currentIndex + chunkSize, totalElements);
-      const thisChunkSize = endIndex - currentIndex;
-      chunks.push(data.subarray(currentIndex, endIndex));
-      chunkInfo.push({
-        startIndex: currentIndex,
-        endIndex,
-        length: thisChunkSize,
-        chunkIndex
-      });
-      currentIndex = endIndex;
-      chunkIndex++;
-    }
-  }
-  return {
-    chunks,
-    chunkInfo,
-    totalElements,
-    numChunks: chunks.length
-  };
+	const { minChunkSize } = {
+		...DEFAULT_CHUNK_OPTIONS,
+		...options
+	};
+	return assembleChunks(data.length, options, minChunkSize, data, (start, end) => data.subarray(start, end));
 }
 function chunkArray(data, options = {}) {
-  const { balanced } = { ...DEFAULT_CHUNK_OPTIONS, ...options };
-  const totalElements = data.length;
-  if (totalElements === 0) {
-    return {
-      chunks: [],
-      chunkInfo: [],
-      totalElements: 0,
-      numChunks: 0
-    };
-  }
-  const numChunks = calculateOptimalChunks(totalElements, options);
-  if (numChunks <= 1) {
-    return {
-      chunks: [data],
-      chunkInfo: [
-        {
-          startIndex: 0,
-          endIndex: totalElements,
-          length: totalElements,
-          chunkIndex: 0
-        }
-      ],
-      totalElements,
-      numChunks: 1
-    };
-  }
-  const chunks = [];
-  const chunkInfo = [];
-  if (balanced) {
-    const baseChunkSize = Math.floor(totalElements / numChunks);
-    const remainder = totalElements % numChunks;
-    let currentIndex = 0;
-    for (let i = 0; i < numChunks; i++) {
-      const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
-      const endIndex = currentIndex + thisChunkSize;
-      chunks.push(data.slice(currentIndex, endIndex));
-      chunkInfo.push({
-        startIndex: currentIndex,
-        endIndex,
-        length: thisChunkSize,
-        chunkIndex: i
-      });
-      currentIndex = endIndex;
-    }
-  } else {
-    const chunkSize = Math.ceil(totalElements / numChunks);
-    let currentIndex = 0;
-    let chunkIndex = 0;
-    while (currentIndex < totalElements) {
-      const endIndex = Math.min(currentIndex + chunkSize, totalElements);
-      const thisChunkSize = endIndex - currentIndex;
-      chunks.push(data.slice(currentIndex, endIndex));
-      chunkInfo.push({
-        startIndex: currentIndex,
-        endIndex,
-        length: thisChunkSize,
-        chunkIndex
-      });
-      currentIndex = endIndex;
-      chunkIndex++;
-    }
-  }
-  return {
-    chunks,
-    chunkInfo,
-    totalElements,
-    numChunks: chunks.length
-  };
+	return assembleChunks(data.length, options, 0, data, (start, end) => data.slice(start, end));
 }
 function mergeFloat64Chunks(chunks) {
-  if (chunks.length === 0) return new Float64Array(0);
-  if (chunks.length === 1) return chunks[0];
-  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-  const result = new Float64Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return result;
+	if (chunks.length === 0) return /* @__PURE__ */ new Float64Array(0);
+	if (chunks.length === 1) return chunks[0];
+	const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+	const result = new Float64Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
 }
 function mergeArrayChunks(chunks) {
-  if (chunks.length === 0) return [];
-  if (chunks.length === 1) return chunks[0];
-  return chunks.flat();
+	if (chunks.length === 0) return [];
+	if (chunks.length === 1) return chunks[0];
+	return chunks.flat();
 }
 function shouldParallelize(elementCount, threshold = 1e4) {
-  return elementCount >= threshold;
+	return elementCount >= threshold;
 }
 function partitionRange(start, end, options = {}) {
-  const totalElements = end - start;
-  const numChunks = calculateOptimalChunks(totalElements, options);
-  if (numChunks <= 1) {
-    return [[start, end]];
-  }
-  const partitions = [];
-  const baseChunkSize = Math.floor(totalElements / numChunks);
-  const remainder = totalElements % numChunks;
-  let currentIndex = start;
-  for (let i = 0; i < numChunks; i++) {
-    const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
-    const endIndex = currentIndex + thisChunkSize;
-    partitions.push([currentIndex, endIndex]);
-    currentIndex = endIndex;
-  }
-  return partitions;
+	const totalElements = end - start;
+	const numChunks = calculateOptimalChunks(totalElements, options);
+	if (numChunks <= 1) return [[start, end]];
+	const partitions = [];
+	const baseChunkSize = Math.floor(totalElements / numChunks);
+	const remainder = totalElements % numChunks;
+	let currentIndex = start;
+	for (let i = 0; i < numChunks; i++) {
+		const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
+		const endIndex = currentIndex + thisChunkSize;
+		partitions.push([currentIndex, endIndex]);
+		currentIndex = endIndex;
+	}
+	return partitions;
 }
 function partition2D(rows, cols, options = {}) {
-  const rowPartitions = partitionRange(0, rows, options);
-  return rowPartitions.map(([rowStart, rowEnd]) => [rowStart, rowEnd, 0, cols]);
-}
-
-// src/ops/bitwise.ts
+	return partitionRange(0, rows, options).map(([rowStart, rowEnd]) => [
+		rowStart,
+		rowEnd,
+		0,
+		cols
+	]);
+}
+//#endregion
+//#region src/ops/bitwise.ts
 function applyBinaryChunk(a, b, out, start, length, outStart, op) {
-  const end = start + length;
-  switch (op) {
-    case "bitAnd":
-      for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] & b[i];
-      return;
-    case "bitOr":
-      for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] | b[i];
-      return;
-    case "bitXor":
-      for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] ^ b[i];
-      return;
-    case "leftShift":
-      for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] << b[i];
-      return;
-    case "rightArithShift":
-      for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] >> b[i];
-      return;
-    case "rightLogShift":
-      for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] >>> b[i];
-      return;
-  }
+	const end = start + length;
+	switch (op) {
+		case "bitAnd":
+			for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] & b[i];
+			return;
+		case "bitOr":
+			for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] | b[i];
+			return;
+		case "bitXor":
+			for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] ^ b[i];
+			return;
+		case "leftShift":
+			for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] << b[i];
+			return;
+		case "rightArithShift":
+			for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] >> b[i];
+			return;
+		case "rightLogShift":
+			for (let i = start; i < end; i++) out[outStart + (i - start)] = a[i] >>> b[i];
+			return;
+	}
 }
 function runBinary(a, b, op, options = {}) {
-  if (a.length !== b.length) {
-    throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-  }
-  const out = new Int32Array(a.length);
-  if (a.length === 0) return out;
-  const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
-  const base = Math.floor(a.length / numChunks);
-  const remainder = a.length % numChunks;
-  let start = 0;
-  for (let c = 0; c < numChunks; c++) {
-    const len = base + (c < remainder ? 1 : 0);
-    if (len === 0) continue;
-    applyBinaryChunk(a, b, out, start, len, start, op);
-    start += len;
-  }
-  return out;
+	if (a.length !== b.length) throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
+	const out = new Int32Array(a.length);
+	if (a.length === 0) return out;
+	const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
+	const base = Math.floor(a.length / numChunks);
+	const remainder = a.length % numChunks;
+	let start = 0;
+	for (let c = 0; c < numChunks; c++) {
+		const len = base + (c < remainder ? 1 : 0);
+		if (len === 0) continue;
+		applyBinaryChunk(a, b, out, start, len, start, op);
+		start += len;
+	}
+	return out;
 }
 function bitAnd(a, b, options) {
-  return runBinary(a, b, "bitAnd", options);
+	return runBinary(a, b, "bitAnd", options);
 }
 function bitOr(a, b, options) {
-  return runBinary(a, b, "bitOr", options);
+	return runBinary(a, b, "bitOr", options);
 }
 function bitXor(a, b, options) {
-  return runBinary(a, b, "bitXor", options);
+	return runBinary(a, b, "bitXor", options);
 }
 function leftShift(a, b, options) {
-  if (typeof b === "number") return runBinaryScalar(a, b, "leftShift", options);
-  return runBinary(a, b, "leftShift", options);
+	if (typeof b === "number") return runBinaryScalar(a, b, "leftShift", options);
+	return runBinary(a, b, "leftShift", options);
 }
 function rightArithShift(a, b, options) {
-  if (typeof b === "number") return runBinaryScalar(a, b, "rightArithShift", options);
-  return runBinary(a, b, "rightArithShift", options);
+	if (typeof b === "number") return runBinaryScalar(a, b, "rightArithShift", options);
+	return runBinary(a, b, "rightArithShift", options);
 }
 function rightLogShift(a, b, options) {
-  if (typeof b === "number") return runBinaryScalar(a, b, "rightLogShift", options);
-  return runBinary(a, b, "rightLogShift", options);
+	if (typeof b === "number") return runBinaryScalar(a, b, "rightLogShift", options);
+	return runBinary(a, b, "rightLogShift", options);
 }
 function bitNot(a, options = {}) {
-  const out = new Int32Array(a.length);
-  if (a.length === 0) return out;
-  const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
-  const base = Math.floor(a.length / numChunks);
-  const remainder = a.length % numChunks;
-  let start = 0;
-  for (let c = 0; c < numChunks; c++) {
-    const len = base + (c < remainder ? 1 : 0);
-    if (len === 0) continue;
-    const end = start + len;
-    for (let i = start; i < end; i++) out[i] = ~a[i];
-    start += len;
-  }
-  return out;
+	const out = new Int32Array(a.length);
+	if (a.length === 0) return out;
+	const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
+	const base = Math.floor(a.length / numChunks);
+	const remainder = a.length % numChunks;
+	let start = 0;
+	for (let c = 0; c < numChunks; c++) {
+		const len = base + (c < remainder ? 1 : 0);
+		if (len === 0) continue;
+		const end = start + len;
+		for (let i = start; i < end; i++) out[i] = ~a[i];
+		start += len;
+	}
+	return out;
 }
 function runBinaryScalar(a, scalar, op, options = {}) {
-  const out = new Int32Array(a.length);
-  if (a.length === 0) return out;
-  const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
-  const base = Math.floor(a.length / numChunks);
-  const remainder = a.length % numChunks;
-  let start = 0;
-  for (let c = 0; c < numChunks; c++) {
-    const len = base + (c < remainder ? 1 : 0);
-    if (len === 0) continue;
-    const end = start + len;
-    switch (op) {
-      case "leftShift":
-        for (let i = start; i < end; i++) out[i] = a[i] << scalar;
-        break;
-      case "rightArithShift":
-        for (let i = start; i < end; i++) out[i] = a[i] >> scalar;
-        break;
-      case "rightLogShift":
-        for (let i = start; i < end; i++) out[i] = a[i] >>> scalar;
-        break;
-      // The non-shift ops never go through the scalar path — caller
-      // routes only the three shift ops here. Listed for exhaustiveness.
-      case "bitAnd":
-        for (let i = start; i < end; i++) out[i] = a[i] & scalar;
-        break;
-      case "bitOr":
-        for (let i = start; i < end; i++) out[i] = a[i] | scalar;
-        break;
-      case "bitXor":
-        for (let i = start; i < end; i++) out[i] = a[i] ^ scalar;
-        break;
-    }
-    start += len;
-  }
-  return out;
-}
-
-// src/ComputePool.ts
+	const out = new Int32Array(a.length);
+	if (a.length === 0) return out;
+	const numChunks = Math.max(1, calculateOptimalChunks(a.length, options));
+	const base = Math.floor(a.length / numChunks);
+	const remainder = a.length % numChunks;
+	let start = 0;
+	for (let c = 0; c < numChunks; c++) {
+		const len = base + (c < remainder ? 1 : 0);
+		if (len === 0) continue;
+		const end = start + len;
+		switch (op) {
+			case "leftShift":
+				for (let i = start; i < end; i++) out[i] = a[i] << scalar;
+				break;
+			case "rightArithShift":
+				for (let i = start; i < end; i++) out[i] = a[i] >> scalar;
+				break;
+			case "rightLogShift":
+				for (let i = start; i < end; i++) out[i] = a[i] >>> scalar;
+				break;
+			case "bitAnd":
+				for (let i = start; i < end; i++) out[i] = a[i] & scalar;
+				break;
+			case "bitOr":
+				for (let i = start; i < end; i++) out[i] = a[i] | scalar;
+				break;
+			case "bitXor": for (let i = start; i < end; i++) out[i] = a[i] ^ scalar;
+		}
+		start += len;
+	}
+	return out;
+}
+//#endregion
+//#region src/ComputePool.ts
 function resolveOpThreshold(t) {
-  if (t === "never") return Number.MAX_SAFE_INTEGER;
-  if (t === "always") return 0;
-  return t;
-}
-var DEFAULT_THRESHOLD_BY_OP = {
-  // element-wise: overhead dominates at all tested sizes
-  add: "never",
-  subtract: "never",
-  multiply: "never",
-  divide: "never",
-  pow: "never",
-  scale: "never",
-  abs: "never",
-  negate: "never",
-  exp: "never",
-  log: "never",
-  sin: "never",
-  cos: "never",
-  tan: "never",
-  sign: "never",
-  // Added 2026-07-02 (WS-2): these element-wise ops were absent from the map and
-  // silently defaulted to the 50 000 global threshold — an inconsistency with their
-  // siblings above (surfaced by parallel-pairing.md). Benchmarked (tools/benchmark/
-  // parallel/run.ts sqrt square) — memory-bound, speedup 0.12–0.65×, no persistent
-  // break-even → 'never', matching the class.
-  sqrt: "never",
-  square: "never",
-  // tensor contraction: parallelize when contracted-axis volume >= 8K
-  tensordot: 8192,
-  // reductions: overhead dominates
-  sum: "never",
-  mean: "never",
-  variance: "never",
-  parallelStatProd: "never",
-  normalCDF: "never",
-  // Added 2026-07-02 (WS-2): reductions that were absent from the map and defaulted
-  // to the global threshold; benchmarked memory-bound (0.09–1.19×, occasional noise
-  // spikes but no persistent win) → 'never'.
-  norm: "never",
-  // ACCURACY NOTE: `dot`/`distance` staying 'never' is also what keeps them stable. The
-  // sequential fallbacks use core's pairwiseDot / scaledDistance, but the worker kernels
-  // (dotChunk / distanceChunk in workerpool) still accumulate naively. Do NOT tune these off
-  // 'never' without giving those kernels the same pairwise/scaled accumulation first, or large
-  // inputs — the regime where O(n)·ε is worst — would silently revert to naive accuracy.
-  dot: "never",
-  // Added 2026-07-02 (WS-2): `min`/`max` are now `OpName`s (added to the union) so
-  // they're tunable. Same memory-bound reduction profile as sum/mean/norm above →
-  // 'never'. Their `functions/` call sites previously dispatched to the worker pool
-  // unconditionally (no `shouldParallelize` gate), paying dispatch overhead on every
-  // call; they now respect this threshold (sequential) with a `shouldParallelize` gate.
-  min: "never",
-  max: "never",
-  // Added 2026-07-03 (WS-2, DGT sweep): the remaining memory-bound reductions that
-  // defaulted to the 50 000 global threshold and dispatched unconditionally at every
-  // `functions/` call site. Same class as sum/mean/min/max/norm/dot → 'never'. Now
-  // gated INSIDE the ComputePool reduction methods (inline sequential fallback), so
-  // ALL call sites honor the threshold without per-site edits. `std` derives from
-  // `variance`; `min`/`max` derive from `minMax`.
-  minMax: "never",
-  std: "never",
-  prod: "never",
-  distance: "never",
-  // Added 2026-07-04 (WS-2 completion): the five OpNames that were absent from
-  // this map and silently rode the untested 50 000 global default. Benchmarked
-  // (tools/benchmarks/ws2-missing-ops.mjs, medians of 9 interleaved reps):
-  // histogram 0.23-0.56x, transpose 0.01-0.28x, matvec 0.00-0.05x, outer
-  // 0.01-0.50x at every size up to 4.2M elements - memory-bound / copy-dominated,
-  // no break-even -> 'never'. Their ComputePool methods previously dispatched to
-  // the worker pool UNCONDITIONALLY (no shouldParallelize gate); they now gate
-  // with an inline sequential fallback like the reductions above.
-  histogram: "never",
-  transpose: "never",
-  matvec: "never",
-  outer: "never",
-  // integrateFanOut loses ~50-100x for cheap integrands (0.01-0.02x at 128-32768
-  // evals). The fan-out is CALLER-OPT-IN (integration.ts dispatches only when the
-  // caller passes workerCount > 1), so this entry documents the default posture;
-  // no shouldParallelize call consults it. Expensive (ms-scale) integrands are the
-  // one case where the fan-out pays off.
-  integrateChunk: "never",
-  // Added 2026-07-05 (WS-2 addendum): the bitwise family gated via a NAMELESS
-  // shouldParallelize(len) -> the untested global 50k. Benchmarked
-  // (tools/benchmarks/ws2-bitwise-ops.mjs, medians of 9 interleaved reps):
-  // bitAnd 0.07-0.15x, bitNot 0.06-0.09x, leftShift 0.04-0.07x at every size up
-  // to 4M elements - Int32Array element-wise is maximally memory-bound; the
-  // worker path loses 7-25x. All seven -> 'never'; the methods now pass their
-  // op name so these entries actually govern.
-  bitAnd: "never",
-  bitOr: "never",
-  bitXor: "never",
-  bitNot: "never",
-  leftShift: "never",
-  rightArithShift: "never",
-  rightLogShift: "never",
-  // signal: overhead dominates or break-even never reached
-  parallelFFT: "never",
-  parallelConv: "never",
-  fft2d: "never",
-  // geometry: overhead dominates
-  distanceMatrix: "never",
-  // special functions: parallel wins above these sizes
-  erfc: 1e5,
-  besselJ: 1e6,
-  spectrogram: 65536,
-  // linear algebra: parallel wins above these element counts
-  matmul: 4096,
-  // break-even at 64×64 (4,096 elements)
-  matrixPower: 9216,
-  // break-even at ~96×96
-  characteristicPolynomial: 9216,
-  // break-even at ~96×96
-  // hypothesis tests: element-wise reduction (chiSquare) and post-sort
-  // dot-product (KS/MW/SW). Threshold 4096 per Slice 3.10 spec.
-  chiSquareTest: 4096,
-  kolmogorovSmirnovTest: 4096,
-  mannWhitneyTest: 4096,
-  shapiroWilkTest: 4096,
-  // distribution batch sampling: per-sample cost (rejection/transcendental) amortises
-  // worker overhead above 100 000 samples (Slice 5.12).
-  sampleChunk: 1e5
+	if (t === "never") return Number.MAX_SAFE_INTEGER;
+	if (t === "always") return 0;
+	return t;
+}
+const DEFAULT_THRESHOLD_BY_OP = {
+	add: "never",
+	subtract: "never",
+	multiply: "never",
+	divide: "never",
+	pow: "never",
+	scale: "never",
+	abs: "never",
+	negate: "never",
+	exp: "never",
+	log: "never",
+	sin: "never",
+	cos: "never",
+	tan: "never",
+	sign: "never",
+	sqrt: "never",
+	square: "never",
+	tensordot: 8192,
+	sum: "never",
+	mean: "never",
+	variance: "never",
+	parallelStatProd: "never",
+	normalCDF: "never",
+	norm: "never",
+	dot: "never",
+	min: "never",
+	max: "never",
+	minMax: "never",
+	std: "never",
+	prod: "never",
+	distance: "never",
+	histogram: "never",
+	transpose: "never",
+	matvec: "never",
+	outer: "never",
+	integrateChunk: "never",
+	bitAnd: "never",
+	bitOr: "never",
+	bitXor: "never",
+	bitNot: "never",
+	leftShift: "never",
+	rightArithShift: "never",
+	rightLogShift: "never",
+	parallelFFT: "never",
+	parallelConv: "never",
+	fft2d: "never",
+	distanceMatrix: "never",
+	erfc: 1e5,
+	besselJ: 1e6,
+	spectrogram: 65536,
+	matmul: 4096,
+	matrixPower: 9216,
+	characteristicPolynomial: 9216,
+	chiSquareTest: 4096,
+	kolmogorovSmirnovTest: 4096,
+	mannWhitneyTest: 4096,
+	shapiroWilkTest: 4096,
+	sampleChunk: 1e5
 };
-var DEFAULT_POOL_CONFIG = {
-  enabled: true,
-  minWorkers: 1,
-  maxWorkers: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4,
-  thresholdElements: 5e4,
-  thresholdByOp: DEFAULT_THRESHOLD_BY_OP,
-  chunkSize: 1e4,
-  workerType: "auto",
-  workerIdleTimeout: 6e4,
-  taskTimeout: 3e5
-  // 5 minutes
+const DEFAULT_POOL_CONFIG = {
+	enabled: true,
+	minWorkers: 1,
+	maxWorkers: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4,
+	thresholdElements: 5e4,
+	thresholdByOp: DEFAULT_THRESHOLD_BY_OP,
+	chunkSize: 1e4,
+	workerType: "auto",
+	workerIdleTimeout: 6e4,
+	taskTimeout: 3e5
 };
 function mergeThresholds(base, override) {
-  return override === void 0 ? base : { ...base, ...override };
+	return override === void 0 ? base : {
+		...base,
+		...override
+	};
 }
 function toParallelResult(result) {
-  return {
-    result: result.result,
-    duration: result.duration,
-    chunks: result.chunks,
-    parallelized: result.parallelized
-  };
+	return {
+		result: result.result,
+		duration: result.duration,
+		chunks: result.chunks,
+		parallelized: result.parallelized
+	};
 }
 function toWorkerConfig(config) {
-  return {
-    enabled: config.enabled,
-    minWorkers: config.minWorkers,
-    maxWorkers: config.maxWorkers,
-    parallelThreshold: config.thresholdElements,
-    chunkSize: config.chunkSize,
-    workerType: config.workerType,
-    idleTimeout: config.workerIdleTimeout,
-    taskTimeout: config.taskTimeout
-  };
-}
-function _rowMajorStrides(shape) {
-  const strides = new Array(shape.length);
-  let stride = 1;
-  for (let i = shape.length - 1; i >= 0; i--) {
-    strides[i] = stride;
-    stride *= shape[i];
-  }
-  return strides;
-}
-function _flatIndex(idx, strides) {
-  let flat = 0;
-  for (let i = 0; i < idx.length; i++) flat += idx[i] * strides[i];
-  return flat;
-}
-function _forEachIndex(sizes, cb) {
-  const rank = sizes.length;
-  if (rank === 0) {
-    cb([]);
-    return;
-  }
-  const idx = new Array(rank).fill(0);
-  const total = sizes.reduce((a, b) => a * b, 1);
-  for (let n = 0; n < total; n++) {
-    cb(idx.slice());
-    for (let d = rank - 1; d >= 0; d--) {
-      idx[d]++;
-      if (idx[d] < sizes[d]) break;
-      idx[d] = 0;
-    }
-  }
-}
-function tensordotChunkKernel(a, aShape, b, bShape, axesA, axesB, resultShape, outStart, outEnd) {
-  const aStrides = _rowMajorStrides(aShape);
-  const bStrides = _rowMajorStrides(bShape);
-  const outStrides = _rowMajorStrides(resultShape);
-  const aRank = aShape.length;
-  const bRank = bShape.length;
-  const contractedAxesA = Array.from(axesA);
-  const contractedAxesB = Array.from(axesB);
-  const contractedSetA = new Set(contractedAxesA);
-  const contractedSetB = new Set(contractedAxesB);
-  const aFreeAxes = [];
-  const bFreeAxes = [];
-  for (let i = 0; i < aRank; i++) if (!contractedSetA.has(i)) aFreeAxes.push(i);
-  for (let i = 0; i < bRank; i++) if (!contractedSetB.has(i)) bFreeAxes.push(i);
-  const contractedSizes = contractedAxesA.map((ax) => aShape[ax]);
-  const chunkLen = outEnd - outStart;
-  const result = new Float64Array(chunkLen);
-  const outRank = resultShape.length;
-  const outIdx = new Array(outRank);
-  for (let outFlat = outStart; outFlat < outEnd; outFlat++) {
-    let rem = outFlat;
-    for (let d = 0; d < outRank; d++) {
-      outIdx[d] = Math.floor(rem / outStrides[d]);
-      rem -= outIdx[d] * outStrides[d];
-    }
-    const aFreeVals = outIdx.slice(0, aFreeAxes.length);
-    const bFreeVals = outIdx.slice(aFreeAxes.length);
-    let acc = 0;
-    _forEachIndex(contractedSizes, (contractVals) => {
-      const aIdx = new Array(aRank).fill(0);
-      for (let fi = 0; fi < aFreeAxes.length; fi++) aIdx[aFreeAxes[fi]] = aFreeVals[fi];
-      for (let ci = 0; ci < contractedAxesA.length; ci++)
-        aIdx[contractedAxesA[ci]] = contractVals[ci];
-      const bIdx = new Array(bRank).fill(0);
-      for (let fi = 0; fi < bFreeAxes.length; fi++) bIdx[bFreeAxes[fi]] = bFreeVals[fi];
-      for (let ci = 0; ci < contractedAxesB.length; ci++)
-        bIdx[contractedAxesB[ci]] = contractVals[ci];
-      acc += a[_flatIndex(aIdx, aStrides)] * b[_flatIndex(bIdx, bStrides)];
-    });
-    result[outFlat - outStart] = acc;
-  }
-  return result;
+	return {
+		enabled: config.enabled,
+		minWorkers: config.minWorkers,
+		maxWorkers: config.maxWorkers,
+		parallelThreshold: config.thresholdElements,
+		chunkSize: config.chunkSize,
+		workerType: config.workerType,
+		idleTimeout: config.workerIdleTimeout,
+		taskTimeout: config.taskTimeout
+	};
 }
 var ComputePool = class {
-  workerPool;
-  config;
-  constructor(config = {}) {
-    this.config = {
-      ...DEFAULT_POOL_CONFIG,
-      ...config,
-      thresholdByOp: mergeThresholds(DEFAULT_POOL_CONFIG.thresholdByOp, config.thresholdByOp)
-    };
-    this.workerPool = new MathWorkerPool(toWorkerConfig(this.config));
-  }
-  /**
-   * Initialize the worker pool
-   */
-  async initialize() {
-    await this.workerPool.initialize();
-  }
-  /**
-   * Check if pool is ready
-   */
-  isReady() {
-    return this.workerPool.isReady();
-  }
-  /**
-   * Determine if operation should be parallelized.
-   *
-   * When `op` is supplied the per-op threshold map is consulted first;
-   * if the op is absent from the map the global `thresholdElements` fallback
-   * 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, op) {
-    const byOp = this.config.thresholdByOp;
-    if (op !== void 0 && byOp !== void 0 && op in byOp) {
-      const raw = byOp[op];
-      if (raw !== void 0) {
-        const threshold = resolveOpThreshold(raw);
-        return this.config.enabled && elementCount >= threshold && this.workerPool.isReady();
-      }
-    }
-    return this.workerPool.shouldParallelize(elementCount);
-  }
-  /**
-   * Wrap a sequentially-computed reduction result in the `ParallelResult`
-   * envelope. Used by the reduction methods below so that ops whose threshold
-   * says "don't parallelize at this size" (notably the memory-bound reductions
-   * pinned to `'never'`) compute inline instead of paying a worker round-trip —
-   * previously every reduction dispatched to the pool unconditionally, ignoring
-   * its threshold.
-   */
-  seqResult(result) {
-    return { result, duration: 0, chunks: 1, parallelized: false };
-  }
-  /**
-   * Execute a method in the worker pool
-   */
-  async exec(method, params, options) {
-    return this.workerPool.exec(method, params, options);
-  }
-  /**
-   * Get pool statistics
-   */
-  stats() {
-    return this.workerPool.stats();
-  }
-  /**
-   * Parallel sum of array elements
-   */
-  async sum(data) {
-    if (!this.shouldParallelize(data.length, "sum")) {
-      return this.seqResult(pairwiseSum(data));
-    }
-    return toParallelResult(await this.workerPool.sum(data));
-  }
-  /**
-   * Parallel product of array elements
-   */
-  async prod(data) {
-    if (!this.shouldParallelize(data.length, "prod")) {
-      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));
-  }
-  /**
-   * Parallel dot product
-   */
-  async dot(a, b) {
-    if (!this.shouldParallelize(a.length, "dot")) {
-      if (a.length !== b.length) throw new Error("dot: vectors must have the same length");
-      return this.seqResult(pairwiseDot(a, b));
-    }
-    return toParallelResult(await this.workerPool.dot(a, b));
-  }
-  /**
-   * Pool options that apply `op`'s `thresholdByOp` entry to a call the pool decides itself.
-   *
-   * The worker pool's methods check only the global `thresholdElements`, so a method that
-   * forwarded without options let its entry govern nothing: `sin: 'never'` still went to the
-   * workers at 50,000 elements once the pool was initialized, and `matmul: 4_096` did not
-   * parallelize below 50,000. The bitwise family had the same bug (WS-2 addendum).
-   * `shouldParallelize` requires a ready pool, so `forceParallel` never reaches an idle one.
-   */
-  poolOptions(elementCount, op) {
-    return this.shouldParallelize(elementCount, op) ? { forceParallel: true } : { forceSequential: true };
-  }
-  /**
-   * Parallel element-wise operation
-   */
-  async elementwise(a, b, op) {
-    const result = await this.workerPool.elementwise(a, b, op, this.poolOptions(a.length, op));
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel scale operation
-   */
-  async scale(data, scalar) {
-    const result = await this.workerPool.scale(
-      data,
-      scalar,
-      this.poolOptions(data.length, "scale")
-    );
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel matrix multiplication
-   *
-   * @param a - First matrix as flat Float64Array (row-major)
-   * @param aRows - Number of rows in A
-   * @param aCols - Number of columns in A
-   * @param b - Second matrix as flat Float64Array (row-major)
-   * @param bCols - Number of columns in B
-   */
-  async matmul(a, aRows, aCols, b, bCols) {
-    const result = await this.workerPool.matmul(
-      a,
-      aRows,
-      aCols,
-      b,
-      bCols,
-      this.poolOptions(aRows * bCols, "matmul")
-    );
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel matrix transpose
-   */
-  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})`);
-      }
-      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);
-    }
-    const result = await this.workerPool.transpose(data, rows, cols);
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel map operation
-   */
-  async map(data, fn) {
-    const result = await this.workerPool.map(data, fn);
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel reduce operation
-   */
-  async reduce(data, fn, initial) {
-    const result = await this.workerPool.reduce(data, fn, initial);
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel filter operation
-   */
-  async filter(data, predicate) {
-    const result = await this.workerPool.filter(data, predicate);
-    return toParallelResult(result);
-  }
-  // =========================================================================
-  // Statistical Operations
-  // =========================================================================
-  /**
-   * Find min and max values in parallel
-   */
-  async minMax(data) {
-    if (!this.shouldParallelize(data.length, "minMax") && !this.shouldParallelize(data.length, "min")) {
-      let min = Infinity;
-      let max = -Infinity;
-      let minIdx = -1;
-      let maxIdx = -1;
-      for (let i = 0; i < data.length; i++) {
-        if (data[i] < min) {
-          min = data[i];
-          minIdx = i;
-        }
-        if (data[i] > max) {
-          max = data[i];
-          maxIdx = i;
-        }
-      }
-      return this.seqResult({ min, max, minIdx, maxIdx });
-    }
-    return toParallelResult(await this.workerPool.minMax(data));
-  }
-  /**
-   * Compute variance, mean, and standard deviation in parallel
-   */
-  async variance(data) {
-    if (!this.shouldParallelize(data.length, "variance")) {
-      const n = data.length;
-      const mean = n > 0 ? pairwiseSum(data) / n : 0;
-      const variance = n > 0 ? sumSquaredDeviations(data) / n : 0;
-      return this.seqResult({ mean, variance, std: Math.sqrt(variance) });
-    }
-    return toParallelResult(await this.workerPool.variance(data));
-  }
-  /**
-   * Compute norm (Euclidean length) in parallel
-   */
-  async norm(data) {
-    if (!this.shouldParallelize(data.length, "norm")) {
-      return this.seqResult(norm2(data));
-    }
-    return toParallelResult(await this.workerPool.norm(data));
-  }
-  /**
-   * Compute Euclidean distance in parallel
-   */
-  async distance(a, b) {
-    if (!this.shouldParallelize(a.length, "distance")) {
-      if (a.length !== b.length) throw new Error("distance: vectors must have the same length");
-      return this.seqResult(scaledDistance(a, b));
-    }
-    return toParallelResult(await this.workerPool.distance(a, b));
-  }
-  /**
-   * Compute histogram in parallel
-   */
-  async histogram(data, bins, min, max) {
-    if (!this.shouldParallelize(data.length, "histogram")) {
-      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 counts = new Array(bins).fill(0);
-      const width = (hi - lo) / bins || 1;
-      for (let i = 0; i < data.length; i++) {
-        let b = Math.floor((data[i] - lo) / width);
-        if (b >= bins) b = bins - 1;
-        if (b < 0) b = 0;
-        counts[b]++;
-      }
-      return this.seqResult(counts);
-    }
-    const result = await this.workerPool.histogram(data, bins, min, max);
-    return toParallelResult(result);
-  }
-  // =========================================================================
-  // Unary Operations
-  // =========================================================================
-  /**
-   * Apply unary function in parallel
-   */
-  async unary(data, fn) {
-    const result = await this.workerPool.unary(data, fn, this.poolOptions(data.length, fn));
-    return toParallelResult(result);
-  }
-  /**
-   * Apply a caller-supplied unary numeric function in parallel.
-   *
-   * @param data - Input values
-   * @param fnSource - Source of a self-contained `(x: number) => number`
-   *   expression. It must not reference free variables / closures, since it
-   *   is eval'd in an isolated worker context. Used to parallelize element-wise
-   *   math (special functions, distribution PDFs/CDFs).
-   */
-  async applyKernel(data, fnSource) {
-    const result = await this.workerPool.applyKernel(data, fnSource);
-    return toParallelResult(result);
-  }
-  /**
-   * Apply a caller-supplied binary numeric function in parallel.
-   *
-   * @param a - First operand array
-   * @param b - Second operand array (must match the length of `a`)
-   * @param fnSource - Source of a self-contained `(a: number, b: number) =>
-   *   number` expression (no free variables / closures).
-   */
-  async applyKernel2(a, b, fnSource) {
-    const result = await this.workerPool.applyKernel2(a, b, fnSource);
-    return toParallelResult(result);
-  }
-  /**
-   * Fan-out Gauss-Legendre quadrature over `workerCount` sub-intervals.
-   *
-   * Partitions `[a, b]` into `workerCount` equal sub-domains and dispatches one
-   * `integrateChunk` worker task per sub-domain.  Each task evaluates the
-   * integrand (supplied as a stringified closure) with the given GL nodes and
-   * weights and returns its partial integral.  The partial sums are aggregated
-   * on the main thread.
-   *
-   * **Closure contract:** `fnSource` must be a self-contained `(x: number) =>
-   * number` expression — no free variables referencing outer scope, because it
-   * is eval'd inside an isolated worker context.  Call-site validation (via
-   * `validateClosureSource`) should have already rejected unsafe closures before
-   * reaching this method.
-   *
-   * @param fnSource    - Stringified integrand, e.g. `"(x) => Math.sin(x)"`
-   * @param a           - Lower integration bound
-   * @param b           - Upper integration bound
-   * @param workerCount - Number of sub-intervals / worker tasks
-   * @param nodes       - GL nodes on [-1, 1]
-   * @param weights     - Corresponding GL weights
-   * @returns Sum of partial integrals = approximate value of ∫ₐᵇ f(x) dx
-   */
-  async integrateFanOut(fnSource, a, b, workerCount, nodes, weights) {
-    const h = (b - a) / workerCount;
-    const tasks = [];
-    for (let k = 0; k < workerCount; k++) {
-      const subA = a + k * h;
-      const subB = a + (k + 1) * h;
-      tasks.push(
-        this.workerPool.exec("integrateChunk", [fnSource, subA, subB, nodes, weights])
-      );
-    }
-    const partials = await Promise.all(tasks);
-    return partials.reduce((acc, v) => acc + v, 0);
-  }
-  /**
-   * Fan-out distribution batch sampling across `workerCount` workers.
-   *
-   * Partitions `n` samples into `workerCount` equal chunks (last chunk absorbs
-   * the remainder) and dispatches one `sampleChunk` task per chunk. Each chunk
-   * uses an independent seed derived from `baseSeed` via SplitMix64-style
-   * hashing:
-   *
-   *   `chunkSeed = (baseSeed ^ (chunkIdx * 0x9E3779B97F4A7C15)) >>> 0`
-   *
-   * This Fibonacci-hashing multiplier gives good avalanche: even baseSeed=0
-   * produces K distinct seeds, and adjacent chunk indices produce uncorrelated
-   * sequences. See the `sampleChunk` worker kernel for the full rationale.
-   *
-   * @param distName    - One of 'normal', 'gamma', 'beta', 'studentT', 'exponential'
-   * @param params      - Distribution parameters (order matches factory functions)
-   * @param n           - Total number of samples to generate
-   * @param baseSeed    - Base seed for reproducible output
-   * @param workerCount - Number of parallel worker tasks
-   * @returns Concatenated Float64Array of `n` samples
-   */
-  async distributionSampleFanOut(distName, params, n, baseSeed, workerCount) {
-    const SPLIT_MIX_CONST = 2654435769;
-    const baseChunkSize = Math.floor(n / workerCount);
-    const tasks = [];
-    for (let k = 0; k < workerCount; k++) {
-      const chunkCount = k < workerCount - 1 ? baseChunkSize : n - baseChunkSize * (workerCount - 1);
-      const chunkSeed = (baseSeed ^ (Math.imul(k, SPLIT_MIX_CONST) | 0)) >>> 0;
-      tasks.push(
-        this.workerPool.exec("sampleChunk", [distName, params, chunkSeed, chunkCount])
-      );
-    }
-    const buffers = await Promise.all(tasks);
-    const out = new Float64Array(n);
-    let offset = 0;
-    for (const buf of buffers) {
-      const chunk = new Float64Array(buf);
-      out.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return out;
-  }
-  /**
-   * Compute a batch of independent radix-2 FFTs in parallel.
-   *
-   * `real` and `imag` each hold `frameCount` concatenated frames of
-   * `frameLength` samples (`frameLength` must be a power of two). Each frame
-   * is FFT'd independently and the frames are distributed across workers.
-   *
-   * Used to parallelize the embarrassingly-parallel FFT batches in
-   * `spectrogram` (one FFT per windowed frame) and `fft2d` (rows then columns).
-   *
-   * @param real - Concatenated real parts (`frameCount * frameLength` values)
-   * @param imag - Concatenated imaginary parts (same layout as `real`)
-   * @param frameCount - Number of independent frames
-   * @param frameLength - Samples per frame (power of two)
-   * @param inverse - Compute the inverse FFT when true
-   */
-  async fftBatch(real, imag, frameCount, frameLength, inverse = false) {
-    const result = await this.workerPool.fftBatch(real, imag, frameCount, frameLength, inverse);
-    return toParallelResult(result);
-  }
-  /**
-   * Compute an all-pairs Euclidean distance matrix in parallel.
-   *
-   * @param points - Flattened `n * dim` coordinate array (row-major)
-   * @param n - Number of points
-   * @param dim - Coordinate dimension
-   * @returns Flat row-major `n * n` distance matrix
-   */
-  async distanceMatrix(points, n, dim) {
-    const result = await this.workerPool.distanceMatrix(points, n, dim);
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel absolute value
-   */
-  async abs(data) {
-    return this.unary(data, "abs");
-  }
-  /**
-   * Parallel square root
-   */
-  async sqrt(data) {
-    return this.unary(data, "sqrt");
-  }
-  /**
-   * Parallel exponential
-   */
-  async exp(data) {
-    return this.unary(data, "exp");
-  }
-  /**
-   * Parallel natural log
-   */
-  async log(data) {
-    return this.unary(data, "log");
-  }
-  /**
-   * Parallel sine
-   */
-  async sin(data) {
-    return this.unary(data, "sin");
-  }
-  /**
-   * Parallel cosine
-   */
-  async cos(data) {
-    return this.unary(data, "cos");
-  }
-  /**
-   * Parallel tangent
-   */
-  async tan(data) {
-    return this.unary(data, "tan");
-  }
-  /**
-   * Parallel negation
-   */
-  async negate(data) {
-    return this.unary(data, "negate");
-  }
-  /**
-   * Parallel square
-   */
-  async square(data) {
-    return this.unary(data, "square");
-  }
-  // =========================================================================
-  // Additional Matrix Operations
-  // =========================================================================
-  /**
-   * Parallel matrix-vector multiplication
-   */
-  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})`);
-      }
-      const out = new Float64Array(rows);
-      for (let i = 0; i < rows; i++) {
-        let s = 0;
-        for (let j = 0; j < cols; j++) s += matrix[i * cols + j] * vector[j];
-        out[i] = s;
-      }
-      return this.seqResult(out);
-    }
-    const result = await this.workerPool.matvec(matrix, rows, cols, vector);
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel outer product
-   */
-  async outer(a, b) {
-    if (!this.shouldParallelize(a.length * b.length, "outer")) {
-      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);
-    }
-    const result = await this.workerPool.outer(a, b);
-    return toParallelResult(result);
-  }
-  // =========================================================================
-  // Search and Sort Operations
-  // =========================================================================
-  /**
-   * Parallel find operation
-   */
-  async find(data, predicate) {
-    const result = await this.workerPool.find(data, predicate);
-    return toParallelResult(result);
-  }
-  /**
-   * Parallel sort operation
-   */
-  async sort(data, compare) {
-    const result = await this.workerPool.sort(data, compare);
-    return toParallelResult(result);
-  }
-  // =========================================================================
-  // Convenience Methods
-  // =========================================================================
-  /**
-   * Parallel addition of two arrays
-   */
-  async add(a, b) {
-    return this.elementwise(a, b, "add");
-  }
-  /**
-   * Parallel subtraction of two arrays
-   */
-  async subtract(a, b) {
-    return this.elementwise(a, b, "subtract");
-  }
-  /**
-   * Parallel element-wise multiplication
-   */
-  async multiply(a, b) {
-    return this.elementwise(a, b, "multiply");
-  }
-  /**
-   * Parallel element-wise division
-   */
-  async divide(a, b) {
-    return this.elementwise(a, b, "divide");
-  }
-  /**
-   * Parallel element-wise exponentiation.
-   *
-   * `out[i] = a[i] ** b[i]`
-   *
-   * Delegates to `applyKernel2` with the `Math.pow` kernel. The default
-   * per-op threshold for `pow` is `'never'` (overhead dominates); the
-   * sequential path is taken unless the caller overrides `thresholdByOp.pow`.
-   */
-  async pow(a, b) {
-    if (a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${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);
-    for (let i = 0; i < a.length; i++) {
-      result[i] = a[i] ** b[i];
-    }
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Parallel element-wise sign function.
-   *
-   * `out[i] = Math.sign(data[i])`  →  -1 | 0 | 1, with NaN → NaN (IEEE 754).
-   *
-   * Delegates to `applyKernel` with the `Math.sign` kernel. The default
-   * per-op threshold for `sign` is `'never'` (overhead dominates); the
-   * sequential path is taken unless the caller overrides `thresholdByOp.sign`.
-   */
-  async sign(data) {
-    if (this.shouldParallelize(data.length, "sign")) {
-      return this.applyKernel(data, "(x) => Math.sign(x)");
-    }
-    const start = performance.now();
-    const result = new Float64Array(data.length);
-    for (let i = 0; i < data.length; i++) {
-      result[i] = Math.sign(data[i]);
-    }
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * General tensor contraction (tensordot) over specified axis pairs.
-   *
-   * Contracts axis `axesA[i]` of `a` with axis `axesB[i]` of `b` for each
-   * pair index `i`. The result shape is the non-contracted axes of `a` followed
-   * by the non-contracted axes of `b` (NumPy convention).
-   *
-   * Parallelization threshold: contracted-axis volume (product of contracted
-   * dimensions) >= 8 192. When parallelized, output elements are distributed
-   * in contiguous slices across workers via the `tensordotChunk` kernel.
-   *
-   * @param a      - Flat row-major Float64Array for tensor A
-   * @param aShape - Shape of tensor A
-   * @param b      - Flat row-major Float64Array for tensor B
-   * @param bShape - Shape of tensor B
-   * @param axesA  - Axes of A to contract (same length as axesB)
-   * @param axesB  - Axes of B to contract (same length as axesA)
-   * @returns `{ data: Float64Array; shape: number[] }` — flat result + result shape
-   */
-  async tensordot(a, aShape, b, bShape, axesA, axesB) {
-    if (axesA.length !== axesB.length) {
-      throw new Error(
-        `tensordot: axesA.length (${axesA.length}) !== axesB.length (${axesB.length})`
-      );
-    }
-    const aRank = aShape.length;
-    const bRank = bShape.length;
-    const aContracted = /* @__PURE__ */ new Set();
-    const bContracted = /* @__PURE__ */ new Set();
-    for (let i = 0; i < axesA.length; i++) {
-      const ax = axesA[i];
-      const bx = axesB[i];
-      if (!Number.isInteger(ax) || ax < 0 || ax >= aRank) {
-        throw new Error(`tensordot: axesA[${i}]=${ax} is out of range for aShape (rank ${aRank})`);
-      }
-      if (!Number.isInteger(bx) || bx < 0 || bx >= bRank) {
-        throw new Error(`tensordot: axesB[${i}]=${bx} is out of range for bShape (rank ${bRank})`);
-      }
-      if (aShape[ax] !== bShape[bx]) {
-        throw new Error(
-          `tensordot: dimension mismatch on contracted axes: aShape[${ax}]=${aShape[ax]} vs bShape[${bx}]=${bShape[bx]}`
-        );
-      }
-      aContracted.add(ax);
-      bContracted.add(bx);
-    }
-    const resultShape = [];
-    for (let i = 0; i < aRank; i++) {
-      if (!aContracted.has(i)) resultShape.push(aShape[i]);
-    }
-    for (let i = 0; i < bRank; i++) {
-      if (!bContracted.has(i)) resultShape.push(bShape[i]);
-    }
-    const resultSize = resultShape.reduce((acc, d) => acc * d, 1);
-    const contractedVolume = Array.from(axesA).reduce((acc, ax) => acc * aShape[ax], 1);
-    const start = performance.now();
-    if (this.shouldParallelize(contractedVolume, "tensordot") && resultSize > 0) {
-      const chunkSize = this.config.chunkSize;
-      const chunks = [];
-      for (let i = 0; i < resultSize; i += chunkSize) {
-        chunks.push([i, Math.min(i + chunkSize, resultSize)]);
-      }
-      const aShapeArr = Array.from(aShape);
-      const bShapeArr = Array.from(bShape);
-      const axesAArr = Array.from(axesA);
-      const axesBArr = Array.from(axesB);
-      const chunkResults = await Promise.all(
-        chunks.map(
-          ([outStart, outEnd]) => this.workerPool.exec("tensordotChunk", [
-            a.buffer,
-            aShapeArr,
-            b.buffer,
-            bShapeArr,
-            axesAArr,
-            axesBArr,
-            resultShape,
-            outStart,
-            outEnd
-          ])
-        )
-      );
-      const data2 = new Float64Array(resultSize);
-      let offset = 0;
-      for (const buf of chunkResults) {
-        const chunk = new Float64Array(buf);
-        data2.set(chunk, offset);
-        offset += chunk.length;
-      }
-      return {
-        result: { data: data2, shape: resultShape },
-        duration: performance.now() - start,
-        chunks: chunks.length,
-        parallelized: true
-      };
-    }
-    const data = resultSize === 0 ? new Float64Array(0) : tensordotChunkKernel(a, aShape, b, bShape, axesA, axesB, resultShape, 0, resultSize);
-    return {
-      result: { data, shape: resultShape },
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Compute mean in parallel (uses variance internally)
-   */
-  async mean(data) {
-    const result = await this.variance(data);
-    return {
-      ...result,
-      result: result.result.mean
-    };
-  }
-  /**
-   * Compute standard deviation in parallel
-   */
-  async std(data) {
-    const result = await this.variance(data);
-    return {
-      ...result,
-      result: result.result.std
-    };
-  }
-  /**
-   * Find minimum value in parallel
-   */
-  async min(data) {
-    const result = await this.minMax(data);
-    return {
-      ...result,
-      result: result.result.min
-    };
-  }
-  /**
-   * Find maximum value in parallel
-   */
-  async max(data) {
-    const result = await this.minMax(data);
-    return {
-      ...result,
-      result: result.result.max
-    };
-  }
-  // =========================================================================
-  // Bitwise Operations (Int32Array)
-  // =========================================================================
-  //
-  // Above the elementwise threshold these dispatch to the `Int32Array`-keyed
-  // worker kernels in `@danielsimonjr/mathts-workerpool` (`bitwiseChunk`,
-  // `bitwiseScalarChunk`, `bitwiseNotChunk`). Below threshold they fall back
-  // to the pure in-process drivers in `./ops/bitwise.ts`. The fallback path
-  // uses those drivers verbatim so the algorithm lives in one place.
-  /**
-   * Element-wise bitwise AND on two `Int32Array`s.
-   */
-  async bitAnd(a, b) {
-    if (a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-    }
-    if (this.shouldParallelize(a.length, "bitAnd")) {
-      return toParallelResult(await this.workerPool.bitwiseBinary(a, b, "bitAnd"));
-    }
-    const start = performance.now();
-    const result = bitAnd(a, b);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Element-wise bitwise OR on two `Int32Array`s.
-   */
-  async bitOr(a, b) {
-    if (a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-    }
-    if (this.shouldParallelize(a.length, "bitOr")) {
-      return toParallelResult(await this.workerPool.bitwiseBinary(a, b, "bitOr"));
-    }
-    const start = performance.now();
-    const result = bitOr(a, b);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Element-wise bitwise XOR on two `Int32Array`s.
-   */
-  async bitXor(a, b) {
-    if (a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-    }
-    if (this.shouldParallelize(a.length, "bitXor")) {
-      return toParallelResult(await this.workerPool.bitwiseBinary(a, b, "bitXor"));
-    }
-    const start = performance.now();
-    const result = bitXor(a, b);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Unary bitwise NOT on an `Int32Array`.
-   */
-  async bitNot(a) {
-    if (this.shouldParallelize(a.length, "bitNot")) {
-      return toParallelResult(await this.workerPool.bitwiseNot(a));
-    }
-    const start = performance.now();
-    const result = bitNot(a);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Element-wise left shift. `b` may be a per-element `Int32Array` of
-   * shift counts or a single scalar `number` applied uniformly.
-   */
-  async leftShift(a, b) {
-    if (typeof b !== "number" && a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-    }
-    if (this.shouldParallelize(a.length, "leftShift")) {
-      const result2 = typeof b === "number" ? await this.workerPool.bitwiseScalar(a, b, "leftShift") : await this.workerPool.bitwiseBinary(a, b, "leftShift");
-      return toParallelResult(result2);
-    }
-    const start = performance.now();
-    const result = leftShift(a, b);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Element-wise arithmetic (sign-preserving) right shift.
-   */
-  async rightArithShift(a, b) {
-    if (typeof b !== "number" && a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-    }
-    if (this.shouldParallelize(a.length, "rightArithShift")) {
-      const result2 = typeof b === "number" ? await this.workerPool.bitwiseScalar(a, b, "rightArithShift") : await this.workerPool.bitwiseBinary(a, b, "rightArithShift");
-      return toParallelResult(result2);
-    }
-    const start = performance.now();
-    const result = rightArithShift(a, b);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Element-wise logical (zero-filling) right shift. Results are stored
-   * as `Int32Array`, so values ≥ 2^31 wrap into the negative range —
-   * matching `(x >>> n) | 0` JavaScript semantics.
-   */
-  async rightLogShift(a, b) {
-    if (typeof b !== "number" && a.length !== b.length) {
-      throw new Error(`Array lengths must match: ${a.length} vs ${b.length}`);
-    }
-    if (this.shouldParallelize(a.length, "rightLogShift")) {
-      const result2 = typeof b === "number" ? await this.workerPool.bitwiseScalar(a, b, "rightLogShift") : await this.workerPool.bitwiseBinary(a, b, "rightLogShift");
-      return toParallelResult(result2);
-    }
-    const start = performance.now();
-    const result = rightLogShift(a, b);
-    return {
-      result,
-      duration: performance.now() - start,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  /**
-   * Terminate the worker pool
-   */
-  async terminate(force = false) {
-    await this.workerPool.terminate(force);
-  }
-  /**
-   * Update configuration
-   */
-  updateConfig(config) {
-    this.config = {
-      ...this.config,
-      ...config,
-      thresholdByOp: mergeThresholds(this.config.thresholdByOp, config.thresholdByOp)
-    };
-    this.workerPool.updateConfig(toWorkerConfig(this.config));
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Maximum number of workers configured for this pool.
-   * Used by distribution sampling fan-out to determine chunk count.
-   */
-  get workerCount() {
-    return this.config.maxWorkers;
-  }
-  /**
-   * Get the underlying MathWorkerPool for advanced operations
-   */
-  getWorkerPool() {
-    return this.workerPool;
-  }
+	workerPool;
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_POOL_CONFIG,
+			...config,
+			thresholdByOp: mergeThresholds(DEFAULT_POOL_CONFIG.thresholdByOp, config.thresholdByOp)
+		};
+		this.workerPool = new MathWorkerPool(toWorkerConfig(this.config));
+	}
+	async initialize() {
+		await this.workerPool.initialize();
+	}
+	isReady() {
+		return this.workerPool.isReady();
+	}
+	shouldParallelize(elementCount, op) {
+		const byOp = this.config.thresholdByOp;
+		if (op !== void 0 && byOp !== void 0 && op in byOp) {
+			const raw = byOp[op];
+			if (raw !== void 0) {
+				const threshold = resolveOpThreshold(raw);
+				return this.config.enabled && elementCount >= threshold && this.workerPool.isReady();
+			}
+		}
+		return this.workerPool.shouldParallelize(elementCount);
+	}
+	seqResult(result) {
+		return {
+			result,
+			duration: 0,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	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));
+		}
+		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}`);
+		if (this.shouldParallelize(a.length, options.op)) return toParallelResult(await this.workerPool.bitwiseBinary(a, b, options.op));
+		const start = performance.now();
+		return {
+			result: options.fallback(a, b),
+			duration: performance.now() - start,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	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 (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 {
+			result: options.fallback(a, b),
+			duration: performance.now() - start,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	async exec(method, params, options) {
+		return this.workerPool.exec(method, params, options);
+	}
+	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 prod(data) {
+		if (!this.shouldParallelize(data.length, "prod")) {
+			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));
+	}
+	async dot(a, b) {
+		return this.gatedBinary(a, b, {
+			op: "dot",
+			sequential: pairwiseDot,
+			worker: (x, y) => this.workerPool.dot(x, y)
+		});
+	}
+	poolOptions(elementCount, op) {
+		return this.shouldParallelize(elementCount, op) ? { forceParallel: true } : { forceSequential: true };
+	}
+	async elementwise(a, b, op) {
+		return toParallelResult(await this.workerPool.elementwise(a, b, op, this.poolOptions(a.length, op)));
+	}
+	async scale(data, scalar) {
+		return toParallelResult(await this.workerPool.scale(data, scalar, this.poolOptions(data.length, "scale")));
+	}
+	async matmul(a, aRows, aCols, b, bCols) {
+		return toParallelResult(await this.workerPool.matmul(a, aRows, aCols, b, bCols, this.poolOptions(aRows * bCols, "matmul")));
+	}
+	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})`);
+			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));
+	}
+	async map(data, fn) {
+		return toParallelResult(await this.workerPool.map(data, fn));
+	}
+	async reduce(data, fn, initial) {
+		return toParallelResult(await this.workerPool.reduce(data, fn, initial));
+	}
+	async filter(data, predicate) {
+		return toParallelResult(await this.workerPool.filter(data, predicate));
+	}
+	async minMax(data) {
+		if (!this.shouldParallelize(data.length, "minMax") && !this.shouldParallelize(data.length, "min")) {
+			let min = Infinity;
+			let max = -Infinity;
+			let minIdx = -1;
+			let maxIdx = -1;
+			for (let i = 0; i < data.length; i++) {
+				if (data[i] < min) {
+					min = data[i];
+					minIdx = i;
+				}
+				if (data[i] > max) {
+					max = data[i];
+					maxIdx = i;
+				}
+			}
+			return this.seqResult({
+				min,
+				max,
+				minIdx,
+				maxIdx
+			});
+		}
+		return toParallelResult(await this.workerPool.minMax(data));
+	}
+	async variance(data) {
+		if (!this.shouldParallelize(data.length, "variance")) {
+			const n = data.length;
+			const mean = n > 0 ? pairwiseSum(data) / n : 0;
+			const variance = n > 0 ? sumSquaredDeviations(data) / n : 0;
+			return this.seqResult({
+				mean,
+				variance,
+				std: Math.sqrt(variance)
+			});
+		}
+		return toParallelResult(await this.workerPool.variance(data));
+	}
+	async norm(data) {
+		if (!this.shouldParallelize(data.length, "norm")) return this.seqResult(norm2(data));
+		return toParallelResult(await this.workerPool.norm(data));
+	}
+	async distance(a, b) {
+		return this.gatedBinary(a, b, {
+			op: "distance",
+			sequential: scaledDistance,
+			worker: (x, y) => this.workerPool.distance(x, y)
+		});
+	}
+	async histogram(data, bins, min, max) {
+		if (!this.shouldParallelize(data.length, "histogram")) {
+			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 counts = new Array(bins).fill(0);
+			const width = (hi - lo) / bins || 1;
+			for (let i = 0; i < data.length; i++) {
+				let b = Math.floor((data[i] - 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));
+	}
+	async unary(data, fn) {
+		return toParallelResult(await this.workerPool.unary(data, fn, this.poolOptions(data.length, fn)));
+	}
+	async applyKernel(data, fnSource) {
+		return toParallelResult(await this.workerPool.applyKernel(data, fnSource));
+	}
+	async applyKernel2(a, b, fnSource) {
+		return toParallelResult(await this.workerPool.applyKernel2(a, b, fnSource));
+	}
+	async integrateFanOut(fnSource, a, b, workerCount, nodes, weights) {
+		const h = (b - a) / workerCount;
+		const tasks = [];
+		for (let k = 0; k < workerCount; k++) {
+			const subA = a + k * h;
+			const subB = a + (k + 1) * h;
+			tasks.push(this.workerPool.exec("integrateChunk", [
+				fnSource,
+				subA,
+				subB,
+				nodes,
+				weights
+			]));
+		}
+		return (await Promise.all(tasks)).reduce((acc, v) => acc + v, 0);
+	}
+	async distributionSampleFanOut(distName, params, n, baseSeed, workerCount) {
+		const SPLIT_MIX_CONST = 2654435769;
+		const baseChunkSize = Math.floor(n / workerCount);
+		const tasks = [];
+		for (let k = 0; k < workerCount; k++) {
+			const chunkCount = k < workerCount - 1 ? baseChunkSize : n - baseChunkSize * (workerCount - 1);
+			const chunkSeed = (baseSeed ^ (Math.imul(k, SPLIT_MIX_CONST) | 0)) >>> 0;
+			tasks.push(this.workerPool.exec("sampleChunk", [
+				distName,
+				params,
+				chunkSeed,
+				chunkCount
+			]));
+		}
+		const buffers = await Promise.all(tasks);
+		const out = new Float64Array(n);
+		let offset = 0;
+		for (const buf of buffers) {
+			const chunk = new Float64Array(buf);
+			out.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return out;
+	}
+	async fftBatch(real, imag, frameCount, frameLength, inverse = false) {
+		return toParallelResult(await this.workerPool.fftBatch(real, imag, frameCount, frameLength, inverse));
+	}
+	async distanceMatrix(points, n, dim) {
+		return toParallelResult(await this.workerPool.distanceMatrix(points, n, dim));
+	}
+	async abs(data) {
+		return this.unary(data, "abs");
+	}
+	async sqrt(data) {
+		return this.unary(data, "sqrt");
+	}
+	async exp(data) {
+		return this.unary(data, "exp");
+	}
+	async log(data) {
+		return this.unary(data, "log");
+	}
+	async sin(data) {
+		return this.unary(data, "sin");
+	}
+	async cos(data) {
+		return this.unary(data, "cos");
+	}
+	async tan(data) {
+		return this.unary(data, "tan");
+	}
+	async negate(data) {
+		return this.unary(data, "negate");
+	}
+	async square(data) {
+		return this.unary(data, "square");
+	}
+	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})`);
+			const out = new Float64Array(rows);
+			for (let i = 0; i < rows; i++) {
+				let s = 0;
+				for (let j = 0; j < cols; j++) s += matrix[i * cols + j] * vector[j];
+				out[i] = s;
+			}
+			return this.seqResult(out);
+		}
+		return toParallelResult(await this.workerPool.matvec(matrix, rows, cols, vector));
+	}
+	async outer(a, b) {
+		if (!this.shouldParallelize(a.length * b.length, "outer")) {
+			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));
+	}
+	async find(data, predicate) {
+		return toParallelResult(await this.workerPool.find(data, predicate));
+	}
+	async sort(data, compare) {
+		return toParallelResult(await this.workerPool.sort(data, compare));
+	}
+	async add(a, b) {
+		return this.elementwise(a, b, "add");
+	}
+	async subtract(a, b) {
+		return this.elementwise(a, b, "subtract");
+	}
+	async multiply(a, b) {
+		return this.elementwise(a, b, "multiply");
+	}
+	async divide(a, b) {
+		return this.elementwise(a, b, "divide");
+	}
+	async pow(a, b) {
+		if (a.length !== b.length) throw new Error(`Array lengths must match: ${a.length} vs ${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);
+		for (let i = 0; i < a.length; i++) result[i] = a[i] ** b[i];
+		return {
+			result,
+			duration: performance.now() - start,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	async sign(data) {
+		if (this.shouldParallelize(data.length, "sign")) return this.applyKernel(data, "(x) => Math.sign(x)");
+		const start = performance.now();
+		const result = new Float64Array(data.length);
+		for (let i = 0; i < data.length; i++) result[i] = Math.sign(data[i]);
+		return {
+			result,
+			duration: performance.now() - start,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	async tensordot(a, aShape, b, bShape, axesA, axesB) {
+		if (axesA.length !== axesB.length) throw new Error(`tensordot: axesA.length (${axesA.length}) !== axesB.length (${axesB.length})`);
+		const aRank = aShape.length;
+		const bRank = bShape.length;
+		const aContracted = /* @__PURE__ */ new Set();
+		const bContracted = /* @__PURE__ */ new Set();
+		for (let i = 0; i < axesA.length; i++) {
+			const ax = axesA[i];
+			const bx = axesB[i];
+			if (!Number.isInteger(ax) || ax < 0 || ax >= aRank) throw new Error(`tensordot: axesA[${i}]=${ax} is out of range for aShape (rank ${aRank})`);
+			if (!Number.isInteger(bx) || bx < 0 || bx >= bRank) throw new Error(`tensordot: axesB[${i}]=${bx} is out of range for bShape (rank ${bRank})`);
+			if (aShape[ax] !== bShape[bx]) throw new Error(`tensordot: dimension mismatch on contracted axes: aShape[${ax}]=${aShape[ax]} vs bShape[${bx}]=${bShape[bx]}`);
+			aContracted.add(ax);
+			bContracted.add(bx);
+		}
+		const resultShape = [];
+		for (let i = 0; i < aRank; i++) if (!aContracted.has(i)) resultShape.push(aShape[i]);
+		for (let i = 0; i < bRank; i++) if (!bContracted.has(i)) resultShape.push(bShape[i]);
+		const resultSize = resultShape.reduce((acc, d) => acc * d, 1);
+		const contractedVolume = Array.from(axesA).reduce((acc, ax) => acc * aShape[ax], 1);
+		const start = performance.now();
+		if (this.shouldParallelize(contractedVolume, "tensordot") && resultSize > 0) {
+			const chunkSize = this.config.chunkSize;
+			const chunks = [];
+			for (let i = 0; i < resultSize; i += chunkSize) chunks.push([i, Math.min(i + chunkSize, resultSize)]);
+			const aShapeArr = Array.from(aShape);
+			const bShapeArr = Array.from(bShape);
+			const axesAArr = Array.from(axesA);
+			const axesBArr = Array.from(axesB);
+			const chunkResults = await Promise.all(chunks.map(([outStart, outEnd]) => this.workerPool.exec("tensordotChunk", [
+				a.buffer,
+				aShapeArr,
+				b.buffer,
+				bShapeArr,
+				axesAArr,
+				axesBArr,
+				resultShape,
+				outStart,
+				outEnd
+			])));
+			const data = new Float64Array(resultSize);
+			let offset = 0;
+			for (const buf of chunkResults) {
+				const chunk = new Float64Array(buf);
+				data.set(chunk, offset);
+				offset += chunk.length;
+			}
+			return {
+				result: {
+					data,
+					shape: resultShape
+				},
+				duration: performance.now() - start,
+				chunks: chunks.length,
+				parallelized: true
+			};
+		}
+		return {
+			result: {
+				data: resultSize === 0 ? /* @__PURE__ */ new Float64Array(0) : tensordotRange(a, aShape, b, bShape, axesA, axesB, resultShape, 0, resultSize),
+				shape: resultShape
+			},
+			duration: performance.now() - start,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	async mean(data) {
+		const result = await this.variance(data);
+		return {
+			...result,
+			result: result.result.mean
+		};
+	}
+	async std(data) {
+		const result = await this.variance(data);
+		return {
+			...result,
+			result: result.result.std
+		};
+	}
+	async min(data) {
+		const result = await this.minMax(data);
+		return {
+			...result,
+			result: result.result.min
+		};
+	}
+	async max(data) {
+		const result = await this.minMax(data);
+		return {
+			...result,
+			result: result.result.max
+		};
+	}
+	async bitAnd(a, b) {
+		return this.bitwiseBinary(a, b, {
+			op: "bitAnd",
+			fallback: bitAnd
+		});
+	}
+	async bitOr(a, b) {
+		return this.bitwiseBinary(a, b, {
+			op: "bitOr",
+			fallback: bitOr
+		});
+	}
+	async bitXor(a, b) {
+		return this.bitwiseBinary(a, b, {
+			op: "bitXor",
+			fallback: bitXor
+		});
+	}
+	async bitNot(a) {
+		if (this.shouldParallelize(a.length, "bitNot")) return toParallelResult(await this.workerPool.bitwiseNot(a));
+		const start = performance.now();
+		return {
+			result: bitNot(a),
+			duration: performance.now() - start,
+			chunks: 1,
+			parallelized: false
+		};
+	}
+	async leftShift(a, b) {
+		return this.bitwiseShift(a, b, {
+			op: "leftShift",
+			fallback: leftShift
+		});
+	}
+	async rightArithShift(a, b) {
+		return this.bitwiseShift(a, b, {
+			op: "rightArithShift",
+			fallback: rightArithShift
+		});
+	}
+	async rightLogShift(a, b) {
+		return this.bitwiseShift(a, b, {
+			op: "rightLogShift",
+			fallback: rightLogShift
+		});
+	}
+	async terminate(force = false) {
+		await this.workerPool.terminate(force);
+	}
+	updateConfig(config) {
+		this.config = {
+			...this.config,
+			...config,
+			thresholdByOp: mergeThresholds(this.config.thresholdByOp, config.thresholdByOp)
+		};
+		this.workerPool.updateConfig(toWorkerConfig(this.config));
+	}
+	getConfig() {
+		return { ...this.config };
+	}
+	get workerCount() {
+		return this.config.maxWorkers;
+	}
+	getWorkerPool() {
+		return this.workerPool;
+	}
+};
+const computePool = new ComputePool();
+//#endregion
+//#region src/WorkerPool.ts
+var WorkerPool = class {
+	workers = [];
+	availableWorkers = [];
+	taskQueue = [];
+	activeTasks = /* @__PURE__ */ new Map();
+	maxWorkers;
+	workerScript;
+	isNode;
+	terminated = false;
+	constructor(workerScript, maxWorkers) {
+		this.workerScript = workerScript;
+		this.maxWorkers = maxWorkers || this.getOptimalWorkerCount();
+		this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+		this.initialize();
+	}
+	getOptimalWorkerCount() {
+		if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) return Math.max(2, navigator.hardwareConcurrency - 1);
+		return 4;
+	}
+	async initialize() {
+		for (let i = 0; i < this.maxWorkers; i++) {
+			const worker = await this.createWorker();
+			if (this.terminated) {
+				worker.terminate();
+				return;
+			}
+			this.workers.push(worker);
+			this.availableWorkers.push(worker);
+			this.processQueue();
+		}
+	}
+	async createWorker() {
+		let worker;
+		if (this.isNode) {
+			const { Worker: NodeWorker } = await import("worker_threads");
+			const nodeWorker = new NodeWorker(this.workerScript.startsWith("file://") ? new URL(this.workerScript) : this.workerScript);
+			nodeWorker.on("message", (data) => {
+				this.handleWorkerMessage(worker, data);
+			});
+			nodeWorker.on("error", (error) => {
+				this.handleWorkerError(worker, { message: error.message });
+			});
+			worker = nodeWorker;
+		} else {
+			worker = new Worker(this.workerScript, { type: "module" });
+			worker.onmessage = (event) => {
+				this.handleWorkerMessage(worker, event.data);
+			};
+			worker.onerror = (error) => {
+				this.handleWorkerError(worker, error);
+			};
+		}
+		return worker;
+	}
+	handleWorkerMessage(worker, message) {
+		const task = this.activeTasks.get(message.id);
+		if (!task) return;
+		this.activeTasks.delete(message.id);
+		if (task.timeoutHandle) {
+			clearTimeout(task.timeoutHandle);
+			task.timeoutHandle = void 0;
+		}
+		if (message.type === "result") task.resolve(message.data);
+		else if (message.type === "error") task.reject(new Error(message.error || "Worker error"));
+		this.availableWorkers.push(worker);
+		this.processQueue();
+	}
+	handleWorkerError(worker, error) {
+		console.error("Worker error:", error);
+		for (const [id, task] of this.activeTasks) if (this.workers.includes(worker)) {
+			this.activeTasks.delete(id);
+			this.clearTaskTimer(task);
+			task.reject(/* @__PURE__ */ new Error(`Worker error: ${error.message}`));
+		}
+	}
+	processQueue() {
+		while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
+			const task = this.taskQueue.shift();
+			const worker = this.availableWorkers.shift();
+			this.executeTask(worker, task);
+		}
+	}
+	executeTask(worker, task) {
+		this.activeTasks.set(task.id, task);
+		task.worker = worker;
+		const message = {
+			id: task.id,
+			type: "task",
+			data: task.data
+		};
+		if (task.transferables && task.transferables.length > 0) worker.postMessage(message, task.transferables);
+		else worker.postMessage(message);
+	}
+	async handleTaskTimeout(task, timeoutMs) {
+		const queuedAt = this.taskQueue.indexOf(task);
+		if (queuedAt >= 0) {
+			this.taskQueue.splice(queuedAt, 1);
+			task.reject(/* @__PURE__ */ new Error(`Worker task timed out after ${timeoutMs}ms`));
+			return;
+		}
+		if (!this.activeTasks.has(task.id)) return;
+		this.activeTasks.delete(task.id);
+		const dead = task.worker;
+		if (dead) {
+			try {
+				dead.terminate();
+			} catch {}
+			this.workers = this.workers.filter((w) => w !== dead);
+			this.availableWorkers = this.availableWorkers.filter((w) => w !== dead);
+			try {
+				const replacement = await this.createWorker();
+				if (this.terminated) {
+					replacement.terminate();
+					task.reject(/* @__PURE__ */ new Error(`Worker task timed out after ${timeoutMs}ms`));
+					return;
+				}
+				this.workers.push(replacement);
+				this.availableWorkers.push(replacement);
+				this.processQueue();
+			} catch (err) {
+				console.error("WorkerPool: failed to spawn replacement worker:", err);
+			}
+		}
+		task.reject(/* @__PURE__ */ new Error(`Worker task timed out after ${timeoutMs}ms`));
+	}
+	async execute(data, transferables, timeoutMs) {
+		return new Promise((resolve, reject) => {
+			if (this.terminated) {
+				reject(/* @__PURE__ */ new Error("WorkerPool terminated"));
+				return;
+			}
+			const task = {
+				id: this.generateTaskId(),
+				data,
+				resolve: (value) => resolve(value),
+				reject,
+				transferables
+			};
+			if (typeof timeoutMs === "number" && timeoutMs > 0) task.timeoutHandle = setTimeout(() => {
+				this.handleTaskTimeout(task, timeoutMs);
+			}, timeoutMs);
+			if (this.availableWorkers.length > 0) {
+				const worker = this.availableWorkers.shift();
+				this.executeTask(worker, task);
+			} else this.taskQueue.push(task);
+		});
+	}
+	generateTaskId() {
+		return `task_${Date.now()}_${globalThis.crypto.randomUUID()}`;
+	}
+	async terminate() {
+		this.terminated = true;
+		for (const task of this.taskQueue) {
+			this.clearTaskTimer(task);
+			task.reject(/* @__PURE__ */ new Error("WorkerPool terminated"));
+		}
+		this.taskQueue = [];
+		for (const task of this.activeTasks.values()) {
+			this.clearTaskTimer(task);
+			task.reject(/* @__PURE__ */ new Error("WorkerPool terminated"));
+		}
+		this.activeTasks.clear();
+		for (const worker of this.workers) worker.terminate();
+		this.workers = [];
+		this.availableWorkers = [];
+	}
+	clearTaskTimer(task) {
+		if (task.timeoutHandle !== void 0) {
+			clearTimeout(task.timeoutHandle);
+			task.timeoutHandle = void 0;
+		}
+	}
+	get activeTaskCount() {
+		return this.activeTasks.size;
+	}
+	get queuedTaskCount() {
+		return this.taskQueue.length;
+	}
+	get workerCount() {
+		return this.workers.length;
+	}
 };
-var computePool = new ComputePool();
-
-// src/operations/matmul.ts
+//#endregion
+//#region src/operations/matmul.ts
 async function parallelMatmul(a, aRows, aCols, b, bCols, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.matmul(a, aRows, aCols, b, bCols);
+	return (options.pool ?? computePool).matmul(a, aRows, aCols, b, bCols);
 }
 async function parallelMatvec(matrix, rows, cols, vector, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.matvec(matrix, rows, cols, vector);
+	return (options.pool ?? computePool).matvec(matrix, rows, cols, vector);
 }
 async function parallelTranspose(data, rows, cols, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.transpose(data, rows, cols);
+	return (options.pool ?? computePool).transpose(data, rows, cols);
 }
 async function parallelOuter(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.outer(a, b);
+	return (options.pool ?? computePool).outer(a, b);
 }
 async function parallelDot(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.dot(a, b);
+	return (options.pool ?? computePool).dot(a, b);
 }
-
-// src/operations/elementwise.ts
+//#endregion
+//#region src/operations/elementwise.ts
 async function parallelAdd(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.add(a, b);
+	return (options.pool ?? computePool).add(a, b);
 }
 async function parallelSubtract(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.subtract(a, b);
+	return (options.pool ?? computePool).subtract(a, b);
 }
 async function parallelMultiply(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.multiply(a, b);
+	return (options.pool ?? computePool).multiply(a, b);
 }
 async function parallelDivide(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.divide(a, b);
+	return (options.pool ?? computePool).divide(a, b);
 }
 async function parallelScale(data, scalar, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.scale(data, scalar);
+	return (options.pool ?? computePool).scale(data, scalar);
 }
 async function parallelAbs(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.abs(data);
+	return (options.pool ?? computePool).abs(data);
 }
 async function parallelNegate(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.negate(data);
+	return (options.pool ?? computePool).negate(data);
 }
 async function parallelSquare(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.square(data);
+	return (options.pool ?? computePool).square(data);
 }
 async function parallelSqrt(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.sqrt(data);
+	return (options.pool ?? computePool).sqrt(data);
 }
 async function parallelExp(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.exp(data);
+	return (options.pool ?? computePool).exp(data);
 }
 async function parallelLog(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.log(data);
+	return (options.pool ?? computePool).log(data);
 }
 async function parallelSin(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.sin(data);
+	return (options.pool ?? computePool).sin(data);
 }
 async function parallelCos(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.cos(data);
+	return (options.pool ?? computePool).cos(data);
 }
 async function parallelTan(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.tan(data);
+	return (options.pool ?? computePool).tan(data);
 }
 async function parallelElementwise(a, b, op, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.elementwise(a, b, op);
+	return (options.pool ?? computePool).elementwise(a, b, op);
 }
 async function parallelUnary(data, fn, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.unary(data, fn);
+	return (options.pool ?? computePool).unary(data, fn);
 }
-
-// src/operations/reduce.ts
+//#endregion
+//#region src/operations/reduce.ts
 async function parallelSum(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.sum(data);
+	return (options.pool ?? computePool).sum(data);
 }
 async function parallelMean(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.mean(data);
+	return (options.pool ?? computePool).mean(data);
 }
 async function parallelMin(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.min(data);
+	return (options.pool ?? computePool).min(data);
 }
 async function parallelMax(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.max(data);
+	return (options.pool ?? computePool).max(data);
 }
 async function parallelMinMax(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.minMax(data);
+	return (options.pool ?? computePool).minMax(data);
 }
 async function parallelVariance(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.variance(data);
+	return (options.pool ?? computePool).variance(data);
 }
 async function parallelStd(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.std(data);
+	return (options.pool ?? computePool).std(data);
 }
 async function parallelNorm(data, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.norm(data);
+	return (options.pool ?? computePool).norm(data);
 }
 async function parallelDistance(a, b, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.distance(a, b);
+	return (options.pool ?? computePool).distance(a, b);
 }
 async function parallelHistogram(data, bins, min, max, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.histogram(data, bins, min, max);
+	return (options.pool ?? computePool).histogram(data, bins, min, max);
 }
 async function parallelReduce(data, fn, initial, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.reduce(data, fn, initial);
+	return (options.pool ?? computePool).reduce(data, fn, initial);
 }
-
-// src/operations/map.ts
+//#endregion
+//#region src/operations/map.ts
 async function parallelMap(data, fn, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.map(data, fn);
+	return (options.pool ?? computePool).map(data, fn);
 }
 async function parallelFilter(data, predicate, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.filter(data, predicate);
+	return (options.pool ?? computePool).filter(data, predicate);
 }
 async function parallelFind(data, predicate, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.find(data, predicate);
+	return (options.pool ?? computePool).find(data, predicate);
 }
 async function parallelSort(data, compare, options = {}) {
-  const pool = options.pool ?? computePool;
-  return pool.sort(data, compare);
+	return (options.pool ?? computePool).sort(data, compare);
 }
 async function parallelForEach(data, fn, options = {}) {
-  const pool = options.pool ?? computePool;
-  const result = await pool.map(data, (item) => {
-    fn(item);
-    return void 0;
-  });
-  return {
-    ...result,
-    result: result.result
-  };
+	const result = await (options.pool ?? computePool).map(data, (item) => {
+		fn(item);
+	});
+	return {
+		...result,
+		result: result.result
+	};
 }
 async function parallelSome(data, predicate, options = {}) {
-  const pool = options.pool ?? computePool;
-  const findResult = await pool.find(data, predicate);
-  return {
-    ...findResult,
-    result: findResult.result.found
-  };
+	const findResult = await (options.pool ?? computePool).find(data, predicate);
+	return {
+		...findResult,
+		result: findResult.result.found
+	};
 }
 async function parallelEvery(data, predicate, options = {}) {
-  const pool = options.pool ?? computePool;
-  const findResult = await pool.find(data, (item) => !predicate(item));
-  return {
-    ...findResult,
-    result: !findResult.result.found
-  };
+	const findResult = await (options.pool ?? computePool).find(data, (item) => !predicate(item));
+	return {
+		...findResult,
+		result: !findResult.result.found
+	};
 }
 async function parallelCount(data, predicate, options = {}) {
-  const pool = options.pool ?? computePool;
-  if (!predicate) {
-    return {
-      result: data.length,
-      duration: 0,
-      chunks: 1,
-      parallelized: false
-    };
-  }
-  const filterResult = await pool.filter(data, predicate);
-  return {
-    ...filterResult,
-    result: filterResult.result.length
-  };
-}
-
-// src/strategies/threshold.ts
+	const pool = options.pool ?? computePool;
+	if (!predicate) return {
+		result: data.length,
+		duration: 0,
+		chunks: 1,
+		parallelized: false
+	};
+	const filterResult = await pool.filter(data, predicate);
+	return {
+		...filterResult,
+		result: filterResult.result.length
+	};
+}
+//#endregion
+//#region src/strategies/threshold.ts
 function opThreshold(op, fallback) {
-  const raw = DEFAULT_THRESHOLD_BY_OP[op];
-  return typeof raw === "number" ? raw : fallback;
-}
-var DEFAULT_THRESHOLDS = {
-  matmul: opThreshold("matmul", 4096),
-  // canonical: DEFAULT_THRESHOLD_BY_OP.matmul
-  elementwise: 5e4,
-  // ~50K elements (memory-bound; ComputePool ops mostly 'never')
-  reduce: 1e5,
-  // ~100K elements
-  map: 1e4,
-  // ~10K elements
-  sort: 5e3,
-  // ~5K elements
-  decomposition: 2500,
-  // ~50x50 matrix (no single canonical op; heuristic)
-  general: 5e4
-  // Default ~50K
+	const raw = DEFAULT_THRESHOLD_BY_OP[op];
+	return typeof raw === "number" ? raw : fallback;
+}
+const DEFAULT_THRESHOLDS = {
+	matmul: opThreshold("matmul", 4096),
+	elementwise: 5e4,
+	reduce: 1e5,
+	map: 1e4,
+	sort: 5e3,
+	decomposition: 2500,
+	general: 5e4
 };
 var ThresholdDispatcher = class {
-  thresholds;
-  pool;
-  constructor(thresholds = {}, pool) {
-    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
-    this.pool = pool ?? computePool;
-  }
-  /**
-   * Get threshold for a specific operation category
-   */
-  getThreshold(category) {
-    return this.thresholds[category];
-  }
-  /**
-   * Update thresholds
-   */
-  setThresholds(thresholds) {
-    this.thresholds = { ...this.thresholds, ...thresholds };
-  }
-  /**
-   * Get current threshold configuration
-   */
-  getThresholds() {
-    return { ...this.thresholds };
-  }
-  /**
-   * Determine execution mode based on operation and data size
-   */
-  dispatch(elementCount, category = "general") {
-    const threshold = this.thresholds[category];
-    const poolReady = this.pool.isReady();
-    if (!poolReady) {
-      return {
-        mode: "sequential",
-        reason: "Worker pool not initialized",
-        threshold,
-        elementCount
-      };
-    }
-    const config = this.pool.getConfig();
-    if (!config.enabled) {
-      return {
-        mode: "sequential",
-        reason: "Parallel processing disabled",
-        threshold,
-        elementCount
-      };
-    }
-    if (elementCount < threshold) {
-      return {
-        mode: "sequential",
-        reason: `Element count (${elementCount}) below threshold (${threshold})`,
-        threshold,
-        elementCount
-      };
-    }
-    return {
-      mode: "parallel",
-      reason: `Element count (${elementCount}) exceeds threshold (${threshold})`,
-      threshold,
-      elementCount
-    };
-  }
-  /**
-   * Simple boolean check for parallel execution
-   */
-  shouldParallelize(elementCount, category = "general") {
-    return this.dispatch(elementCount, category).mode === "parallel";
-  }
-  /**
-   * Calculate optimal chunk count based on operation and data size
-   */
-  calculateChunks(elementCount, category = "general") {
-    const dispatch2 = this.dispatch(elementCount, category);
-    if (dispatch2.mode === "sequential") {
-      return 1;
-    }
-    const stats = this.pool.stats();
-    const workerCount = Math.max(1, stats.totalWorkers);
-    switch (category) {
-      case "matmul":
-      case "decomposition":
-        return workerCount;
-      case "elementwise":
-      case "map":
-        return Math.min(workerCount * 2, Math.ceil(elementCount / 1e4));
-      case "reduce":
-        return Math.min(workerCount, Math.ceil(elementCount / 5e4));
-      case "sort":
-        return Math.min(workerCount, 8);
-      default:
-        return workerCount;
-    }
-  }
+	thresholds;
+	pool;
+	constructor(thresholds = {}, pool) {
+		this.thresholds = {
+			...DEFAULT_THRESHOLDS,
+			...thresholds
+		};
+		this.pool = pool ?? computePool;
+	}
+	getThreshold(category) {
+		return this.thresholds[category];
+	}
+	setThresholds(thresholds) {
+		this.thresholds = {
+			...this.thresholds,
+			...thresholds
+		};
+	}
+	getThresholds() {
+		return { ...this.thresholds };
+	}
+	dispatch(elementCount, category = "general") {
+		const threshold = this.thresholds[category];
+		if (!this.pool.isReady()) return {
+			mode: "sequential",
+			reason: "Worker pool not initialized",
+			threshold,
+			elementCount
+		};
+		if (!this.pool.getConfig().enabled) return {
+			mode: "sequential",
+			reason: "Parallel processing disabled",
+			threshold,
+			elementCount
+		};
+		if (elementCount < threshold) return {
+			mode: "sequential",
+			reason: `Element count (${elementCount}) below threshold (${threshold})`,
+			threshold,
+			elementCount
+		};
+		return {
+			mode: "parallel",
+			reason: `Element count (${elementCount}) exceeds threshold (${threshold})`,
+			threshold,
+			elementCount
+		};
+	}
+	shouldParallelize(elementCount, category = "general") {
+		return this.dispatch(elementCount, category).mode === "parallel";
+	}
+	calculateChunks(elementCount, category = "general") {
+		if (this.dispatch(elementCount, category).mode === "sequential") return 1;
+		const stats = this.pool.stats();
+		const workerCount = Math.max(1, stats.totalWorkers);
+		switch (category) {
+			case "matmul":
+			case "decomposition": return workerCount;
+			case "elementwise":
+			case "map": return Math.min(workerCount * 2, Math.ceil(elementCount / 1e4));
+			case "reduce": return Math.min(workerCount, Math.ceil(elementCount / 5e4));
+			case "sort": return Math.min(workerCount, 8);
+			default: return workerCount;
+		}
+	}
 };
-var thresholdDispatcher = new ThresholdDispatcher();
-function shouldParallelize2(elementCount, category = "general") {
-  return thresholdDispatcher.shouldParallelize(elementCount, category);
+const thresholdDispatcher = new ThresholdDispatcher();
+function shouldParallelize$1(elementCount, category = "general") {
+	return thresholdDispatcher.shouldParallelize(elementCount, category);
 }
 function dispatch(elementCount, category = "general") {
-  return thresholdDispatcher.dispatch(elementCount, category);
+	return thresholdDispatcher.dispatch(elementCount, category);
 }
 function calculateChunks(elementCount, category = "general") {
-  return thresholdDispatcher.calculateChunks(elementCount, category);
-}
-export {
-  ComputePool,
-  DEFAULT_POOL_CONFIG,
-  DEFAULT_THRESHOLDS,
-  DEFAULT_THRESHOLD_BY_OP,
-  ThresholdDispatcher,
-  Transfer,
-  bitAnd,
-  bitNot,
-  bitOr,
-  bitXor,
-  calculateChunks,
-  calculateOptimalChunks,
-  chunkArray,
-  chunkFloat64Array,
-  computePool,
-  dispatch,
-  leftShift,
-  mergeArrayChunks,
-  mergeFloat64Chunks,
-  parallelAbs,
-  parallelAdd,
-  parallelCos,
-  parallelCount,
-  parallelDistance,
-  parallelDivide,
-  parallelDot,
-  parallelElementwise,
-  parallelEvery,
-  parallelExp,
-  parallelFilter,
-  parallelFind,
-  parallelForEach,
-  parallelHistogram,
-  parallelLog,
-  parallelMap,
-  parallelMatmul,
-  parallelMatvec,
-  parallelMax,
-  parallelMean,
-  parallelMin,
-  parallelMinMax,
-  parallelMultiply,
-  parallelNegate,
-  parallelNorm,
-  parallelOuter,
-  parallelReduce,
-  parallelScale,
-  parallelSin,
-  parallelSome,
-  parallelSort,
-  parallelSqrt,
-  parallelSquare,
-  parallelStd,
-  parallelSubtract,
-  parallelSum,
-  parallelTan,
-  parallelTranspose,
-  parallelUnary,
-  parallelVariance,
-  partition2D,
-  partitionRange,
-  resolveOpThreshold,
-  rightArithShift,
-  rightLogShift,
-  shouldParallelize as shouldChunkParallelize,
-  shouldParallelize2 as shouldParallelize,
-  thresholdDispatcher
-};
+	return thresholdDispatcher.calculateChunks(elementCount, category);
+}
+//#endregion
+export { ComputePool, DEFAULT_POOL_CONFIG, DEFAULT_THRESHOLDS, DEFAULT_THRESHOLD_BY_OP, ThresholdDispatcher, Transfer, WorkerPool, bitAnd, bitNot, bitOr, bitXor, calculateChunks, calculateOptimalChunks, chunkArray, chunkFloat64Array, computePool, dispatch, leftShift, mergeArrayChunks, mergeFloat64Chunks, parallelAbs, parallelAdd, parallelCos, parallelCount, parallelDistance, parallelDivide, parallelDot, parallelElementwise, parallelEvery, parallelExp, parallelFilter, parallelFind, parallelForEach, parallelHistogram, parallelLog, parallelMap, parallelMatmul, parallelMatvec, parallelMax, parallelMean, parallelMin, parallelMinMax, parallelMultiply, parallelNegate, parallelNorm, parallelOuter, parallelReduce, parallelScale, parallelSin, parallelSome, parallelSort, parallelSqrt, parallelSquare, parallelStd, parallelSubtract, parallelSum, parallelTan, parallelTranspose, parallelUnary, parallelVariance, partition2D, partitionRange, resolveOpThreshold, rightArithShift, rightLogShift, shouldParallelize as shouldChunkParallelize, shouldParallelize$1 as shouldParallelize, thresholdDispatcher };