@xyo-network/hash 4.0.1 → 4.0.3

package/dist/browser/worker/subtleHash-bundle.mjs

@@ -45,11 +45,26 @@
     }
   });
 
-  // ../../../../../../node_modules/.store/@xylabs-platform-npm-4.12.30-2074a9f711/package/dist/browser/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-platform-npm-4.13.4-b870ae4dca/package/dist/browser/index.mjs
   var subtle = globalThis.crypto.subtle;
 
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.12.30-d94c3dfd0f/package/dist/browser/worker/worker.browser.mjs
+  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.13.4-bf1f577edc/package/dist/browser/worker/worker.browser.mjs
   var import_is_observable_2_1_0 = __toESM(require_package(), 1);
+  var __defProp2 = Object.defineProperty;
+  var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+  function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+      deserialize(message) {
+        return implementation.deserialize(message, fallbackDeserializer);
+      },
+      serialize(input) {
+        return implementation.serialize(input, fallbackSerializer);
+      }
+    };
+  }
+  __name(extendSerializer, "extendSerializer");
   var DefaultErrorSerializer = {
     deserialize(message) {
       return Object.assign(new Error(message.message), {
@@ -66,7 +81,7 @@
       };
     }
   };
-  var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+  var isSerializedError = /* @__PURE__ */ __name((thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error", "isSerializedError");
   var DefaultSerializer = {
     deserialize(message) {
       return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
@@ -76,96 +91,144 @@
     }
   };
   globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+  function registerSerializer(serializer) {
+    globalThis.registeredSerializer = extendSerializer(globalThis.registeredSerializer, serializer);
+  }
+  __name(registerSerializer, "registerSerializer");
   function deserialize(message) {
     return globalThis.registeredSerializer.deserialize(message);
   }
+  __name(deserialize, "deserialize");
   function serialize(input) {
     return globalThis.registeredSerializer.serialize(input);
   }
+  __name(serialize, "serialize");
   var $errors = Symbol("thread.errors");
   var $events = Symbol("thread.events");
   var $terminate = Symbol("thread.terminate");
   var $transferable = Symbol("thread.transferable");
   var $worker = Symbol("thread.worker");
+  function isTransferable(thing) {
+    if (!thing || typeof thing !== "object") return false;
+    return true;
+  }
+  __name(isTransferable, "isTransferable");
   function isTransferDescriptor(thing) {
     return thing && typeof thing === "object" && thing[$transferable];
   }
-  var isErrorEvent = (value) => value && value.error;
+  __name(isTransferDescriptor, "isTransferDescriptor");
+  function Transfer(payload, transferables) {
+    console.log("Transfer");
+    if (!transferables) {
+      if (!isTransferable(payload)) throw new Error("Not transferable");
+      transferables = [
+        payload
+      ];
+    }
+    return {
+      [$transferable]: true,
+      send: payload,
+      transferables
+    };
+  }
+  __name(Transfer, "Transfer");
+  var MasterMessageType = /* @__PURE__ */ function(MasterMessageType2) {
+    MasterMessageType2["cancel"] = "cancel";
+    MasterMessageType2["run"] = "run";
+    return MasterMessageType2;
+  }({});
+  var WorkerMessageType = /* @__PURE__ */ function(WorkerMessageType2) {
+    WorkerMessageType2["error"] = "error";
+    WorkerMessageType2["init"] = "init";
+    WorkerMessageType2["result"] = "result";
+    WorkerMessageType2["running"] = "running";
+    WorkerMessageType2["uncaughtError"] = "uncaughtError";
+    return WorkerMessageType2;
+  }({});
+  var isErrorEvent = /* @__PURE__ */ __name((value) => value && value.error, "isErrorEvent");
   function createExpose(implementation, self2) {
     let exposeCalled = false;
     const activeSubscriptions = /* @__PURE__ */ new Map();
-    const isMasterJobCancelMessage = (thing) => thing && thing.type === "cancel";
-    const isMasterJobRunMessage = (thing) => thing && thing.type === "run";
-    const isObservable = (thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing);
+    const isMasterJobCancelMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.cancel, "isMasterJobCancelMessage");
+    const isMasterJobRunMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.run, "isMasterJobRunMessage");
+    const isObservable = /* @__PURE__ */ __name((thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing), "isObservable");
     function isZenObservable(thing) {
       return thing && typeof thing === "object" && typeof thing.subscribe === "function";
     }
+    __name(isZenObservable, "isZenObservable");
     function deconstructTransfer(thing) {
-      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+      return isTransferDescriptor(thing) ? {
+        payload: thing.send,
+        transferables: thing.transferables
+      } : {
+        payload: thing,
+        transferables: void 0
+      };
     }
+    __name(deconstructTransfer, "deconstructTransfer");
     function postFunctionInitMessage() {
       const initMessage = {
-        exposed: { type: "function" },
-        type: "init"
-        /* init */
+        exposed: {
+          type: "function"
+        },
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postFunctionInitMessage, "postFunctionInitMessage");
     function postModuleInitMessage(methodNames) {
       const initMessage = {
         exposed: {
           methods: methodNames,
           type: "module"
         },
-        type: "init"
-        /* init */
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postModuleInitMessage, "postModuleInitMessage");
     function postJobErrorMessage(uid, rawError) {
       const { payload: error, transferables } = deconstructTransfer(rawError);
       const errorMessage = {
         error: serialize(error),
-        type: "error",
+        type: WorkerMessageType.error,
         uid
       };
       implementation.postMessageToMaster(errorMessage, transferables);
     }
+    __name(postJobErrorMessage, "postJobErrorMessage");
     function postJobResultMessage(uid, completed, resultValue) {
       const { payload, transferables } = deconstructTransfer(resultValue);
       const resultMessage = {
         complete: completed ? true : void 0,
         payload,
-        type: "result",
+        type: WorkerMessageType.result,
         uid
       };
       implementation.postMessageToMaster(resultMessage, transferables);
     }
+    __name(postJobResultMessage, "postJobResultMessage");
     function postJobStartMessage(uid, resultType) {
       const startMessage = {
         resultType,
-        type: "running",
+        type: WorkerMessageType.running,
         uid
       };
       implementation.postMessageToMaster(startMessage);
     }
+    __name(postJobStartMessage, "postJobStartMessage");
     function postUncaughtErrorMessage(error) {
       try {
         const errorMessage = {
           error: serialize(error),
-          type: "uncaughtError"
-          /* uncaughtError */
+          type: WorkerMessageType.uncaughtError
         };
         implementation.postMessageToMaster(errorMessage);
       } catch (subError) {
-        console.error(
-          "Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:",
-          subError,
-          "\nOriginal error:",
-          error
-        );
+        console.error("Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:", subError, "\nOriginal error:", error);
       }
     }
+    __name(postUncaughtErrorMessage, "postUncaughtErrorMessage");
     async function runFunction(jobUID, fn, args) {
       let syncResult;
       try {
@@ -177,17 +240,13 @@
       const resultType = isObservable(syncResult) ? "observable" : "promise";
       postJobStartMessage(jobUID, resultType);
       if (isObservable(syncResult)) {
-        const subscription = syncResult.subscribe(
-          (value) => postJobResultMessage(jobUID, false, serialize(value)),
-          (error) => {
-            postJobErrorMessage(jobUID, serialize(error));
-            activeSubscriptions.delete(jobUID);
-          },
-          () => {
-            postJobResultMessage(jobUID, true);
-            activeSubscriptions.delete(jobUID);
-          }
-        );
+        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, serialize(value)), (error) => {
+          postJobErrorMessage(jobUID, serialize(error));
+          activeSubscriptions.delete(jobUID);
+        }, () => {
+          postJobResultMessage(jobUID, true);
+          activeSubscriptions.delete(jobUID);
+        });
         activeSubscriptions.set(jobUID, subscription);
       } else {
         try {
@@ -198,7 +257,8 @@
         }
       }
     }
-    const expose2 = (exposed) => {
+    __name(runFunction, "runFunction");
+    const expose2 = /* @__PURE__ */ __name((exposed) => {
       if (!implementation.isWorkerRuntime()) {
         throw new Error("expose() called in the master thread.");
       }
@@ -234,7 +294,7 @@
           }
         }
       });
-    };
+    }, "expose");
     if (typeof globalThis !== "undefined" && typeof self2.addEventListener === "function" && implementation.isWorkerRuntime()) {
       self2.addEventListener("error", (event) => {
         setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
@@ -258,23 +318,24 @@
     }
     return expose2;
   }
-  var isWorkerRuntime = function isWorkerRuntime2() {
+  __name(createExpose, "createExpose");
+  var isWorkerRuntime = /* @__PURE__ */ __name(function isWorkerRuntime2() {
     const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
     return self !== void 0 && self["postMessage"] && !isWindowContext ? true : false;
-  };
-  var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+  }, "isWorkerRuntime");
+  var postMessageToMaster = /* @__PURE__ */ __name(function postMessageToMaster2(data, transferList) {
     self.postMessage(data, transferList);
-  };
-  var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
-    const messageHandler = (messageEvent) => {
+  }, "postMessageToMaster");
+  var subscribeToMasterMessages = /* @__PURE__ */ __name(function subscribeToMasterMessages2(onMessage) {
+    const messageHandler = /* @__PURE__ */ __name((messageEvent) => {
       onMessage(messageEvent.data);
-    };
-    const unsubscribe = () => {
+    }, "messageHandler");
+    const unsubscribe = /* @__PURE__ */ __name(() => {
       self.removeEventListener("message", messageHandler);
-    };
+    }, "unsubscribe");
     self.addEventListener("message", messageHandler);
     return unsubscribe;
-  };
+  }, "subscribeToMasterMessages");
   var addEventListener = self.addEventListener.bind(void 0);
   var postMessage = self.postMessage.bind(void 0);
   var removeEventListener = self.removeEventListener.bind(void 0);

package/dist/browser/worker/wasmHash-bundle.mjs

@@ -45,7 +45,7 @@
     }
   });
 
-  // ../../../../../../node_modules/.store/@xylabs-typeof-npm-4.12.30-f77a95a8b2/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-typeof-npm-4.13.4-60e49ee07c/package/dist/neutral/index.mjs
   function isUndefined(value) {
     return value === void 0;
   }
@@ -56,7 +56,7 @@
     return typeof value === "number";
   }
 
-  // ../../../../../../node_modules/.store/@xylabs-hex-npm-4.12.30-5cf36c2500/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-hex-npm-4.13.4-3dcbea2bc5/package/dist/neutral/index.mjs
   var assertError = (value, assert, defaultMessage) => {
     if (!isUndefined(assert)) {
       const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
@@ -112,8 +112,23 @@
     return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
   }
 
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.12.30-d94c3dfd0f/package/dist/browser/worker/worker.browser.mjs
+  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.13.4-bf1f577edc/package/dist/browser/worker/worker.browser.mjs
   var import_is_observable_2_1_0 = __toESM(require_package(), 1);
+  var __defProp2 = Object.defineProperty;
+  var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+  function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+      deserialize(message) {
+        return implementation.deserialize(message, fallbackDeserializer);
+      },
+      serialize(input) {
+        return implementation.serialize(input, fallbackSerializer);
+      }
+    };
+  }
+  __name(extendSerializer, "extendSerializer");
   var DefaultErrorSerializer = {
     deserialize(message) {
       return Object.assign(new Error(message.message), {
@@ -130,7 +145,7 @@
       };
     }
   };
-  var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+  var isSerializedError = /* @__PURE__ */ __name((thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error", "isSerializedError");
   var DefaultSerializer = {
     deserialize(message) {
       return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
@@ -140,96 +155,144 @@
     }
   };
   globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+  function registerSerializer(serializer) {
+    globalThis.registeredSerializer = extendSerializer(globalThis.registeredSerializer, serializer);
+  }
+  __name(registerSerializer, "registerSerializer");
   function deserialize(message) {
     return globalThis.registeredSerializer.deserialize(message);
   }
+  __name(deserialize, "deserialize");
   function serialize(input) {
     return globalThis.registeredSerializer.serialize(input);
   }
+  __name(serialize, "serialize");
   var $errors = Symbol("thread.errors");
   var $events = Symbol("thread.events");
   var $terminate = Symbol("thread.terminate");
   var $transferable = Symbol("thread.transferable");
   var $worker = Symbol("thread.worker");
+  function isTransferable(thing) {
+    if (!thing || typeof thing !== "object") return false;
+    return true;
+  }
+  __name(isTransferable, "isTransferable");
   function isTransferDescriptor(thing) {
     return thing && typeof thing === "object" && thing[$transferable];
   }
-  var isErrorEvent = (value) => value && value.error;
+  __name(isTransferDescriptor, "isTransferDescriptor");
+  function Transfer(payload, transferables) {
+    console.log("Transfer");
+    if (!transferables) {
+      if (!isTransferable(payload)) throw new Error("Not transferable");
+      transferables = [
+        payload
+      ];
+    }
+    return {
+      [$transferable]: true,
+      send: payload,
+      transferables
+    };
+  }
+  __name(Transfer, "Transfer");
+  var MasterMessageType = /* @__PURE__ */ function(MasterMessageType2) {
+    MasterMessageType2["cancel"] = "cancel";
+    MasterMessageType2["run"] = "run";
+    return MasterMessageType2;
+  }({});
+  var WorkerMessageType = /* @__PURE__ */ function(WorkerMessageType2) {
+    WorkerMessageType2["error"] = "error";
+    WorkerMessageType2["init"] = "init";
+    WorkerMessageType2["result"] = "result";
+    WorkerMessageType2["running"] = "running";
+    WorkerMessageType2["uncaughtError"] = "uncaughtError";
+    return WorkerMessageType2;
+  }({});
+  var isErrorEvent = /* @__PURE__ */ __name((value) => value && value.error, "isErrorEvent");
   function createExpose(implementation, self2) {
     let exposeCalled = false;
     const activeSubscriptions = /* @__PURE__ */ new Map();
-    const isMasterJobCancelMessage = (thing) => thing && thing.type === "cancel";
-    const isMasterJobRunMessage = (thing) => thing && thing.type === "run";
-    const isObservable = (thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing);
+    const isMasterJobCancelMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.cancel, "isMasterJobCancelMessage");
+    const isMasterJobRunMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.run, "isMasterJobRunMessage");
+    const isObservable = /* @__PURE__ */ __name((thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing), "isObservable");
     function isZenObservable(thing) {
       return thing && typeof thing === "object" && typeof thing.subscribe === "function";
     }
+    __name(isZenObservable, "isZenObservable");
     function deconstructTransfer(thing) {
-      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+      return isTransferDescriptor(thing) ? {
+        payload: thing.send,
+        transferables: thing.transferables
+      } : {
+        payload: thing,
+        transferables: void 0
+      };
     }
+    __name(deconstructTransfer, "deconstructTransfer");
     function postFunctionInitMessage() {
       const initMessage = {
-        exposed: { type: "function" },
-        type: "init"
-        /* init */
+        exposed: {
+          type: "function"
+        },
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postFunctionInitMessage, "postFunctionInitMessage");
     function postModuleInitMessage(methodNames) {
       const initMessage = {
         exposed: {
           methods: methodNames,
           type: "module"
         },
-        type: "init"
-        /* init */
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postModuleInitMessage, "postModuleInitMessage");
     function postJobErrorMessage(uid, rawError) {
       const { payload: error, transferables } = deconstructTransfer(rawError);
       const errorMessage = {
         error: serialize(error),
-        type: "error",
+        type: WorkerMessageType.error,
         uid
       };
       implementation.postMessageToMaster(errorMessage, transferables);
     }
+    __name(postJobErrorMessage, "postJobErrorMessage");
     function postJobResultMessage(uid, completed, resultValue) {
       const { payload, transferables } = deconstructTransfer(resultValue);
       const resultMessage = {
         complete: completed ? true : void 0,
         payload,
-        type: "result",
+        type: WorkerMessageType.result,
         uid
       };
       implementation.postMessageToMaster(resultMessage, transferables);
     }
+    __name(postJobResultMessage, "postJobResultMessage");
     function postJobStartMessage(uid, resultType) {
       const startMessage = {
         resultType,
-        type: "running",
+        type: WorkerMessageType.running,
         uid
       };
       implementation.postMessageToMaster(startMessage);
     }
+    __name(postJobStartMessage, "postJobStartMessage");
     function postUncaughtErrorMessage(error) {
       try {
         const errorMessage = {
           error: serialize(error),
-          type: "uncaughtError"
-          /* uncaughtError */
+          type: WorkerMessageType.uncaughtError
         };
         implementation.postMessageToMaster(errorMessage);
       } catch (subError) {
-        console.error(
-          "Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:",
-          subError,
-          "\nOriginal error:",
-          error
-        );
+        console.error("Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:", subError, "\nOriginal error:", error);
       }
     }
+    __name(postUncaughtErrorMessage, "postUncaughtErrorMessage");
     async function runFunction(jobUID, fn, args) {
       let syncResult;
       try {
@@ -241,17 +304,13 @@
       const resultType = isObservable(syncResult) ? "observable" : "promise";
       postJobStartMessage(jobUID, resultType);
       if (isObservable(syncResult)) {
-        const subscription = syncResult.subscribe(
-          (value) => postJobResultMessage(jobUID, false, serialize(value)),
-          (error) => {
-            postJobErrorMessage(jobUID, serialize(error));
-            activeSubscriptions.delete(jobUID);
-          },
-          () => {
-            postJobResultMessage(jobUID, true);
-            activeSubscriptions.delete(jobUID);
-          }
-        );
+        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, serialize(value)), (error) => {
+          postJobErrorMessage(jobUID, serialize(error));
+          activeSubscriptions.delete(jobUID);
+        }, () => {
+          postJobResultMessage(jobUID, true);
+          activeSubscriptions.delete(jobUID);
+        });
         activeSubscriptions.set(jobUID, subscription);
       } else {
         try {
@@ -262,7 +321,8 @@
         }
       }
     }
-    const expose2 = (exposed) => {
+    __name(runFunction, "runFunction");
+    const expose2 = /* @__PURE__ */ __name((exposed) => {
       if (!implementation.isWorkerRuntime()) {
         throw new Error("expose() called in the master thread.");
       }
@@ -298,7 +358,7 @@
           }
         }
       });
-    };
+    }, "expose");
     if (typeof globalThis !== "undefined" && typeof self2.addEventListener === "function" && implementation.isWorkerRuntime()) {
       self2.addEventListener("error", (event) => {
         setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
@@ -322,23 +382,24 @@
     }
     return expose2;
   }
-  var isWorkerRuntime = function isWorkerRuntime2() {
+  __name(createExpose, "createExpose");
+  var isWorkerRuntime = /* @__PURE__ */ __name(function isWorkerRuntime2() {
     const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
     return self !== void 0 && self["postMessage"] && !isWindowContext ? true : false;
-  };
-  var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+  }, "isWorkerRuntime");
+  var postMessageToMaster = /* @__PURE__ */ __name(function postMessageToMaster2(data, transferList) {
     self.postMessage(data, transferList);
-  };
-  var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
-    const messageHandler = (messageEvent) => {
+  }, "postMessageToMaster");
+  var subscribeToMasterMessages = /* @__PURE__ */ __name(function subscribeToMasterMessages2(onMessage) {
+    const messageHandler = /* @__PURE__ */ __name((messageEvent) => {
       onMessage(messageEvent.data);
-    };
-    const unsubscribe = () => {
+    }, "messageHandler");
+    const unsubscribe = /* @__PURE__ */ __name(() => {
       self.removeEventListener("message", messageHandler);
-    };
+    }, "unsubscribe");
     self.addEventListener("message", messageHandler);
     return unsubscribe;
-  };
+  }, "subscribeToMasterMessages");
   var addEventListener = self.addEventListener.bind(void 0);
   var postMessage = self.postMessage.bind(void 0);
   var removeEventListener = self.removeEventListener.bind(void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/hash",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -50,20 +50,20 @@
     "wasmHashBundle": "esbuild src/worker/wasmHash.ts --bundle --outfile=dist/browser/worker/wasmHash-bundle.mjs --target=chrome120,firefox120,safari14,edge120"
   },
   "dependencies": {
-    "@xylabs/assert": "^4.12.30",
-    "@xylabs/hex": "^4.12.30",
-    "@xylabs/object": "^4.12.30",
-    "@xylabs/platform": "^4.12.30",
-    "@xylabs/threads": "^4.12.30",
-    "@xylabs/typeof": "^4.12.30",
-    "@xyo-network/wasm": "^4.0.1",
+    "@xylabs/assert": "^4.13.4",
+    "@xylabs/hex": "^4.13.4",
+    "@xylabs/object": "^4.13.4",
+    "@xylabs/platform": "^4.13.4",
+    "@xylabs/threads": "^4.13.4",
+    "@xylabs/typeof": "^4.13.4",
+    "@xyo-network/wasm": "^4.0.3",
     "hash-wasm": "^4.12.0"
   },
   "devDependencies": {
-    "@xylabs/delay": "^4.12.30",
-    "@xylabs/tsconfig": "^6.5.12",
-    "@xylabs/vitest-extended": "^4.12.30",
-    "esbuild": "^0.25.5",
+    "@xylabs/delay": "^4.13.4",
+    "@xylabs/tsconfig": "^6.5.18",
+    "@xylabs/vitest-extended": "^4.13.4",
+    "esbuild": "^0.25.6",
     "publint": "^0.3.12",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"