@getpara/server-sdk 2.0.0-alpha.6 → 2.0.0-alpha.61

package/dist/cjs/wallet/signing.js

@@ -57,109 +57,161 @@ var uuid = __toESM(require("uuid"));
 var import_workerWrapper = require("../workers/workerWrapper.js");
 function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (sendTransactionRes) => __async(this, null, function* () {
-          resolve(sendTransactionRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        cosmosPrefix: ctx.cosmosPrefix,
-        params: { share, walletId, userId, tx, chainId },
-        functionType: "SIGN_TRANSACTION",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        useDKLS: isDKLS,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (sendTransactionRes) => __async(this, null, function* () {
+            resolve(sendTransactionRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, tx, chainId },
+            functionType: "SIGN_TRANSACTION",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          cosmosPrefix: ctx.cosmosPrefix,
+          params: { share, walletId, userId, tx, chainId },
+          functionType: "SIGN_TRANSACTION",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          useDKLS: isDKLS,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }
 function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (sendTransactionRes) => __async(this, null, function* () {
-          resolve(sendTransactionRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        params: { share, walletId, userId, tx, chainId },
-        functionType: "SEND_TRANSACTION",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        useDKLS: isDKLS,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (sendTransactionRes) => __async(this, null, function* () {
+            resolve(sendTransactionRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, tx, chainId },
+            functionType: "SEND_TRANSACTION",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          params: { share, walletId, userId, tx, chainId },
+          functionType: "SEND_TRANSACTION",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          useDKLS: isDKLS,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }
 function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (signMessageRes) => __async(this, null, function* () {
-          resolve(signMessageRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        params: { share, walletId, userId, message },
-        functionType: "SIGN_MESSAGE",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        useDKLS: isDKLS,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (signMessageRes) => __async(this, null, function* () {
+            resolve(signMessageRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, message },
+            functionType: "SIGN_MESSAGE",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          params: { share, walletId, userId, message },
+          functionType: "SIGN_MESSAGE",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          useDKLS: isDKLS,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }
 function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
       const workId = uuid.v4();
-      const worker = yield (0, import_workerWrapper.setupWorker)(
-        ctx,
-        (signMessageRes) => __async(this, null, function* () {
-          resolve(signMessageRes);
-        }),
-        workId
-      );
-      worker.postMessage({
-        env: ctx.env,
-        apiKey: ctx.apiKey,
-        params: { share, walletId, userId, base64Bytes },
-        functionType: "ED25519_SIGN",
-        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
-        disableWorkers: ctx.disableWorkers,
-        sessionCookie,
-        disableWebSockets: ctx.disableWebSockets,
-        wasmOverride: ctx.wasmOverride,
-        workId
-      });
+      try {
+        const worker = yield (0, import_workerWrapper.setupWorker)(
+          ctx,
+          (signMessageRes) => __async(this, null, function* () {
+            resolve(signMessageRes);
+          }),
+          (error) => {
+            reject(error);
+          },
+          workId,
+          {
+            params: { walletId, userId, base64Bytes },
+            functionType: "ED25519_SIGN",
+            disableWorkers: ctx.disableWorkers,
+            disableWebSockets: ctx.disableWebSockets
+          }
+        );
+        worker.postMessage({
+          env: ctx.env,
+          apiKey: ctx.apiKey,
+          params: { share, walletId, userId, base64Bytes },
+          functionType: "ED25519_SIGN",
+          offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+          disableWorkers: ctx.disableWorkers,
+          sessionCookie,
+          disableWebSockets: ctx.disableWebSockets,
+          wasmOverride: ctx.wasmOverride,
+          workId
+        });
+      } catch (error) {
+        reject(error);
+      }
     }));
   });
 }

package/dist/cjs/workers/walletUtils.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -50,6 +60,7 @@ __export(walletUtils_exports, {
 });
 module.exports = __toCommonJS(walletUtils_exports);
 var import_core_sdk = require("@getpara/core-sdk");
+var uuid = __toESM(require("uuid"));
 const configCGGMPBase = (serverUrl, walletId, id) => `{"ServerUrl":"${serverUrl}", "WalletId": "${walletId}", "Id":"${id}", "Ids":["USER","CAPSULE"], "Threshold":1}`;
 const configDKLSBase = (walletId, id, disableWebSockets) => `{"walletId": "${walletId}", "id":"${id}", "otherId":"CAPSULE", "isReceiver": false, "disableWebSockets": ${disableWebSockets}}`;
 function keygenRequest(ctx, userId, walletId, protocolId) {
@@ -133,20 +144,30 @@ function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
 }
 function ed25519Sign(ctx, share, userId, walletId, base64Bytes) {
   return __async(this, null, function* () {
-    const { protocolId } = yield ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519");
-    try {
-      const base64Sig = yield new Promise(
-        (resolve, reject) => global.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve(result);
-        })
-      );
-      return { signature: base64Sig };
-    } catch (e) {
-      throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+    const protocolId = uuid.v4();
+    const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519", void 0, protocolId);
+    const signRes = function() {
+      return __async(this, null, function* () {
+        try {
+          const base64Sig = yield new Promise(
+            (resolve, reject) => global.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve(result);
+            })
+          );
+          return { signature: base64Sig };
+        } catch (e) {
+          throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const { pendingTransactionId } = yield preSignMessageRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield signRes;
   });
 }
 function keygen(ctx, userId, type, secretKey) {
@@ -233,81 +254,102 @@ function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type,
 }
 function signMessage(ctx, share, walletId, userId, message) {
   return __async(this, null, function* () {
-    const { protocolId, pendingTransactionId } = yield ctx.client.preSignMessage(userId, walletId, message);
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
+    const protocolId = uuid.v4();
+    const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, message, null, null, protocolId);
     if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
       return signMessageRequest(ctx, userId, walletId, protocolId, message, share);
     }
     const serverUrl = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
     const signMessageFn = ctx.useDKLS ? global.dklsSignMessage : global.signMessage;
-    try {
-      return yield new Promise(
-        (resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve({ signature: result });
-        })
-      );
-    } catch (e) {
-      throw new Error(`error signing for account with userId ${userId} and walletId ${walletId}`);
+    const signMessageRes = function() {
+      return __async(this, null, function* () {
+        try {
+          return yield new Promise(
+            (resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve({ signature: result });
+            })
+          );
+        } catch (e) {
+          throw new Error(`error signing for account with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const { pendingTransactionId } = yield preSignMessageRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield signMessageRes;
   });
 }
 function signTransaction(ctx, share, walletId, userId, tx, chainId) {
   return __async(this, null, function* () {
-    const {
-      data: { protocolId, pendingTransactionId }
-    } = yield ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId });
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
+    const protocolId = uuid.v4();
+    const signTransactionRes = ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId, protocolId });
     if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
       return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
     }
     const serverUrl = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
     const signTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-    try {
-      return yield new Promise(
-        (resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve({ signature: result });
-        })
-      );
-    } catch (e) {
-      throw new Error(`error signing transaction for account with userId ${userId} and walletId ${walletId}`);
+    const signTxRes = function() {
+      return __async(this, null, function* () {
+        try {
+          return yield new Promise(
+            (resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve({ signature: result });
+            })
+          );
+        } catch (e) {
+          throw new Error(`error signing transaction for account with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const {
+      data: { pendingTransactionId }
+    } = yield signTransactionRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield signTxRes;
   });
 }
 function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
   return __async(this, null, function* () {
-    const {
-      data: { protocolId, pendingTransactionId }
-    } = yield ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId });
-    if (pendingTransactionId) {
-      return { pendingTransactionId };
-    }
+    const protocolId = uuid.v4();
+    const sendTransactionRes = ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId, protocolId });
     if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
       return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
     }
     const serverUrl = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
     const sendTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
-    try {
-      return yield new Promise(
-        (resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          resolve({ signature: result });
-        })
-      );
-    } catch (e) {
-      throw new Error(`error signing transaction to send for account with userId ${userId} and walletId ${walletId}`);
+    const sendTxRes = function() {
+      return __async(this, null, function* () {
+        try {
+          return yield new Promise(
+            (resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+              if (err) {
+                reject(err);
+              }
+              resolve({ signature: result });
+            })
+          );
+        } catch (e) {
+          throw new Error(`error signing transaction to send for account with userId ${userId} and walletId ${walletId}`);
+        }
+      });
+    }();
+    const {
+      data: { pendingTransactionId }
+    } = yield sendTransactionRes;
+    if (pendingTransactionId) {
+      return { pendingTransactionId };
     }
+    return yield sendTxRes;
   });
 }
 function refresh(ctx, share, walletId, userId) {

package/dist/cjs/workers/worker.js

@@ -48,13 +48,15 @@ var __async = (__this, __arguments, generator) => {
 var worker_exports = {};
 __export(worker_exports, {
   handleMessage: () => handleMessage,
-  requestWasmWithRetries: () => requestWasmWithRetries
+  requestWasmWithRetries: () => requestWasmWithRetries,
+  withRetry: () => withRetry
 });
 module.exports = __toCommonJS(worker_exports);
 var import_axios = __toESM(require("axios"));
 var import_core_sdk = require("@getpara/core-sdk");
 var walletUtils = __toESM(require("./walletUtils.js"));
 let rawWasm;
+let wasmLoaded = false;
 function requestWasmWithRetries(ctx, retries = 3) {
   return __async(this, null, function* () {
     for (let i = 0; i < retries; i++) {
@@ -85,21 +87,24 @@ function executeMessage(ctx, message) {
   return __async(this, null, function* () {
     const { functionType, params } = message;
     switch (functionType) {
+      case "INIT": {
+        return {};
+      }
       case "KEYGEN": {
         const { userId, secretKey, type = "EVM" } = params;
         return walletUtils.keygen(ctx, userId, type, secretKey);
       }
       case "SIGN_TRANSACTION": {
         const { share, walletId, userId, tx, chainId } = params;
-        return walletUtils.signTransaction(ctx, share, walletId, userId, tx, chainId);
+        return withRetry(() => walletUtils.signTransaction(ctx, share, walletId, userId, tx, chainId));
       }
       case "SEND_TRANSACTION": {
         const { share, walletId, userId, tx, chainId } = params;
-        return walletUtils.sendTransaction(ctx, share, walletId, userId, tx, chainId);
+        return withRetry(() => walletUtils.sendTransaction(ctx, share, walletId, userId, tx, chainId));
       }
       case "SIGN_MESSAGE": {
         const { share, walletId, userId, message: message2 } = params;
-        return walletUtils.signMessage(ctx, share, walletId, userId, message2);
+        return withRetry(() => walletUtils.signMessage(ctx, share, walletId, userId, message2));
       }
       case "REFRESH": {
         const { share, walletId, userId } = params;
@@ -144,6 +149,29 @@ function executeMessage(ctx, message) {
     }
   });
 }
+function withRetry(operation, maxRetries = 2, timeoutMs = 1e4) {
+  return __async(this, null, function* () {
+    let retries = 0;
+    while (true) {
+      try {
+        const operationPromise = operation();
+        const timeoutPromise = new Promise((_, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          operationPromise.finally(() => clearTimeout(timeoutId));
+        });
+        return yield Promise.race([operationPromise, timeoutPromise]);
+      } catch (error) {
+        retries++;
+        if (retries > maxRetries) {
+          throw error;
+        }
+        console.warn(`Operation failed (attempt ${retries}/${maxRetries}), retrying...`, error);
+      }
+    }
+  });
+}
 function handleMessage(e) {
   return __async(this, null, function* () {
     const {
@@ -167,8 +195,20 @@ function handleMessage(e) {
       disableWebSockets: !!disableWebSockets,
       cosmosPrefix
     };
-    if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+    if (!wasmLoaded && (!ctx.offloadMPCComputationURL || ctx.useDKLS)) {
       yield loadWasm(ctx);
+      if (global.initWasm) {
+        const serverUrl = (0, import_core_sdk.getBaseMPCNetworkUrl)(ctx.env, !ctx.disableWebSockets);
+        yield new Promise(
+          (resolve, reject) => global.initWasm((err, result2) => {
+            if (err) {
+              reject(err);
+            }
+            resolve(result2);
+          }, serverUrl)
+        );
+      }
+      wasmLoaded = true;
     }
     const result = yield executeMessage(ctx, e.data);
     result.workId = workId;
@@ -178,5 +218,6 @@ function handleMessage(e) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handleMessage,
-  requestWasmWithRetries
+  requestWasmWithRetries,
+  withRetry
 });

package/dist/cjs/workers/workerWrapper.js

@@ -37,6 +37,7 @@ var __async = (__this, __arguments, generator) => {
 };
 var workerWrapper_exports = {};
 __export(workerWrapper_exports, {
+  resetWorker: () => resetWorker,
   setupWorker: () => setupWorker
 });
 module.exports = __toCommonJS(workerWrapper_exports);
@@ -53,30 +54,70 @@ function removeWorkId(workId, skipClearTimeout) {
   }
   clearTimeout(timeoutId);
 }
-function setupWorker(ctx, resFunction, workId) {
+function resetWorker() {
+  if (worker) {
+    worker.terminate();
+    worker = void 0;
+  }
+}
+function setupWorker(ctx, resFunction, errorFunction, workId, errorContext) {
   return __async(this, null, function* () {
     const timeoutId = setTimeout(() => {
-      removeWorkId(workId, true);
+      if (resFunctionMap[workId]) {
+        const errorMsg = `worker operation timed out after ${CLEAR_WORKER_TIMEOUT_MS}ms for workId ${workId} and opts ${JSON.stringify(resFunctionMap[workId].errorContext)}`;
+        resFunctionMap[workId].errorFn(new Error(errorMsg));
+        removeWorkId(workId, true);
+      }
     }, CLEAR_WORKER_TIMEOUT_MS);
     resFunctionMap[workId] = {
       fn: resFunction,
-      timeoutId
+      errorFn: errorFunction,
+      timeoutId,
+      errorContext
     };
     if (!worker || !worker.threadId) {
-      const workerRes = yield fetch(`${(0, import_core_sdk.getPortalBaseURL)(ctx)}/static/js/mpcWorkerServer-bundle.js`);
+      const isDeno = typeof (globalThis == null ? void 0 : globalThis.Deno) !== "undefined";
+      const workerFileName = isDeno ? "mpcWorkerServer-esm.js" : "mpcWorkerServer-bundle.js";
+      const workerRes = yield fetch(`${(0, import_core_sdk.getPortalBaseURL)(ctx)}/static/js/${workerFileName}`);
       worker = new import_worker_threads.Worker(yield workerRes.text(), { eval: true });
       const onmessage = (message) => __async(this, null, function* () {
         const { workId: messageWorkId } = message;
+        if (!resFunctionMap[messageWorkId]) {
+          console.warn(`received message for unknown workId: ${messageWorkId}`);
+          return;
+        }
         delete message.workId;
-        yield resFunctionMap[messageWorkId].fn(message);
-        removeWorkId(messageWorkId);
+        try {
+          yield resFunctionMap[messageWorkId].fn(message);
+          removeWorkId(messageWorkId);
+        } catch (error) {
+          console.error(`error in worker message handler for workId ${messageWorkId}:`, error);
+          if (resFunctionMap[messageWorkId]) {
+            resFunctionMap[messageWorkId].errorFn(error);
+            removeWorkId(messageWorkId);
+          }
+        }
       });
       worker.on("message", onmessage);
       worker.on("error", (err) => {
-        throw err;
+        console.error("worker error:", err);
+        Object.keys(resFunctionMap).forEach((id) => {
+          if (resFunctionMap[id]) {
+            const errorMsg = `worker error with workId ${id} and opts ${JSON.stringify(resFunctionMap[id].errorContext)}: ${err.message}`;
+            resFunctionMap[id].errorFn(new Error(errorMsg));
+            removeWorkId(id);
+          }
+        });
       });
       worker.on("exit", (code) => {
         console.error(`worker stopped with exit code ${code}`);
+        Object.keys(resFunctionMap).forEach((id) => {
+          if (resFunctionMap[id]) {
+            resFunctionMap[id].errorFn(new Error(`worker exited unexpectedly with code ${code}`));
+            removeWorkId(id);
+          }
+        });
+        worker = void 0;
       });
     }
     return worker;
@@ -84,5 +125,6 @@ function setupWorker(ctx, resFunction, workId) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  resetWorker,
   setupWorker
 });