@fireproof/core 0.14.8 → 0.15.0-dev

package/dist/memory/fireproof.esm.js

@@ -11337,7 +11337,7 @@ var parse2 = (data) => decode16(utf8Encoder.encode(data));
 var utf8Encoder = new TextEncoder();
 
 // src/version.ts
-var PACKAGE_VERSION = "0.14.8";
+var PACKAGE_VERSION = "0.15.0-dev";
 
 // src/store.ts
 var match = PACKAGE_VERSION.match(/^([^.]*\.[^.]*)/);
@@ -11365,9 +11365,9 @@ var MetaStore = class extends VersionedStore {
 var DataStore = class {
   tag = "car-base";
   STORAGE_VERSION = STORAGE_VERSION;
-  loader;
-  constructor(loader) {
-    this.loader = loader;
+  name;
+  constructor(name8) {
+    this.name = name8;
   }
 };
 
@@ -11538,11 +11538,11 @@ var DataStore2 = class extends DataStore {
     this.store.delete(cid.toString());
   }
 };
-var RemoteWAL2 = class extends RemoteWAL {
-  tag = "wal-mem";
+var MetaStore2 = class extends MetaStore {
+  tag = "header-mem";
   store = /* @__PURE__ */ new Map();
   headerKey(branch) {
-    return `fp.${this.STORAGE_VERSION}.wal.${this.loader.name}.${branch}`;
+    return `fp.${this.STORAGE_VERSION}.meta.${this.name}.${branch}`;
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async load(branch = "main") {
@@ -11550,27 +11550,28 @@ var RemoteWAL2 = class extends RemoteWAL {
       const bytesString = this.store.get(this.headerKey(branch));
       if (!bytesString)
         return null;
-      return parse2(bytesString);
+      return [this.parseHeader(bytesString)];
     } catch (e) {
       return null;
     }
   }
   // eslint-disable-next-line @typescript-eslint/require-await
-  async save(state, branch = "main") {
+  async save(meta, branch = "main") {
     try {
-      const encoded = format3(state);
-      this.store.set(this.headerKey(branch), encoded);
+      const headerKey = this.headerKey(branch);
+      const bytes = this.makeHeader(meta);
+      this.store.set(headerKey, bytes);
+      return null;
     } catch (e) {
-      console.error("error saving wal", e);
-      throw e;
+      return null;
     }
   }
 };
-var MetaStore2 = class extends MetaStore {
-  tag = "header-mem";
+var RemoteWAL2 = class extends RemoteWAL {
+  tag = "wal-mem";
   store = /* @__PURE__ */ new Map();
   headerKey(branch) {
-    return `fp.${this.STORAGE_VERSION}.meta.${this.name}.${branch}`;
+    return `fp.${this.STORAGE_VERSION}.wal.${this.loader.name}.${branch}`;
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async load(branch = "main") {
@@ -11578,20 +11579,19 @@ var MetaStore2 = class extends MetaStore {
       const bytesString = this.store.get(this.headerKey(branch));
       if (!bytesString)
         return null;
-      return [this.parseHeader(bytesString)];
+      return parse2(bytesString);
     } catch (e) {
       return null;
     }
   }
   // eslint-disable-next-line @typescript-eslint/require-await
-  async save(meta, branch = "main") {
+  async save(state, branch = "main") {
     try {
-      const headerKey = this.headerKey(branch);
-      const bytes = this.makeHeader(meta);
-      this.store.set(headerKey, bytes);
-      return null;
+      const encoded = format3(state);
+      this.store.set(this.headerKey(branch), encoded);
     } catch (e) {
-      return null;
+      console.error("error saving wal", e);
+      throw e;
     }
   }
 };
@@ -11637,7 +11637,7 @@ var Loader = class {
     this.name = name8;
     this.opts = opts || this.opts;
     this.metaStore = new MetaStore2(this.name);
-    this.carStore = new DataStore2(this);
+    this.carStore = new DataStore2(this.name);
     this.remoteWAL = new RemoteWAL2(this);
     this.ready = Promise.resolve().then(async () => {
       if (!this.metaStore || !this.carStore || !this.remoteWAL)
@@ -20707,7 +20707,7 @@ var DbLoader = class _DbLoader extends Loader {
   fileStore;
   constructor(name8, clock, opts) {
     super(name8, opts);
-    this.fileStore = new DataStore2(this);
+    this.fileStore = new DataStore2(this.name);
     this.clock = clock;
   }
   async _readyForMerge() {
@@ -20912,7 +20912,7 @@ function applyHeadQueue(worker) {
         const task = queue.shift();
         if (!task)
           continue;
-        await worker(task.id, task.newHead, task.prevHead, task.updates);
+        await worker(task.newHead, task.prevHead);
         if (task.updates) {
           allUpdates.push(...task.updates);
         }
@@ -20941,7 +20941,7 @@ function applyHeadQueue(worker) {
 
 // src/crdt-clock.ts
 var CRDTClock = class {
-  // todo: keep the clock of remote and local changes separate, merge on read
+  // todo: track local and remote clocks independently, merge on read
   // that way we can drop the whole remote if we need to
   // should go with making sure the local clock only references locally available blocks on write
   head = [];
@@ -20957,68 +20957,22 @@ var CRDTClock = class {
     this.head = head;
   }
   async applyHead(newHead, prevHead, updates = null) {
-    const taskId = Math.random().toString().slice(2, 8);
     for await (const { updates: updatesAcc, all } of this.applyHeadQueue.push({
-      id: taskId,
-      // tblocks,
       newHead,
       prevHead,
       updates
     })) {
-      ;
-      ((updatesAcc2, all2) => {
-        void Promise.resolve().then(async () => {
-          let intUpdates = updatesAcc2;
-          if (this.watchers.size && !all2) {
-            const changes = await clockChangesSince(this.blocks, this.head, prevHead, {});
-            intUpdates = changes.result;
-          }
-          this.zoomers.forEach((fn) => fn());
-          this.notifyWatchers(intUpdates || []);
-        });
-      })([...updatesAcc], all);
+      this.processUpdates(updatesAcc, all, prevHead);
     }
   }
-  async int_applyHead(taskId, newHead, prevHead) {
-    const ogHead = this.head.sort((a, b) => a.toString().localeCompare(b.toString()));
-    newHead = newHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-    newHead.map(async (cid) => {
-      const got = await this.blocks.get(cid);
-      if (!got) {
-        throw new Error("int_applyHead missing block: " + cid.toString());
-      }
-    });
-    if (ogHead.toString() === newHead.toString()) {
-      return;
+  async processUpdates(updatesAcc, all, prevHead) {
+    let internalUpdates = updatesAcc;
+    if (this.watchers.size && !all) {
+      const changes = await clockChangesSince(this.blocks, this.head, prevHead, {});
+      internalUpdates = changes.result;
     }
-    const ogPrev = prevHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-    if (ogHead.toString() === ogPrev.toString()) {
-      this.setHead(newHead);
-      return;
-    }
-    let head = this.head;
-    const noLoader = false;
-    const withBlocks = async (fn) => {
-      if (!this.blocks)
-        throw new Error("missing blocks");
-      return await this.blocks.transaction(fn, void 0, { noLoader });
-    };
-    await withBlocks(async (tblocks) => {
-      for (const cid of newHead) {
-        try {
-          head = await advance(tblocks, head, cid);
-        } catch (e) {
-          console.error("failed to advance", cid.toString(), e);
-          continue;
-        }
-      }
-      const result = await root(tblocks, head);
-      for (const { cid, bytes } of [...result.additions, ...result.removals]) {
-        tblocks.putSync(cid, bytes);
-      }
-      return { head };
-    });
-    this.setHead(head);
+    this.zoomers.forEach((fn) => fn());
+    this.notifyWatchers(internalUpdates || []);
   }
   notifyWatchers(updates) {
     this.emptyWatchers.forEach((fn) => fn());
@@ -21033,7 +20987,62 @@ var CRDTClock = class {
   onZoom(fn) {
     this.zoomers.add(fn);
   }
+  async int_applyHead(newHead, prevHead) {
+    const ogHead = sortClockHead(this.head);
+    newHead = sortClockHead(newHead);
+    await validateBlocks(newHead, this.blocks);
+    if (compareClockHeads(ogHead, newHead)) {
+      return;
+    }
+    const ogPrev = sortClockHead(prevHead);
+    if (compareClockHeads(ogHead, ogPrev)) {
+      this.setHead(newHead);
+      return;
+    }
+    let head = this.head;
+    const noLoader = false;
+    if (!this.blocks)
+      throw new Error("missing blocks");
+    await this.blocks.transaction(
+      async (tblocks) => {
+        head = await advanceBlocks(newHead, tblocks, head);
+        const result = await root(tblocks, head);
+        for (const { cid, bytes } of [...result.additions, ...result.removals]) {
+          tblocks.putSync(cid, bytes);
+        }
+        return { head };
+      },
+      void 0,
+      { noLoader }
+    );
+    this.setHead(head);
+  }
 };
+function sortClockHead(clockHead) {
+  return clockHead.sort((a, b) => a.toString().localeCompare(b.toString()));
+}
+async function validateBlocks(newHead, blocks) {
+  newHead.map(async (cid) => {
+    const got = await blocks.get(cid);
+    if (!got) {
+      throw new Error("int_applyHead missing block: " + cid.toString());
+    }
+  });
+}
+function compareClockHeads(head1, head2) {
+  return head1.toString() === head2.toString();
+}
+async function advanceBlocks(newHead, tblocks, head) {
+  for (const cid of newHead) {
+    try {
+      head = await advance(tblocks, head, cid);
+    } catch (e) {
+      console.error("failed to advance", cid.toString(), e);
+      continue;
+    }
+  }
+  return head;
+}
 
 // src/crdt.ts
 var CRDT = class {
@@ -21208,6 +21217,9 @@ var Database = class {
     }));
     return { rows, clock: head };
   }
+  async allDocuments() {
+    return this.allDocs();
+  }
   subscribe(listener, updates) {
     if (updates) {
       if (!this._listening) {