wao 0.6.1 → 0.6.3

package/cjs/{kv.js → weavedb.js}

@@ -5,10 +5,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
-var _arweave = _interopRequireDefault(require("arweave"));
-var _utils = require("./utils.js");
-var _ramda = require("ramda");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+var _path = require("path");
+var _fs = require("fs");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
@@ -26,14 +24,28 @@ var CACHE_SZ = 32 * KB;
 var CHUNK_SZ = 128 * MB;
 var NOTIFY_SZ = 512 * MB;
 var log = console.log;
-var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
-  _classCallCheck(this, KV);
-  this.kv = function WeaveDrive(mod, FS) {
+var rand = Math.floor(Math.random() * 1000000).toString();
+var WeaveDB = exports["default"] = /*#__PURE__*/_createClass(function WeaveDB(ar, dir) {
+  var _dir;
+  _classCallCheck(this, WeaveDB);
+  (_dir = dir) !== null && _dir !== void 0 ? _dir : dir = (0, _path.resolve)(import.meta.dirname, ".db");
+  var kv_dir = (0, _path.resolve)(dir, rand);
+  var data_dir = (0, _path.resolve)(kv_dir, "data");
+  var rollup_dir = (0, _path.resolve)(kv_dir, "rollup");
+  for (var _i = 0, _arr = [dir, kv_dir, rollup_dir, data_dir]; _i < _arr.length; _i++) {
+    var v = _arr[_i];
+    if (!(0, _fs.existsSync)(v)) (0, _fs.mkdirSync)(v);
+  }
+  this.ext = function (mod, FS) {
+    var cache = {
+      data: {},
+      rollup: {}
+    };
     return {
       create: function create(id) {
         return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-          var _yield$ar$data$length, _yield$ar$data;
-          var properties, node, bytesLength, stream;
+          var _data$length;
+          var properties, node, data, bytesLength, stream;
           return _regeneratorRuntime().wrap(function _callee$(_context) {
             while (1) switch (_context.prev = _context.next) {
               case 0:
@@ -41,48 +53,13 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                   isDevice: false,
                   contents: null
                 };
-                if (!FS.analyzePath("/data/").exists) FS.mkdir("/data/");
-                node = FS.createFile("/", "data/" + id, properties, true, false); // Set initial parameters
+                if (!FS.analyzePath("/rollup/").exists) FS.mkdir("/rollup/");
+                node = FS.createFile("/", "rollup/" + id, properties, true, false); // Set initial parame
                 _context.next = 5;
                 return ar.data(id);
               case 5:
-                _context.t2 = _yield$ar$data = _context.sent;
-                _context.t1 = _context.t2 === null;
-                if (_context.t1) {
-                  _context.next = 9;
-                  break;
-                }
-                _context.t1 = _yield$ar$data === void 0;
-              case 9:
-                if (!_context.t1) {
-                  _context.next = 13;
-                  break;
-                }
-                _context.t3 = void 0;
-                _context.next = 14;
-                break;
-              case 13:
-                _context.t3 = _yield$ar$data.length;
-              case 14:
-                _context.t4 = _yield$ar$data$length = _context.t3;
-                _context.t0 = _context.t4 !== null;
-                if (!_context.t0) {
-                  _context.next = 18;
-                  break;
-                }
-                _context.t0 = _yield$ar$data$length !== void 0;
-              case 18:
-                if (!_context.t0) {
-                  _context.next = 22;
-                  break;
-                }
-                _context.t5 = _yield$ar$data$length;
-                _context.next = 23;
-                break;
-              case 22:
-                _context.t5 = 0;
-              case 23:
-                bytesLength = _context.t5;
+                data = _context.sent;
+                bytesLength = (_data$length = data === null || data === void 0 ? void 0 : data.length) !== null && _data$length !== void 0 ? _data$length : 0;
                 node.total_size = Number(bytesLength);
                 node.cache = new Uint8Array(0);
                 node.position = 0;
@@ -97,66 +74,141 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                 });
 
                 // Now we have created the file in the emscripten FS, we can open it as a stream
-                stream = FS.open("/data/" + id, "r"); //console.log("JS: Created file: ", id, " fd: ", stream.fd);
+                stream = FS.open("/rollup/" + id, "r"); //console.log("JS: Created file: ", id, " fd: ", stream.fd);
                 return _context.abrupt("return", stream);
-              case 30:
+              case 13:
               case "end":
                 return _context.stop();
             }
           }, _callee);
         }))();
       },
-      open: function open(filename) {
-        var _this = this;
+      createData: function createData(col, doc, val) {
         return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-          var pathCategory, id, stream, _stream;
+          var _data$length2, _data2;
+          var properties, node, data, _readFileSync, col_dir, _data, bytesLength, stream;
           return _regeneratorRuntime().wrap(function _callee2$(_context2) {
             while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                properties = {
+                  isDevice: false,
+                  contents: null
+                };
+                if (!FS.analyzePath("/data/").exists) FS.mkdir("/data/");
+                if (!FS.analyzePath("/data/".concat(col)).exists) FS.mkdir("/data/".concat(col));
+                node = FS.createFile("/", "data/".concat(col, "/").concat(doc), properties, true, false); // Set initial parame
+                data = val;
+                if (!val) {
+                  col_dir = (0, _path.resolve)(data_dir, col);
+                  _data = (_readFileSync = (0, _fs.readFileSync)((0, _path.resolve)(col_dir, "".concat(doc, ".json")), "utf8")) !== null && _readFileSync !== void 0 ? _readFileSync : "";
+                  data = Buffer.from(_data, "utf8");
+                }
+                bytesLength = (_data$length2 = (_data2 = data) === null || _data2 === void 0 ? void 0 : _data2.length) !== null && _data$length2 !== void 0 ? _data$length2 : 0;
+                node.total_size = Number(bytesLength);
+                node.cache = new Uint8Array(0);
+                node.position = 0;
+
+                // Add a function that defers querying the file size until it is asked the first time.
+                Object.defineProperties(node, {
+                  usedBytes: {
+                    get: function get() {
+                      return bytesLength;
+                    }
+                  }
+                });
+
+                // Now we have created the file in the emscripten FS, we can open it as a stream
+                stream = FS.open("/data/" + "".concat(col, "/").concat(doc), "r"); //console.log("JS: Created file: ", id, " fd: ", stream.fd);
+                return _context2.abrupt("return", stream);
+              case 13:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }))();
+      },
+      open: function open(filename, val) {
+        var _this = this;
+        return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+          var pathCategory, id, stream, _stream, col, doc, _stream2, _stream3;
+          return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
               case 0:
                 pathCategory = filename.split("/")[1];
-                id = filename.split("/")[2]; //log("JS: Opening ID: ", id)
-                if (!(pathCategory === "data")) {
-                  _context2.next = 17;
+                if (!(pathCategory === "rollup")) {
+                  _context3.next = 17;
                   break;
                 }
+                //log("JS: Opening ID: ", id)
+                id = filename.split("/")[2];
                 if (!FS.analyzePath(filename).exists) {
-                  _context2.next = 11;
+                  _context3.next = 11;
                   break;
                 }
                 stream = FS.open(filename, "r");
                 if (!stream.fd) {
-                  _context2.next = 7;
+                  _context3.next = 7;
                   break;
                 }
-                return _context2.abrupt("return", stream.fd);
+                return _context3.abrupt("return", stream.fd);
               case 7:
                 console.log("JS: File not found: ", filename);
-                return _context2.abrupt("return", 0);
+                return _context3.abrupt("return", 0);
               case 11:
-                _context2.next = 13;
+                _context3.next = 13;
                 return _this.create(id);
               case 13:
-                _stream = _context2.sent;
-                return _context2.abrupt("return", _stream.fd);
+                _stream = _context3.sent;
+                return _context3.abrupt("return", _stream.fd);
               case 15:
-                _context2.next = 19;
+                _context3.next = 36;
                 break;
               case 17:
+                if (!(pathCategory === "data")) {
+                  _context3.next = 34;
+                  break;
+                }
+                //log("JS: Opening ID: ", id)
+                col = filename.split("/")[2];
+                doc = filename.split("/")[3];
+                if (!FS.analyzePath(filename).exists) {
+                  _context3.next = 28;
+                  break;
+                }
+                _stream2 = FS.open(filename, "r");
+                if (!_stream2.fd) {
+                  _context3.next = 24;
+                  break;
+                }
+                return _context3.abrupt("return", _stream2.fd);
+              case 24:
+                console.log("JS: File not found: ", filename);
+                return _context3.abrupt("return", 0);
+              case 28:
+                _context3.next = 30;
+                return _this.createData(col, doc, val);
+              case 30:
+                _stream3 = _context3.sent;
+                return _context3.abrupt("return", _stream3.fd);
+              case 32:
+                _context3.next = 36;
+                break;
+              case 34:
                 console.log("JS: Invalid path category: ", pathCategory);
-                return _context2.abrupt("return", 0);
-              case 19:
+                return _context3.abrupt("return", 0);
+              case 36:
               case "end":
-                return _context2.stop();
+                return _context3.stop();
             }
-          }, _callee2);
+          }, _callee3);
         }))();
       },
-      read: function read(fd, raw_dst_ptr, raw_length) {
+      read: function read(fd, raw_dst_ptr, raw_length, val) {
         var _this2 = this;
-        return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-          var to_read, dst_ptr, stream, i, bytes_read, chunk_download_sz, to, data, start, end, chunk, response, reader, bytes_until_cache, bytes_until_notify, downloaded_bytes, cache_chunks, _yield$reader$read, done, chunk_bytes, write_length, chunk_to_cache;
-          return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-            while (1) switch (_context3.prev = _context3.next) {
+        return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+          var to_read, dst_ptr, stream, i, bytes_read, chunk_download_sz, to, data, sp, _readFileSync2, col_dir, _data, json, _iterator, _step, _v, _val, _fd, _col_dir, start, end, chunk, response, reader, bytes_until_cache, bytes_until_notify, downloaded_bytes, cache_chunks, _yield$reader$read, done, chunk_bytes, write_length, chunk_to_cache;
+          return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+            while (1) switch (_context4.prev = _context4.next) {
               case 0:
                 to_read = Number(raw_length);
                 dst_ptr = Number(raw_dst_ptr);
@@ -164,7 +216,6 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                 for (i = 0; i < FS.streams.length; i++) {
                   if (FS.streams[i].fd === fd) stream = FS.streams[i];
                 }
-
                 // Satisfy what we can with the cache first
                 bytes_read = _this2.readFromCache(stream, dst_ptr, to_read);
                 stream.position += bytes_read;
@@ -173,19 +224,80 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                 to_read -= bytes_read;
 
                 // Return if we have satisfied the request
+
+                //console.log("KV: Satisfied request with cache. Returning...")
                 if (!(to_read === 0)) {
-                  _context3.next = 11;
+                  _context4.next = 11;
                   break;
                 }
-                return _context3.abrupt("return", bytes_read);
+                return _context4.abrupt("return", bytes_read);
               case 11:
-                //console.log("WeaveDrive: Read from cache: ", bytes_read, " Remaining to read: ", to_read)
+                //console.log("KV: Read from cache: ", bytes_read, " Remaining to read: ", to_read)
                 chunk_download_sz = Math.max(to_read, CACHE_SZ);
                 to = Math.min(stream.node.total_size, stream.position + chunk_download_sz);
-                _context3.next = 15;
+                data = val;
+                if (data) {
+                  _context4.next = 56;
+                  break;
+                }
+                sp = stream.path.split("/");
+                if (!(sp[1] === "data")) {
+                  _context4.next = 22;
+                  break;
+                }
+                col_dir = (0, _path.resolve)(data_dir, sp[2]);
+                _data = (_readFileSync2 = (0, _fs.readFileSync)((0, _path.resolve)(col_dir, "".concat(sp[3], ".json")), "utf8")) !== null && _readFileSync2 !== void 0 ? _readFileSync2 : "";
+                data = Buffer.from(_data, "utf8");
+                _context4.next = 56;
+                break;
+              case 22:
+                _context4.next = 24;
                 return ar.data(stream.node.name);
-              case 15:
-                data = _context3.sent;
+              case 24:
+                data = _context4.sent;
+                _context4.prev = 25;
+                json = JSON.parse(Buffer.from(data).toString());
+                _iterator = _createForOfIteratorHelper(json.diffs);
+                _context4.prev = 28;
+                _iterator.s();
+              case 30:
+                if ((_step = _iterator.n()).done) {
+                  _context4.next = 43;
+                  break;
+                }
+                _v = _step.value;
+                _val = Buffer.from(JSON.stringify(_v.data));
+                _context4.next = 35;
+                return _this2.open("/data/".concat(_v.collection, "/").concat(_v.doc), _val);
+              case 35:
+                _fd = _context4.sent;
+                _col_dir = (0, _path.resolve)(data_dir, _v.collection);
+                if (!(0, _fs.existsSync)(_col_dir)) (0, _fs.mkdirSync)(_col_dir);
+                (0, _fs.writeFileSync)((0, _path.resolve)(_col_dir, "".concat(_v.doc, ".json")), JSON.stringify(_v.data));
+                _context4.next = 41;
+                return _this2.read(_fd, _fd, _val.length, _val);
+              case 41:
+                _context4.next = 30;
+                break;
+              case 43:
+                _context4.next = 48;
+                break;
+              case 45:
+                _context4.prev = 45;
+                _context4.t0 = _context4["catch"](28);
+                _iterator.e(_context4.t0);
+              case 48:
+                _context4.prev = 48;
+                _iterator.f();
+                return _context4.finish(48);
+              case 51:
+                _context4.next = 56;
+                break;
+              case 53:
+                _context4.prev = 53;
+                _context4.t1 = _context4["catch"](25);
+                log(_context4.t1);
+              case 56:
                 // Extract the Range header to determine the start and end of the requested chunk
                 start = 0;
                 end = data.length; // Create a ReadableStream for the requested chunk
@@ -205,24 +317,24 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                 bytes_until_notify = NOTIFY_SZ;
                 downloaded_bytes = 0;
                 cache_chunks = [];
-                _context3.prev = 25;
-              case 26:
+                _context4.prev = 65;
+              case 66:
                 if (!true) {
-                  _context3.next = 44;
+                  _context4.next = 84;
                   break;
                 }
-                _context3.next = 29;
+                _context4.next = 69;
                 return reader.read();
-              case 29:
-                _yield$reader$read = _context3.sent;
+              case 69:
+                _yield$reader$read = _context4.sent;
                 done = _yield$reader$read.done;
                 chunk_bytes = _yield$reader$read.value;
                 if (!done) {
-                  _context3.next = 34;
+                  _context4.next = 74;
                   break;
                 }
-                return _context3.abrupt("break", 44);
-              case 34:
+                return _context4.abrupt("break", 84);
+              case 74:
                 // Update the number of downloaded bytes to be _all_, not just the write length
                 downloaded_bytes += chunk_bytes.length;
                 bytes_until_cache -= chunk_bytes.length;
@@ -231,7 +343,7 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                 // Write bytes from the chunk and update the pointer if necessary
                 write_length = Math.min(chunk_bytes.length, to_read);
                 if (write_length > 0) {
-                  //console.log("WeaveDrive: Writing: ", write_length, " bytes to: ", dst_ptr)
+                  //console.log("KV: Writing: ", write_length, " bytes to: ", dst_ptr)
                   mod.HEAP8.set(chunk_bytes.subarray(0, write_length), dst_ptr);
                   dst_ptr += write_length;
                   bytes_read += write_length;
@@ -240,45 +352,45 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
                 }
                 if (to_read == 0) {
                   // Add excess bytes to our cache
-                  chunk_to_cache = chunk_bytes.subarray(write_length); //console.log("WeaveDrive: Cacheing excess: ", chunk_to_cache.length)
+                  chunk_to_cache = chunk_bytes.subarray(write_length); //console.log("KV: Cacheing excess: ", chunk_to_cache.length)
                   cache_chunks.push(chunk_to_cache);
                 }
                 if (bytes_until_cache <= 0) {
-                  console.log("WeaveDrive: Chunk size reached. Compressing cache...");
+                  console.log("KV: Chunk size reached. Compressing cache...");
                   stream.node.cache = _this2.addChunksToCache(stream.node.cache, cache_chunks);
                   cache_chunks = [];
                   bytes_until_cache = CHUNK_SZ;
                 }
                 if (bytes_until_notify <= 0) {
-                  console.log("WeaveDrive: Downloaded: ", downloaded_bytes / stream.node.total_size * 100, "%");
+                  console.log("KV: Downloaded: ", downloaded_bytes / stream.node.total_size * 100, "%");
                   bytes_until_notify = NOTIFY_SZ;
                 }
-                _context3.next = 26;
+                _context4.next = 66;
                 break;
-              case 44:
-                _context3.next = 49;
+              case 84:
+                _context4.next = 89;
                 break;
-              case 46:
-                _context3.prev = 46;
-                _context3.t0 = _context3["catch"](25);
-                console.error("WeaveDrive: Error reading the stream: ", _context3.t0);
-              case 49:
-                _context3.prev = 49;
+              case 86:
+                _context4.prev = 86;
+                _context4.t2 = _context4["catch"](65);
+                console.error("KV: Error reading the stream: ", _context4.t2);
+              case 89:
+                _context4.prev = 89;
                 reader.releaseLock();
-                return _context3.finish(49);
-              case 52:
+                return _context4.finish(89);
+              case 92:
                 // If we have no cache, or we have not satisfied the full request, we need to download the rest
                 // Rebuild the cache from the new cache chunks
                 stream.node.cache = _this2.addChunksToCache(stream.node.cache, cache_chunks);
 
                 // Update the last read position
                 stream.lastReadPosition = stream.position;
-                return _context3.abrupt("return", bytes_read);
-              case 55:
+                return _context4.abrupt("return", bytes_read);
+              case 95:
               case "end":
-                return _context3.stop();
+                return _context4.stop();
             }
-          }, _callee3, null, [[25, 46, 49, 52]]);
+          }, _callee4, null, [[25, 53], [28, 45, 48, 51], [65, 86, 89, 92]]);
         }))();
       },
       close: function close(fd) {
@@ -291,7 +403,7 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
       readFromCache: function readFromCache(stream, dst_ptr, length) {
         // Check if the cache has been invalidated by a seek
         if (stream.lastReadPosition !== stream.position) {
-          //console.log("WeaveDrive: Invalidating cache for fd: ", stream.fd, " Current pos: ", stream.position, " Last read pos: ", stream.lastReadPosition)
+          //console.log("KV: Invalidating cache for fd: ", stream.fd, " Current pos: ", stream.position, " Last read pos: ", stream.lastReadPosition)
           stream.node.cache = new Uint8Array(0);
           return 0;
         }
@@ -313,20 +425,20 @@ var KV = exports["default"] = /*#__PURE__*/_createClass(function KV(ar) {
         new_cache.set(old_cache, 0);
         // Load the cache chunks into the new cache
         var current_offset = old_cache.length;
-        var _iterator = _createForOfIteratorHelper(chunks),
-          _step;
+        var _iterator2 = _createForOfIteratorHelper(chunks),
+          _step2;
         try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var chunk = _step.value;
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var chunk = _step2.value;
             if (current_offset < new_cache_length) {
               new_cache.set(chunk.subarray(0, new_cache_length - current_offset), current_offset);
               current_offset += chunk.length;
             }
           }
         } catch (err) {
-          _iterator.e(err);
+          _iterator2.e(err);
         } finally {
-          _iterator.f();
+          _iterator2.f();
         }
         return new_cache;
       }

package/cjs/weavedrive.js

@@ -31,7 +31,7 @@ var NOTIFY_SZ = 512 * MB;
 var log = console.log;
 var WeaveDrive = exports["default"] = /*#__PURE__*/_createClass(function WeaveDrive(ar) {
   _classCallCheck(this, WeaveDrive);
-  this.drive = function WeaveDrive(mod, FS) {
+  this.ext = function (mod, FS) {
     return {
       reset: function reset(fd) {
         //console.log("WeaveDrive: Resetting fd: ", fd)
@@ -49,7 +49,7 @@ var WeaveDrive = exports["default"] = /*#__PURE__*/_createClass(function WeaveDr
                 properties = {
                   isDevice: false,
                   contents: null
-                };
+                }; //console.log("WeaveDrive: Arweave ID is not admissable! ", id)
                 _context.next = 3;
                 return _this.checkAdmissible(id);
               case 3:
@@ -98,7 +98,7 @@ var WeaveDrive = exports["default"] = /*#__PURE__*/_createClass(function WeaveDr
       },
       createBlockHeader: function createBlockHeader(id) {
         return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-          var result, block, bytesLength, node, stream;
+          var result, block, node, stream;
           return _regeneratorRuntime().wrap(function _callee2$(_context2) {
             while (1) switch (_context2.prev = _context2.next) {
               case 0:
@@ -117,11 +117,10 @@ var WeaveDrive = exports["default"] = /*#__PURE__*/_createClass(function WeaveDr
                     });
                   }
                 } catch (e) {}
-                bytesLength = result.length;
                 node = FS.createDataFile("/", "block/" + id, Buffer.from(result, "utf-8"), true, false);
                 stream = FS.open("/block/" + id, "r");
                 return _context2.abrupt("return", stream);
-              case 6:
+              case 5:
               case "end":
                 return _context2.stop();
             }
@@ -345,6 +344,8 @@ var WeaveDrive = exports["default"] = /*#__PURE__*/_createClass(function WeaveDr
                 to_read -= bytes_read;
 
                 // Return if we have satisfied the request
+
+                //console.log("WeaveDrive: Satisfied request with cache. Returning...")
                 if (!(to_read === 0)) {
                   _context6.next = 17;
                   break;

package/esm/ao.js

@@ -625,7 +625,7 @@ class AO {
     return await this.pipe({ jwk, fns })
   }
 
-  async wait({ pid, attempts = 5 }) {
+  async wait({ pid, attempts = 10 }) {
     let exist = false
     let err = null
     while (attempts > 0) {

package/esm/aoconnect.js

@@ -16,7 +16,6 @@ import {
 } from "./utils.js"
 import ArMem from "./armem.js"
 import weavedrive from "./weavedrive.js"
-import kv from "./kv.js"
 import AoLoader from "@permaweb/ao-loader"
 import { readFileSync } from "fs"
 import { resolve } from "path"
@@ -24,7 +23,7 @@ import { scheduler, mu, su, cu, acc } from "./test.js"
 import { is, clone, fromPairs, map, mergeLeft, isNil } from "ramda"
 import AR from "./tar.js"
 
-export const connect = (mem, log = false) => {
+export const connect = (mem, { log = false, extensions = {} }) => {
   const isMem = mem?.__type__ === "mem"
   if (!isMem) {
     let args = {}
@@ -35,8 +34,8 @@ export const connect = (mem, log = false) => {
     mem = new ArMem(args)
   }
   const ar = new AR({ mem, log })
-  const WeaveDrive = new weavedrive(ar).drive
-  const KV = new kv(ar).kv
+  for (const k in extensions) extensions[k] = new extensions[k](ar).ext
+  extensions.WeaveDrive = new weavedrive(ar).ext
 
   const transform = input => {
     const output = { Tags: [] }
@@ -152,10 +151,9 @@ export const connect = (mem, log = false) => {
     await ar.postItems(item, su.jwk)
     const now = Date.now
     const t = tags(opt.tags)
-    const wd = t.Extension === "KV" ? KV : WeaveDrive
     const handle = await AoLoader(wasm, {
       format,
-      WeaveDrive: wd,
+      WeaveDrive: extensions[t.Extension],
       spawn: item,
       module: mem.txs[mod],
       blockHeight: "100",

package/esm/lua/weavedb_mock.lua

@@ -0,0 +1,43 @@
+local json = require("json")
+function rollup (id)
+  local file = io.open("/rollup/" .. id)
+  local data = nil
+  if file then data = file:read(file:seek('end')) end
+  file:close()
+  return data
+end
+
+function get (col, doc)
+  local file = io.open("/data/" .. col .. "/" .. doc)
+  local data = nil
+  if file then data = file:read(file:seek('end')) end
+  file:close()
+  return data
+end
+
+Handlers.add(
+  "Rollup",
+  "Rollup",
+  function (msg)
+    msg.reply({ Data = "committed!" })
+  end
+)
+
+Handlers.add(
+  "Finalize",
+  "Finalize",
+  function (msg)
+    local data = json.decode(rollup(msg.TXID))
+    msg.reply({ Data = "finalized!" })
+  end
+)
+
+
+Handlers.add(
+  "Get",
+  "Get",
+  function (msg)
+    msg.reply({ Data = get(msg.col, msg.doc) })
+  end
+)
+

package/esm/server.js

@@ -27,7 +27,7 @@ class Server {
       mem,
       monitor,
       unmonitor,
-    } = connect(aoconnect, log)
+    } = connect(aoconnect, { log })
     this.monitor = monitor
     this.unmonitor = unmonitor
     this.spawn = spawn

package/esm/tao.js

@@ -64,7 +64,7 @@ class AO extends MAO {
       monitor,
       unmonitor,
       mem,
-    } = connect(opt.mem)
+    } = connect(opt.mem, { extensions: opt.extensions })
     this.module = mem.modules.aos2_0_1
     this.assign = assign
     this.result = async (...opt) => {