wao 0.9.2 → 0.10.2

package/cjs/waosm-node/waosm_bg.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Decompressor = exports.Compressor = void 0;
+exports.__wbg_buffer_609cc3eee51ed158 = __wbg_buffer_609cc3eee51ed158;
+exports.__wbg_length_a446193dc22c12f8 = __wbg_length_a446193dc22c12f8;
+exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a;
+exports.__wbg_newwithlength_a381634e90c276d4 = __wbg_newwithlength_a381634e90c276d4;
+exports.__wbg_set_65595bdd868b3009 = __wbg_set_65595bdd868b3009;
+exports.__wbg_set_wasm = __wbg_set_wasm;
+exports.__wbindgen_memory = __wbindgen_memory;
+exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref;
+exports.__wbindgen_throw = __wbindgen_throw;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var wasm;
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+var heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+function getObject(idx) {
+  return heap[idx];
+}
+var heap_next = heap.length;
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  var idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function takeObject(idx) {
+  var ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+var lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+var cachedTextDecoder = new lTextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true
+});
+cachedTextDecoder.decode();
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  var ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+var CompressorFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: function register() {},
+  unregister: function unregister() {}
+} : new FinalizationRegistry(function (ptr) {
+  return wasm.__wbg_compressor_free(ptr >>> 0, 1);
+});
+var Compressor = exports.Compressor = /*#__PURE__*/function () {
+  function Compressor() {
+    _classCallCheck(this, Compressor);
+    var ret = wasm.compressor_new();
+    this.__wbg_ptr = ret >>> 0;
+    CompressorFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Uint8Array} data
+   * @returns {Uint8Array}
+   */
+  return _createClass(Compressor, [{
+    key: "__destroy_into_raw",
+    value: function __destroy_into_raw() {
+      var ptr = this.__wbg_ptr;
+      this.__wbg_ptr = 0;
+      CompressorFinalization.unregister(this);
+      return ptr;
+    }
+  }, {
+    key: "free",
+    value: function free() {
+      var ptr = this.__destroy_into_raw();
+      wasm.__wbg_compressor_free(ptr, 0);
+    }
+  }, {
+    key: "compress",
+    value: function compress(data) {
+      var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+      var len0 = WASM_VECTOR_LEN;
+      var ret = wasm.compressor_compress(this.__wbg_ptr, ptr0, len0);
+      return takeObject(ret);
+    }
+  }]);
+}();
+var DecompressorFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: function register() {},
+  unregister: function unregister() {}
+} : new FinalizationRegistry(function (ptr) {
+  return wasm.__wbg_decompressor_free(ptr >>> 0, 1);
+});
+var Decompressor = exports.Decompressor = /*#__PURE__*/function () {
+  function Decompressor() {
+    _classCallCheck(this, Decompressor);
+    var ret = wasm.compressor_new();
+    this.__wbg_ptr = ret >>> 0;
+    DecompressorFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Uint8Array} data
+   * @returns {Uint8Array}
+   */
+  return _createClass(Decompressor, [{
+    key: "__destroy_into_raw",
+    value: function __destroy_into_raw() {
+      var ptr = this.__wbg_ptr;
+      this.__wbg_ptr = 0;
+      DecompressorFinalization.unregister(this);
+      return ptr;
+    }
+  }, {
+    key: "free",
+    value: function free() {
+      var ptr = this.__destroy_into_raw();
+      wasm.__wbg_decompressor_free(ptr, 0);
+    }
+  }, {
+    key: "decompress",
+    value: function decompress(data) {
+      var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+      var len0 = WASM_VECTOR_LEN;
+      var ret = wasm.decompressor_decompress(this.__wbg_ptr, ptr0, len0);
+      return takeObject(ret);
+    }
+  }]);
+}();
+function __wbg_buffer_609cc3eee51ed158(arg0) {
+  var ret = getObject(arg0).buffer;
+  return addHeapObject(ret);
+}
+;
+function __wbg_length_a446193dc22c12f8(arg0) {
+  var ret = getObject(arg0).length;
+  return ret;
+}
+;
+function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
+  var ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+  return addHeapObject(ret);
+}
+;
+function __wbg_newwithlength_a381634e90c276d4(arg0) {
+  var ret = new Uint8Array(arg0 >>> 0);
+  return addHeapObject(ret);
+}
+;
+function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
+  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+}
+;
+function __wbindgen_memory() {
+  var ret = wasm.memory;
+  return addHeapObject(ret);
+}
+;
+function __wbindgen_object_drop_ref(arg0) {
+  takeObject(arg0);
+}
+;
+function __wbindgen_throw(arg0, arg1) {
+  throw new Error(getStringFromWasm0(arg0, arg1));
+}
+;

package/cjs/waosm-node.js

@@ -0,0 +1,28 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _waosm_bg = _interopRequireWildcard(require("./waosm-node/waosm_bg.js"));
+var wasmBindings = _waosm_bg;
+Object.keys(_waosm_bg).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _waosm_bg[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _waosm_bg[key];
+    }
+  });
+});
+var _fs = require("fs");
+var _path = require("path");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var wasm = (0, _fs.readFileSync)((0, _path.resolve)(import.meta.dirname, "./waosm-node/waosm_bg.wasm"));
+var wasmModule = new WebAssembly.Module(wasm);
+var wasmInstance = new WebAssembly.Instance(wasmModule, {
+  "./waosm_bg.js": wasmBindings
+});
+(0, _waosm_bg.__wbg_set_wasm)(wasmInstance.exports);

package/cjs/war.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
-var _arBase = _interopRequireDefault(require("./ar-base.js"));
+var _bar = _interopRequireDefault(require("./bar.js"));
 var _armemWeb = _interopRequireDefault(require("./armem-web.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -33,5 +33,5 @@ var AR = /*#__PURE__*/function (_BAR) {
   }
   _inherits(AR, _BAR);
   return _createClass(AR);
-}(_arBase["default"]);
+}(_bar["default"]);
 var _default = exports["default"] = AR;

package/esm/ao.js

@@ -369,7 +369,6 @@ class AO {
         data: jsonToStr(data),
       })
     } catch (e) {
-      console.log(e)
       err = e
     }
     const p = pid ? this.p(pid) : null
@@ -405,8 +404,7 @@ class AO {
         }
       }
     }
-    const checkOut = async (get, _txs, _txmap) => {
-      let out = null
+    const checkOut = async (get, _txs, _txmap, out) => {
       for (let v of _txs) {
         if (isNil(_txmap[v.id].res)) {
           const res = await this.result({ process: pid, message: v.id })
@@ -414,8 +412,9 @@ class AO {
         }
         if (!isNil(_txmap[v.id].res) && _txmap[v.id].out !== true) {
           _txmap[v.id].out = true
-          out = getTagVal(get, _txmap[v.id].res, v.from)
-          if (out) break
+          const _out = getTagVal(get, _txmap[v.id].res, v.from)
+          out = mergeOut(out, _out, get)
+          if (isOutComplete(out, get)) break
         }
       }
       return out
@@ -455,14 +454,15 @@ class AO {
         await wait(1000)
         await getNewTxs(pid, _txs, _txmap)
       } while (Date.now() - start < timeout)
+
       if (!checked) {
         err = "something went wrong!"
       } else {
-        out = mergeOut(out, await checkOut(get, _txs, _txmap), get)
+        out = mergeOut(out, await checkOut(get, _txs, _txmap, out), get)
         if (!isOutComplete(out, get) && !isNil(get)) {
           while (Date.now() - start < timeout) {
             await getNewTxs(pid, _txs, _txmap)
-            out = mergeOut(out, await checkOut(get, _txs, _txmap), get)
+            out = mergeOut(out, await checkOut(get, _txs, _txmap, out), get)
             if (isOutComplete(out, get)) break
             await wait(1000)
           }

package/esm/aoconnect-base.js

@@ -14,7 +14,7 @@ import {
   dirname,
 } from "./utils.js"
 import weavedrive from "./weavedrive.js"
-import { is, clone, fromPairs, map, mergeLeft, isNil } from "ramda"
+import { is, clone, fromPairs, map, mergeLeft, isNil, dissoc, o } from "ramda"
 
 export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
   return (mem, { cache, log = false, extensions = {} } = {}) => {
@@ -70,12 +70,12 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
       return {
         Process: {
           Id: pid,
-          Tags: (await mem.get("txs", pid))?.tags ?? [],
+          Tags: (await mem.getTx(pid))?.tags ?? [],
           Owner: owner,
         },
         Module: {
           Id: module,
-          Tags: (await mem.get("txs", module))?.tags ?? [],
+          Tags: (await mem.getTx(module))?.tags ?? [],
         },
       }
     }
@@ -124,7 +124,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
           format,
           WeaveDrive: wdrive,
           spawn: item,
-          module: await mem.get("txs", mod),
+          module: await mem.getTx(mod),
         })
       } catch (e) {}
       if (!handle) return null
@@ -136,7 +136,6 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
       let memory = opt.memory ?? null
       let p = {
         extension: ext,
-        item: item?.binary,
         format,
         id: id,
         epochs: [],
@@ -146,10 +145,8 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         memory,
         owner,
         height: 0,
-        res: { [id]: res },
+        //res: { [id]: res },
         results: [id],
-        txs: [],
-        opt,
       }
       if (memory) {
         // forking...
@@ -166,11 +163,12 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         res = await _module.handle(null, msg, _env)
         p.memory = res.Memory
         delete res.Memory
-        p.res[id] = res
+        //p.res[id] = res
       } else {
         p.height += 1
       }
-      await mem.set(opt, "msgs", id)
+      const _msg = { ...o(dissoc("signer"), dissoc("memory"))(opt), res }
+      await mem.set(_msg, "msgs", id)
       if (_tags["Cron-Interval"]) {
         let [num, unit] = _tags["Cron-Interval"].split("-")
         let int = 0
@@ -221,7 +219,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
 
     const assign = async opt => {
       const p = await mem.get("env", opt.process)
-      if (!p) return null
+      if (!p || !opt.process) return null
       let _opt = await mem.get("msgs", opt.message)
       let hash = genHashChain(p.hash, opt.message)
       p.hash = hash
@@ -285,19 +283,19 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
           p.handle = await AoLoader(wasm, {
             format,
             WeaveDrive: wdrive,
-            spawn: new DataItem(p.item),
-            module: await mem.get("txs", mod),
+            spawn: (await mem.getTx(p.id)).item,
+            module: await mem.getTx(mod),
           })
           mem.env[opt.process].handle = p.handle
         }
         const res = await p.handle(p.memory, msg, _env)
         p.memory = res.Memory
         delete res.Memory
-        p.res[opt.message] = res
+        //p.res[opt.message] = res
         p.results.push(opt.message)
-        p.txs.unshift({ id, ...opt })
         await mem.set(p, "env", opt.process)
-        await mem.set(_opt, "msgs", opt.message)
+        const _msg = { ...dissoc("signer", _opt), res }
+        await mem.set(_msg, "msgs", opt.message)
         for (const v of res.Messages ?? []) {
           if (await mem.get("env", v.Target)) {
             await message({
@@ -361,7 +359,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         if (opt.for) {
           opt.tags.push({ name: "Pushed-For", value: opt.for })
           opt.tags.push({ name: "From-Process", value: opt.from })
-          const pr = (await mem.get("txs", opt.from))?.tags ?? []
+          const pr = (await mem.getTx(opt.from))?.tags ?? []
           const module = tags(pr).Module
           if (module) opt.tags.push({ name: "From-Module", value: module })
         }
@@ -372,7 +370,8 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
           target: opt.process,
         }))
       }
-      await mem.set(opt, "msgs", id)
+      const _msg = dissoc("signer", opt)
+      await mem.set(_msg, "msgs", id)
       await assign({
         message_item: item,
         message: id,
@@ -408,20 +407,22 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
       spawn,
       assign,
       ar,
-      result: async opt =>
-        (await mem.get("env", opt.process))?.res[opt.message],
+      result: async opt => (await mem.get("msgs", opt.message))?.res,
       results: async opt => {
         const p = await mem.get("env", opt.process)
         let results = []
         const limit = opt.limit ?? 25
         if (opt.sort === "DESC") {
           for (let i = p.results.length - 1; 0 < i; i--) {
-            results.push({ cursor: p.results[i], node: p.res[p.results[i]] })
+            results.push({
+              cursor: p.results[i],
+              node: await this.result(p.results[i]),
+            })
             if (results.length >= limit) break
           }
         } else {
           for (let i = 0; i < p.results.length; i++) {
-            results.push({ node: p.res[p.results[i]] })
+            results.push({ node: await this.result(p.results[i]) })
             if (results.length >= limit) break
           }
         }
@@ -464,8 +465,8 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
             p.handle = await AoLoader(wasm, {
               format,
               WeaveDrive: wdrive,
-              spawn: new DataItem(p.item),
-              module: await mem.get("txs", mod),
+              spawn: (await mem.getTx(p.id)).item,
+              module: await mem.getTx(mod),
             })
             mem.env[opt.process].handle = p.handle
           }

package/esm/armem-base.js

@@ -1,12 +1,27 @@
 import _Arweave from "arweave"
 const Arweave = _Arweave.default ?? _Arweave
-
-import { last } from "ramda"
+import { Bundle } from "arbundles"
+import { compress, decompress } from "./compress.js"
+import { last, assoc, is } from "ramda"
 import { buildTags, tags } from "./utils.js"
+import base64url from "base64url"
 
 export default class ArMemBase {
-  constructor({ MU_URL, CU_URL, SU_URL, GATEWAY_URL, scheduler, cache } = {}) {
+  constructor({
+    MU_URL,
+    CU_URL,
+    SU_URL,
+    GATEWAY_URL,
+    scheduler,
+    cache,
+    init,
+    Compressor,
+    Decompressor,
+  } = {}) {
     this.__type__ = "mem"
+    this._init = init
+    this.Compressor = Compressor
+    this.Decompressor = Decompressor
     this.isInit = false
     this.keyInit = false
     this.keys = {}
@@ -16,6 +31,11 @@ export default class ArMemBase {
     this.scheduler = scheduler
     this.SU_URL = SU_URL
   }
+  async owner(di) {
+    return base64url.encode(
+      Buffer.from(await crypto.subtle.digest("SHA-256", di.rawOwner)),
+    )
+  }
   getAnchor() {
     return this.blocks.length === 0
       ? "Do_Uc2Sju_ffp6Ev0AnLVdPtot15rvMjP-a9VVaA5fM"
@@ -34,13 +54,28 @@ export default class ArMemBase {
     } else {
       this[key] ??= {}
       this[key][field] = val
-      if (this.db) await this.db.put(`${key}.${field}`, this[key][field])
+      if (this.db) {
+        if (key === "env") {
+          let memory = val.memory
+          try {
+            memory = Array.from(this.compressor.compress(val.memory))
+          } catch (e) {
+            memory = compress(val.memory)
+          }
+          await this.db.put(
+            `${key}.${field}`,
+            assoc("memory", memory, this[key][field]),
+          )
+        } else {
+          await this.db.put(`${key}.${field}`, this[key][field])
+        }
+      }
     }
   }
   initSync() {
+    this.items = {}
     this.addrmap = {}
     this.txs = {}
-    this.jwks = {}
     this.blocks = []
     this.blockmap = {}
     this.env = {}
@@ -118,11 +153,14 @@ export default class ArMemBase {
   async init() {
     if (this.isInit) return
     this.isInit = true
+    if (typeof this._init === "function") await this._init()
+    this.compressor = new this.Compressor()
+    this.decompressor = new this.Decompressor()
     if (this.db) {
       for (const v of ["height", "blocks"]) this[v] = await this.get(v)
       for (const v of [
+        "items",
         "txs",
-        "jwks",
         "env",
         "modules",
         "wasms",
@@ -136,7 +174,21 @@ export default class ArMemBase {
         for (const v2 of items || []) {
           const key = v2.split(".")[0]
           const field = v2.split(".")[1]
-          if (key === v) this[v][field] = await this.db.get(v2)
+          if (key === v) {
+            if (key.match(/^env/)) {
+              let v3 = await this.db.get(v2)
+              if (is(Array, v3.memory)) {
+                try {
+                  v3.memory = this.decompressor.decompress(v3.memory)
+                } catch (e) {
+                  v3.memory = decompress(v3.memory)
+                }
+              }
+              this[v][field] = v3
+            } else {
+              this[v][field] = await this.db.get(v2)
+            }
+          }
         }
       }
     } else {
@@ -146,6 +198,36 @@ export default class ArMemBase {
       }
     }
   }
+  async getTx(id) {
+    let tx = this.txs[id]
+    if (tx.bundle) {
+      try {
+        let bundle = new Bundle(this.txs[tx.bundle].data)
+        for (let di of bundle.items) {
+          if (id === di.id) {
+            const data = di.data
+            const data_size = Buffer.byteLength(di.rawData).toString()
+            let data_type = ""
+            for (const t of di.tags)
+              if (t.name === "Content-Type") data_type = t.value
+            const owner = await this.owner(di)
+            tx = {
+              _data: { size: data_size, type: data_type },
+              anchor: di.anchor,
+              signature: di.signature,
+              recipient: di.target,
+              id: await di.id,
+              item: di,
+              owner,
+              tags: di.tags,
+              data,
+            }
+          }
+        }
+      } catch (e) {}
+    }
+    return tx
+  }
   async getWasm(module) {
     let mod = module ?? this.modules.aos2_0_1
     if (!mod) throw Error("module not found")
@@ -157,15 +239,13 @@ export default class ArMemBase {
         wasm = await this._getWasm(this.wasms[mod].file)
         format = _wasm.format
       } else {
-        const tx = await this.get("txs", mod)
+        const tx = await this.getTx(mod)
         if (tx) {
           wasm = Buffer.from(tx.data, "base64")
           format = tags(tx.tags)["Module-Format"]
         }
       }
-    } else {
-      format = _wasm.format
-    }
+    } else format = _wasm.format
     format ??= "wasm64-unknown-emscripten-draft_2024_02_15"
     return { format, mod, wasm }
   }

package/esm/armem-web.js

@@ -1,10 +1,11 @@
 import wdb from "./lua/weavedb-lite.js"
 import Base from "./armem-base.js"
 import db from "./lfdb.js"
+import init, { Compressor, Decompressor } from "./waosm/waosm.js"
 
 export default class ArMem extends Base {
   constructor(args = {}) {
-    super(args)
+    super({ ...args, init, Compressor, Decompressor })
     this.db = db(this)
     this.initSync()
   }

package/esm/armem.js

@@ -5,11 +5,12 @@ import { open } from "lmdb"
 import { readFileSync } from "fs"
 import { resolve } from "path"
 import Base from "./armem-base.js"
+import { Compressor, Decompressor } from "./waosm-node.js"
 
 export default class ArMem extends Base {
   constructor(args = {}) {
     const { cache } = args
-    super(args)
+    super({ ...args, Compressor, Decompressor })
     if (cache) this.db = open({ path: cache, compression: true })
     this.initSync()
   }