@shelby-protocol/sdk 0.3.1 → 0.4.0

package/dist/node/parallel/commitment_worker.mjs

@@ -1,64 +1,6 @@
 // src/node/parallel/commitment_worker.ts
 import { parentPort } from "worker_threads";
-import { Hex as Hex3 } from "@aptos-labs/ts-sdk";
-
-// src/core/commitments.ts
 import { Hex as Hex2 } from "@aptos-labs/ts-sdk";
-import { z } from "zod";
-
-// src/core/erasure/constants.ts
-var ERASURE_CODE_PARAMS = {
-  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
-    // total chunks (data + parity)
-    erasure_n: 16,
-    // data chunks
-    erasure_k: 10,
-    // helper nodes
-    erasure_d: 13,
-    // enum index
-    enumIndex: 0
-  },
-  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
-    // total chunks (data + parity)
-    erasure_n: 4,
-    // data chunks
-    erasure_k: 2,
-    // helper nodes
-    erasure_d: 3,
-    // enum index
-    enumIndex: 1
-  }
-};
-var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_n;
-var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_k;
-var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_d;
-var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
-
-// src/core/chunk.ts
-var CHUNK_SIZE_PARAMS = {
-  ["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */]: {
-    // 1MiB
-    chunkSizeBytes: 1 * 1024 * 1024,
-    // 10MiB
-    chunksetSizeBytes: 10 * 1024 * 1024
-  },
-  ["ChunkSet2MiB_Chunk1MiB" /* ChunkSet2MiB_Chunk1MiB */]: {
-    // 1MiB
-    chunkSizeBytes: 1 * 1024 * 1024,
-    // 2MiB
-    chunksetSizeBytes: 2 * 1024 * 1024
-  }
-};
-var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunkSizeBytes;
-var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunksetSizeBytes;
-var ERASURE_CODE_AND_CHUNK_MAPPING = {
-  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
-    ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
-  },
-  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
-    ...CHUNK_SIZE_PARAMS.ChunkSet2MiB_Chunk1MiB
-  }
-};
 
 // src/core/utils.ts
 import {
@@ -76,211 +18,56 @@ function zeroPadBytes(buffer, desiredLength) {
   paddedBuffer.set(buffer);
   return paddedBuffer;
 }
-async function concatHashes(parts) {
-  const chunks = parts.map((part) => Hex.fromHexInput(part).toUint8Array());
-  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
-  const combined = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    combined.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return Hex.fromHexInput(
-    new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
-  );
-}
 
-// src/core/commitments.ts
-var ChunksetCommitmentSchema = z.object({
-  // Chunkset root (vector commitment of child chunks)
-  chunkset_root: z.string(),
-  // the size is known statically from the current configuration
-  chunk_commitments: z.array(z.string())
-}).refine(
-  (data) => {
-    return data.chunk_commitments.length === DEFAULT_ERASURE_K + DEFAULT_ERASURE_M;
-  },
-  {
-    message: `Chunkset must have exactly ${DEFAULT_ERASURE_K + DEFAULT_ERASURE_M} chunks (ERASURE_K + ERASURE_M = ${DEFAULT_ERASURE_K} + ${DEFAULT_ERASURE_M})`,
-    path: ["chunk_commitments"]
-  }
-);
-function expectedTotalChunksets(rawSize, chunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES) {
-  if (chunksetSize <= 0) {
-    throw new Error("chunksetSize must be positive");
-  }
-  if (rawSize === 0) return 1;
-  return Math.ceil(rawSize / chunksetSize);
-}
-var BlobCommitmentsSchema = z.object({
-  schema_version: z.string(),
-  raw_data_size: z.number(),
-  // FIXME I am not sure about this being here, or if it should be somewhere else
-  blob_merkle_root: z.string(),
-  chunkset_commitments: z.array(ChunksetCommitmentSchema)
-}).refine(
-  (data) => {
-    return expectedTotalChunksets(data.raw_data_size) === data.chunkset_commitments.length;
-  },
-  {
-    message: "Total chunkset count mismatches with raw data size",
-    // FIXME put more details in here
-    path: ["chunkset_commitments"]
-  }
-);
-async function generateMerkleRoot(leafHashes) {
-  if (!leafHashes.length) {
-    throw new Error(
-      "An empty array cannot be used to construct a Merkle tree."
-    );
-  }
-  const zeroArray = new Uint8Array(leafHashes[0].toUint8Array().length);
-  const zeroBytes = Hex2.fromHexInput(zeroArray);
-  let currentLeaves = leafHashes;
-  while (currentLeaves.length > 1) {
-    if (currentLeaves.length % 2 !== 0) {
-      currentLeaves.push(zeroBytes);
-    }
-    const nextLeaves = [];
-    for (let i = 0; i < currentLeaves.length; i += 2) {
-      nextLeaves.push(
-        await concatHashes([
-          currentLeaves[i].toUint8Array(),
-          currentLeaves[i + 1].toUint8Array()
-        ])
-      );
-    }
-    currentLeaves = nextLeaves;
+// src/node/parallel/commitment_worker.ts
+var ffiAvailable = null;
+async function tryCreateFFIEncoder(opts) {
+  if (ffiAvailable === false) return null;
+  try {
+    const ffiPath = "@shelby-protocol/clay-codes-ffi";
+    const { createEncoder: createFFIEncoder } = await import(ffiPath);
+    const encoder = await createFFIEncoder(opts);
+    ffiAvailable = true;
+    return encoder;
+  } catch {
+    ffiAvailable = false;
+    return null;
   }
-  return currentLeaves[0];
 }
-
-// src/core/erasure/clay-codes.ts
-import {
-  createDecoder,
-  createEncoder
-} from "@shelby-protocol/clay-codes";
-function getTotalChunks(config) {
-  return config.erasure_n;
+async function createWASMEncoder(opts) {
+  const { createEncoder } = await import("@shelby-protocol/clay-codes");
+  return createEncoder(opts);
 }
-var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
-  config;
-  encoderCache;
-  decoderCache;
-  lastFunction;
-  constructor(config) {
-    this.config = config;
-    this.lastFunction = "none" /* NONE */;
-  }
-  /**
-   * Static factory method to create an initialized ClayErasureCodingProvider
-   */
-  static async create(config) {
-    const provider = new _ClayErasureCodingProvider(config);
-    [provider.encoderCache, provider.decoderCache] = await Promise.all([
-      createEncoder({
-        n: getTotalChunks(config),
-        k: config.erasure_k,
-        d: config.erasure_d,
-        chunkSizeBytes: config.chunkSizeBytes
-      }),
-      createDecoder({
-        n: getTotalChunks(config),
-        k: config.erasure_k,
-        d: config.erasure_d,
-        chunkSizeBytes: config.chunkSizeBytes,
-        erasedChunkIndexes: []
-      })
-    ]);
-    return provider;
-  }
-  encode(data) {
-    const { erasure_k, chunkSizeBytes } = this.config;
-    if (!this.encoderCache) {
-      throw new Error("Encoder cache is missing");
-    }
-    const systematicCapacity = erasure_k * chunkSizeBytes;
-    if (data.byteLength > systematicCapacity) {
-      throw new Error(
-        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
-      );
-    }
-    if (this.requiresPadding(data.length)) {
-      throw new Error(
-        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
-      );
-    }
-    this.lastFunction = "encoded" /* ENCODED */;
-    return this.encoderCache.erasureCode(data);
-  }
-  decode(available, config) {
-    if (!this.decoderCache) {
-      throw new Error("Decoder cache is missing");
-    }
-    const { erasure_k, chunkSizeBytes } = this.config;
-    if (available.length < erasure_k) {
-      throw new Error(
-        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
-      );
-    }
-    for (let i = 0; i < available.length; i++) {
-      const chunk = available[i];
-      if (chunk.length !== chunkSizeBytes) {
-        throw new Error(
-          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
-        );
-      }
-    }
-    this.lastFunction = "decoded" /* DECODED */;
-    return this.decoderCache.decode(available, config);
-  }
-  getChunkMerkleRoots() {
-    if (this.decoderCache && this.lastFunction === "decoded" /* DECODED */)
-      return this.decoderCache.getChunkMerkleRoots();
-    if (this.encoderCache && this.lastFunction === "encoded" /* ENCODED */)
-      return this.encoderCache.getChunkMerkleRoots();
-    throw new Error(
-      "You must call encode or decode before calling getChunkMerkleRoots"
-    );
-  }
-  /**
-   * Determines if data can be erasure coded as-is or requires padding.
-   *
-   * Data can be erasure coded without padding if its size exactly matches
-   * the total systematic data capacity (k * chunkSizeBytes).
-   *
-   * @param dataSize - Size of the data in bytes
-   * @returns true if data needs padding, false if it can be coded as-is
-   */
-  requiresPadding(dataSize) {
-    const { erasure_k, chunkSizeBytes } = this.config;
-    const systematicCapacity = erasure_k * chunkSizeBytes;
-    return dataSize !== systematicCapacity;
-  }
-};
-
-// src/node/parallel/commitment_worker.ts
 async function encodeChunksetForCommitment(chunksetData, encoding) {
   const chunksetSizeBytes = encoding.erasure_k * encoding.chunkSizeBytes;
   const paddedChunkset = zeroPadBytes(chunksetData, chunksetSizeBytes);
-  const provider = await getProvider(encoding);
-  provider.encode(paddedChunkset);
-  const chunkRoots = provider.getChunkMerkleRoots().map((root) => Hex3.fromHexInput(root));
-  const chunksetRoot = await generateMerkleRoot(chunkRoots);
+  const encoder = await getEncoder(encoding);
+  encoder.erasureCode(paddedChunkset);
+  const commitment = encoder.getMerkleCommitment();
+  const chunkRoots = commitment.chunkRoots.map(
+    (root) => Hex2.fromHexInput(root).toString()
+  );
+  const chunksetRoot = Hex2.fromHexInput(commitment.chunksetRoot).toString();
   return {
-    chunkset_root: chunksetRoot.toString(),
-    chunk_commitments: chunkRoots.map((r) => r.toString())
+    chunkset_root: chunksetRoot,
+    chunk_commitments: chunkRoots
   };
 }
-var cachedProvider;
+var cachedEncoder;
 var cachedEncodingKey;
-async function getProvider(encoding) {
+async function getEncoder(encoding) {
   const key = `${encoding.erasure_n},${encoding.erasure_k},${encoding.erasure_d},${encoding.chunkSizeBytes},${encoding.enumIndex}`;
-  if (!cachedProvider || cachedEncodingKey !== key) {
-    cachedProvider = await ClayErasureCodingProvider.create(encoding);
+  if (!cachedEncoder || cachedEncodingKey !== key) {
+    const opts = {
+      n: encoding.erasure_n,
+      k: encoding.erasure_k,
+      d: encoding.erasure_d,
+      chunkSizeBytes: encoding.chunkSizeBytes
+    };
+    cachedEncoder = await tryCreateFFIEncoder(opts) ?? await createWASMEncoder(opts);
     cachedEncodingKey = key;
   }
-  return cachedProvider;
+  return cachedEncoder;
 }
 parentPort?.on("message", async (input) => {
   try {

package/dist/node/parallel/commitment_worker_pool.mjs

@@ -3,6 +3,35 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { Worker } from "worker_threads";
+
+// src/node/parallel/coverage_flush.ts
+import { takeCoverage } from "v8";
+var FLUSH_REQUEST = "__shelby_cov_flush_request__";
+var FLUSH_ACK = "__shelby_cov_flush_ack__";
+var coverageEnabled = () => Boolean(process.env.NODE_V8_COVERAGE);
+var isType = (msg, type) => typeof msg === "object" && msg !== null && msg.type === type;
+function flushWorkerCoverage(worker, timeoutMs = 2e3) {
+  if (!coverageEnabled()) return Promise.resolve();
+  return new Promise((resolve) => {
+    const onMessage = (msg) => {
+      if (isType(msg, FLUSH_ACK)) finish();
+    };
+    const finish = () => {
+      clearTimeout(timer);
+      worker.off("message", onMessage);
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    worker.on("message", onMessage);
+    try {
+      worker.postMessage({ type: FLUSH_REQUEST });
+    } catch {
+      finish();
+    }
+  });
+}
+
+// src/node/parallel/worker_pool.ts
 var WorkerPool = class {
   workers = [];
   queue = [];
@@ -39,6 +68,29 @@ var WorkerPool = class {
     const dir = path.dirname(currentPath);
     const ext = path.extname(currentPath);
     const workerExt = ext === ".mjs" ? ".mjs" : ext === ".js" ? ".js" : ".ts";
+    if (workerExt === ".ts") {
+      const srcSegment = `${path.sep}src${path.sep}`;
+      const srcIdx = currentPath.indexOf(srcSegment);
+      if (srcIdx !== -1) {
+        const packageRoot = currentPath.slice(0, srcIdx);
+        const relFromSrc = path.relative(path.join(packageRoot, "src"), dir);
+        return path.join(
+          packageRoot,
+          "dist",
+          "workers",
+          relFromSrc,
+          `${scriptName}.js`
+        );
+      }
+    }
+    let workerPath = path.join(dir, `${scriptName}${workerExt}`);
+    if (fs.existsSync(workerPath)) {
+      return workerPath;
+    }
+    workerPath = path.join(dir, "workers", `${scriptName}${workerExt}`);
+    if (fs.existsSync(workerPath)) {
+      return workerPath;
+    }
     return path.join(dir, `${scriptName}${workerExt}`);
   }
   initialize() {
@@ -210,9 +262,10 @@ var WorkerPool = class {
     for (const waiter of waiters) {
       waiter.reject(terminationError);
     }
-    const terminatePromises = this.workers.map((workerWrapper) => {
-      return new Promise((resolve) => {
-        const worker = workerWrapper.worker;
+    const terminatePromises = this.workers.map(async (workerWrapper) => {
+      const worker = workerWrapper.worker;
+      await flushWorkerCoverage(worker);
+      await new Promise((resolve) => {
         let resolved = false;
         const doResolve = () => {
           if (!resolved) {

package/dist/node/parallel/coverage_flush.d.ts

@@ -0,0 +1,16 @@
+import { MessagePort, Worker } from 'node:worker_threads';
+
+declare function isCoverageFlushMessage(msg: unknown): boolean;
+/**
+ * Worker side: handle flush requests by writing this thread's V8 coverage. Call
+ * once near the top of each worker entry. No-op unless NODE_V8_COVERAGE is set.
+ */
+declare function registerWorkerCoverageFlush(port: MessagePort | null): void;
+/**
+ * Pool side: ask a worker to flush its V8 coverage and wait (briefly) for the ack,
+ * so the write completes before the worker is terminated. No-op unless
+ * NODE_V8_COVERAGE is set; always resolves (on ack or timeout) and never throws.
+ */
+declare function flushWorkerCoverage(worker: Worker, timeoutMs?: number): Promise<void>;
+
+export { flushWorkerCoverage, isCoverageFlushMessage, registerWorkerCoverageFlush };

package/dist/node/parallel/coverage_flush.mjs

@@ -0,0 +1,43 @@
+// src/node/parallel/coverage_flush.ts
+import { takeCoverage } from "v8";
+var FLUSH_REQUEST = "__shelby_cov_flush_request__";
+var FLUSH_ACK = "__shelby_cov_flush_ack__";
+var coverageEnabled = () => Boolean(process.env.NODE_V8_COVERAGE);
+var isType = (msg, type) => typeof msg === "object" && msg !== null && msg.type === type;
+function isCoverageFlushMessage(msg) {
+  return isType(msg, FLUSH_REQUEST) || isType(msg, FLUSH_ACK);
+}
+function registerWorkerCoverageFlush(port) {
+  if (!coverageEnabled() || !port) return;
+  port.on("message", (msg) => {
+    if (isType(msg, FLUSH_REQUEST)) {
+      takeCoverage();
+      port.postMessage({ type: FLUSH_ACK });
+    }
+  });
+}
+function flushWorkerCoverage(worker, timeoutMs = 2e3) {
+  if (!coverageEnabled()) return Promise.resolve();
+  return new Promise((resolve) => {
+    const onMessage = (msg) => {
+      if (isType(msg, FLUSH_ACK)) finish();
+    };
+    const finish = () => {
+      clearTimeout(timer);
+      worker.off("message", onMessage);
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    worker.on("message", onMessage);
+    try {
+      worker.postMessage({ type: FLUSH_REQUEST });
+    } catch {
+      finish();
+    }
+  });
+}
+export {
+  flushWorkerCoverage,
+  isCoverageFlushMessage,
+  registerWorkerCoverageFlush
+};

package/dist/node/parallel/default_commitment_worker_pool.mjs

@@ -6,6 +6,35 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { Worker } from "worker_threads";
+
+// src/node/parallel/coverage_flush.ts
+import { takeCoverage } from "v8";
+var FLUSH_REQUEST = "__shelby_cov_flush_request__";
+var FLUSH_ACK = "__shelby_cov_flush_ack__";
+var coverageEnabled = () => Boolean(process.env.NODE_V8_COVERAGE);
+var isType = (msg, type) => typeof msg === "object" && msg !== null && msg.type === type;
+function flushWorkerCoverage(worker, timeoutMs = 2e3) {
+  if (!coverageEnabled()) return Promise.resolve();
+  return new Promise((resolve) => {
+    const onMessage = (msg) => {
+      if (isType(msg, FLUSH_ACK)) finish();
+    };
+    const finish = () => {
+      clearTimeout(timer);
+      worker.off("message", onMessage);
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    worker.on("message", onMessage);
+    try {
+      worker.postMessage({ type: FLUSH_REQUEST });
+    } catch {
+      finish();
+    }
+  });
+}
+
+// src/node/parallel/worker_pool.ts
 var WorkerPool = class {
   workers = [];
   queue = [];
@@ -42,6 +71,29 @@ var WorkerPool = class {
     const dir = path.dirname(currentPath);
     const ext = path.extname(currentPath);
     const workerExt = ext === ".mjs" ? ".mjs" : ext === ".js" ? ".js" : ".ts";
+    if (workerExt === ".ts") {
+      const srcSegment = `${path.sep}src${path.sep}`;
+      const srcIdx = currentPath.indexOf(srcSegment);
+      if (srcIdx !== -1) {
+        const packageRoot = currentPath.slice(0, srcIdx);
+        const relFromSrc = path.relative(path.join(packageRoot, "src"), dir);
+        return path.join(
+          packageRoot,
+          "dist",
+          "workers",
+          relFromSrc,
+          `${scriptName}.js`
+        );
+      }
+    }
+    let workerPath = path.join(dir, `${scriptName}${workerExt}`);
+    if (fs.existsSync(workerPath)) {
+      return workerPath;
+    }
+    workerPath = path.join(dir, "workers", `${scriptName}${workerExt}`);
+    if (fs.existsSync(workerPath)) {
+      return workerPath;
+    }
     return path.join(dir, `${scriptName}${workerExt}`);
   }
   initialize() {
@@ -213,9 +265,10 @@ var WorkerPool = class {
     for (const waiter of waiters) {
       waiter.reject(terminationError);
     }
-    const terminatePromises = this.workers.map((workerWrapper) => {
-      return new Promise((resolve) => {
-        const worker = workerWrapper.worker;
+    const terminatePromises = this.workers.map(async (workerWrapper) => {
+      const worker = workerWrapper.worker;
+      await flushWorkerCoverage(worker);
+      await new Promise((resolve) => {
         let resolved = false;
         const doResolve = () => {
           if (!resolved) {

package/dist/node/parallel/index.d.ts

@@ -1,5 +1,6 @@
 export { CommitmentEncoding } from './commitment_worker.js';
 export { CommitmentWorkerPool } from './commitment_worker_pool.js';
+export { flushWorkerCoverage, isCoverageFlushMessage, registerWorkerCoverageFlush } from './coverage_flush.js';
 export { CommitmentWorkerPoolOptions, createDefaultCommitmentWorkerPool, defaultCommitmentWorkerCount } from './default_commitment_worker_pool.js';
 export { generateCommitmentsParallel } from './parallel_commitments.js';
 export { WorkerPool, WorkerPoolTask } from './worker_pool.js';

package/dist/node/parallel/index.mjs

@@ -3,6 +3,47 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { Worker } from "worker_threads";
+
+// src/node/parallel/coverage_flush.ts
+import { takeCoverage } from "v8";
+var FLUSH_REQUEST = "__shelby_cov_flush_request__";
+var FLUSH_ACK = "__shelby_cov_flush_ack__";
+var coverageEnabled = () => Boolean(process.env.NODE_V8_COVERAGE);
+var isType = (msg, type) => typeof msg === "object" && msg !== null && msg.type === type;
+function isCoverageFlushMessage(msg) {
+  return isType(msg, FLUSH_REQUEST) || isType(msg, FLUSH_ACK);
+}
+function registerWorkerCoverageFlush(port) {
+  if (!coverageEnabled() || !port) return;
+  port.on("message", (msg) => {
+    if (isType(msg, FLUSH_REQUEST)) {
+      takeCoverage();
+      port.postMessage({ type: FLUSH_ACK });
+    }
+  });
+}
+function flushWorkerCoverage(worker, timeoutMs = 2e3) {
+  if (!coverageEnabled()) return Promise.resolve();
+  return new Promise((resolve) => {
+    const onMessage = (msg) => {
+      if (isType(msg, FLUSH_ACK)) finish();
+    };
+    const finish = () => {
+      clearTimeout(timer);
+      worker.off("message", onMessage);
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    worker.on("message", onMessage);
+    try {
+      worker.postMessage({ type: FLUSH_REQUEST });
+    } catch {
+      finish();
+    }
+  });
+}
+
+// src/node/parallel/worker_pool.ts
 var WorkerPool = class {
   workers = [];
   queue = [];
@@ -39,6 +80,29 @@ var WorkerPool = class {
     const dir = path.dirname(currentPath);
     const ext = path.extname(currentPath);
     const workerExt = ext === ".mjs" ? ".mjs" : ext === ".js" ? ".js" : ".ts";
+    if (workerExt === ".ts") {
+      const srcSegment = `${path.sep}src${path.sep}`;
+      const srcIdx = currentPath.indexOf(srcSegment);
+      if (srcIdx !== -1) {
+        const packageRoot = currentPath.slice(0, srcIdx);
+        const relFromSrc = path.relative(path.join(packageRoot, "src"), dir);
+        return path.join(
+          packageRoot,
+          "dist",
+          "workers",
+          relFromSrc,
+          `${scriptName}.js`
+        );
+      }
+    }
+    let workerPath = path.join(dir, `${scriptName}${workerExt}`);
+    if (fs.existsSync(workerPath)) {
+      return workerPath;
+    }
+    workerPath = path.join(dir, "workers", `${scriptName}${workerExt}`);
+    if (fs.existsSync(workerPath)) {
+      return workerPath;
+    }
     return path.join(dir, `${scriptName}${workerExt}`);
   }
   initialize() {
@@ -210,9 +274,10 @@ var WorkerPool = class {
     for (const waiter of waiters) {
       waiter.reject(terminationError);
     }
-    const terminatePromises = this.workers.map((workerWrapper) => {
-      return new Promise((resolve) => {
-        const worker = workerWrapper.worker;
+    const terminatePromises = this.workers.map(async (workerWrapper) => {
+      const worker = workerWrapper.worker;
+      await flushWorkerCoverage(worker);
+      await new Promise((resolve) => {
         let resolved = false;
         const doResolve = () => {
           if (!resolved) {
@@ -559,5 +624,8 @@ export {
   WorkerPool,
   createDefaultCommitmentWorkerPool,
   defaultCommitmentWorkerCount,
-  generateCommitmentsParallel
+  flushWorkerCoverage,
+  generateCommitmentsParallel,
+  isCoverageFlushMessage,
+  registerWorkerCoverageFlush
 };