@fireproof/core 0.19.11-dev-dryrun → 0.19.11-dev-dryrun2

package/index.global.js

@@ -12058,6 +12058,16 @@ ${end.comment}` : end.comment;
             bin
           };
         }
+        timeOrderedNextId(now) {
+          now = typeof now === "number" ? now : (/* @__PURE__ */ new Date()).getTime();
+          const t = (281474976710656 + now).toString(16).replace(/^1/, "");
+          const bin = this.crypto.randomBytes(10);
+          bin[1] = bin[1] & 240 | (bin[1] | 8 && 11);
+          const hex = Array.from(bin).map((i) => i.toString(16).padStart(2, "0")).join("");
+          return {
+            str: `${t.slice(0, 8)}-${t.slice(8)}-7${hex.slice(0, 3)}-${hex.slice(3, 7)}-${hex.slice(7, 19)}`
+          };
+        }
         start() {
           return Promise.resolve();
         }
@@ -26262,7 +26272,7 @@ You can use close({ resize: true }) to resize header`);
   }
   async function prepareCarFiles(encoder2, threshold, rootBlock, t) {
     const carFiles = [];
-    threshold = threshold || 1e3 * 1e3;
+    threshold = threshold || 128e3 * 8;
     let clonedt = new CarTransaction(t.parent, { add: false, noLoader: false });
     clonedt.putSync(rootBlock.cid, rootBlock.bytes);
     let newsize = blockLength(toCIDBlock(rootBlock));
@@ -26472,7 +26482,8 @@ You can use close({ resize: true }) to resize header`);
         carLog: this.carLog,
         carStore: fstore,
         WALStore: await this.WALStore(),
-        metaStore: await this.metaStore()
+        metaStore: await this.metaStore(),
+        threshold: this.ebOpts.threshold
       };
       return this.commitQueue.enqueue(async () => {
         await this.cacheTransaction(t);
@@ -26979,26 +26990,7 @@ You can use close({ resize: true }) to resize header`);
       if (this.innerGW.subscribe) {
         return this.innerGW.subscribe(url, callback);
       } else {
-        let lastData = void 0;
-        let interval = 100;
-        const fetchData = async () => {
-          const result = await this.innerGW.get(url);
-          if (result.isOk()) {
-            const data = result.Ok();
-            if (!lastData || !data.every((value, index2) => lastData && value === lastData[index2])) {
-              lastData = data;
-              callback(data);
-              interval = 100;
-            } else {
-              interval *= 2;
-            }
-          }
-          timeoutId = setTimeout(fetchData, interval);
-        };
-        let timeoutId = setTimeout(fetchData, interval);
-        return Result.Ok(() => {
-          clearTimeout(timeoutId);
-        });
+        return Result.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
       }
     }
     async delete(url) {
@@ -27016,6 +27008,109 @@ You can use close({ resize: true }) to resize header`);
     }
   };
 
+  // src/blockstore/meta-key-helper.ts
+  init_cement();
+  async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
+    const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
+    if (!crdtEntries.length) {
+      sthis.logger.Debug().Str("byteHeads", new TextDecoder().decode(byteHeads)).Msg("No CRDT entries found");
+      return [];
+    }
+    if (!crdtEntries.map) {
+      sthis.logger.Debug().Str("crdtEntries", JSON.stringify(crdtEntries)).Msg("No data in CRDT entries");
+      return [];
+    }
+    return Promise.all(
+      crdtEntries.map(async (crdtEntry) => {
+        const eventBlock = await decodeEventBlock(base64pad.decode(crdtEntry.data));
+        const dbMeta = parse3(sthis.txt.decode(eventBlock.value.data.dbMeta));
+        return {
+          eventCid: eventBlock.cid,
+          parents: crdtEntry.parents,
+          dbMeta
+        };
+      })
+    );
+  }
+  async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
+    try {
+      sthis.logger.Debug().Str("uri", uri.toString()).Msg("Setting crypto key from gateway meta payload");
+      const keyInfo = await decodeGatewayMetaBytesToDbMeta(sthis, data);
+      if (keyInfo.length) {
+        const dbMeta = keyInfo[0].dbMeta;
+        if (dbMeta.key) {
+          const kb = await getKeyBag(sthis);
+          const keyName = getStoreKeyName(uri);
+          const res = await kb.setNamedKey(keyName, dbMeta.key);
+          if (res.isErr()) {
+            sthis.logger.Debug().Str("keyName", keyName).Str("dbMeta.key", dbMeta.key).Msg("Failed to set named key");
+            throw res.Err();
+          }
+        }
+        sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
+        return Result.Ok(dbMeta);
+      }
+      sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
+      return Result.Ok(void 0);
+    } catch (error) {
+      sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
+      return Result.Err(error);
+    }
+  }
+  async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
+    try {
+      sthis.logger.Debug().Str("uri", uri.toString()).Msg("Adding crypto key to gateway meta payload");
+      const keyName = getStoreKeyName(uri);
+      const kb = await getKeyBag(sthis);
+      const res = await kb.getNamedExtractableKey(keyName, true);
+      if (res.isErr()) {
+        sthis.logger.Error().Str("keyName", keyName).Msg("Failed to get named extractable key");
+        throw res.Err();
+      }
+      const keyData = await res.Ok().extract();
+      const dbMetas = await decodeGatewayMetaBytesToDbMeta(sthis, body);
+      const { dbMeta, parents } = dbMetas[0];
+      const parentLinks = parents.map((p) => CID.parse(p));
+      dbMeta.key = keyData.keyStr;
+      const events = await Promise.all([dbMeta].map((dbMeta2) => createDbMetaEventBlock(sthis, dbMeta2, parentLinks)));
+      const encoded = await encodeEventsWithParents(sthis, events, parentLinks);
+      sthis.logger.Debug().Str("uri", uri.toString()).Msg("Added crypto key to gateway meta payload");
+      return Result.Ok(encoded);
+    } catch (error) {
+      sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
+      return Result.Err(error);
+    }
+  }
+  function getStoreKeyName(url) {
+    const storeKeyName = [url.getParam("localName") || url.getParam("name")];
+    const idx = url.getParam("index");
+    if (idx) {
+      storeKeyName.push(idx);
+    }
+    storeKeyName.push("data");
+    return `@${storeKeyName.join(":")}@`;
+  }
+  async function createDbMetaEventBlock(sthis, dbMeta, parents) {
+    const event = await EventBlock.create(
+      {
+        dbMeta: sthis.txt.encode(format2(dbMeta))
+      },
+      parents
+    );
+    return event;
+  }
+  async function encodeEventsWithParents(sthis, events, parents) {
+    const crdtEntries = events.map((event) => {
+      const base64String = base64pad.encode(event.bytes);
+      return {
+        cid: event.cid.toString(),
+        data: base64String,
+        parents: parents.map((p) => p.toString())
+      };
+    });
+    return sthis.txt.encode(JSON.stringify(crdtEntries));
+  }
+
   // src/blockstore/store.ts
   function guardVersion(url) {
     if (!url.hasParam("version")) {
@@ -27044,6 +27139,9 @@ You can use close({ resize: true }) to resize header`);
     onClosed(fn) {
       this._onClosed.push(fn);
     }
+    async ready() {
+      return;
+    }
     async keyedCrypto() {
       return keyedCryptoFactory(this._url, await this.keybag(), this.sthis);
     }
@@ -27089,18 +27187,87 @@ You can use close({ resize: true }) to resize header`);
       return version;
     }
   };
+  var MetaStoreImpl = class extends BaseStoreImpl {
+    // remote: boolean;
+    constructor(sthis, name6, url, opts) {
+      super(name6, url, { ...opts }, sthis, ensureLogger(sthis, "MetaStoreImpl"));
+      this.storeType = "meta";
+      this.subscribers = /* @__PURE__ */ new Map();
+      this.parents = [];
+      if (
+        /*this.remote && */
+        opts.gateway.subscribe
+      ) {
+        this.onStarted(async () => {
+          this.logger.Debug().Str("url", this.url().toString()).Msg("Subscribing to the gateway");
+          opts.gateway.subscribe?.(this.url(), async (message2) => {
+            this.logger.Debug().Msg("Received message from gateway");
+            const dbMetas = await decodeGatewayMetaBytesToDbMeta(this.sthis, message2);
+            await Promise.all(
+              dbMetas.map((dbMeta) => this.loader?.taskManager?.handleEvent(dbMeta.eventCid, dbMeta.parents, dbMeta.dbMeta))
+            );
+            this.updateParentsFromDbMetas(dbMetas);
+          });
+        });
+      }
+    }
+    updateParentsFromDbMetas(dbMetas) {
+      const cids = dbMetas.map((m) => m.eventCid);
+      const dbMetaParents = dbMetas.flatMap((m) => m.parents);
+      const uniqueParentsMap = new Map([...this.parents, ...cids].map((p) => [p.toString(), p]));
+      const dbMetaParentsSet = new Set(dbMetaParents.map((p) => p.toString()));
+      this.parents = Array.from(uniqueParentsMap.values()).filter((p) => !dbMetaParentsSet.has(p.toString()));
+    }
+    async handleByteHeads(byteHeads) {
+      return await decodeGatewayMetaBytesToDbMeta(this.sthis, byteHeads);
+    }
+    async load() {
+      const branch = "main";
+      const url = await this.gateway.buildUrl(this.url(), branch);
+      if (url.isErr()) {
+        throw this.logger.Error().Result("buildUrl", url).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
+      }
+      const bytes = await this.gateway.get(url.Ok());
+      if (bytes.isErr()) {
+        if (isNotFoundError(bytes)) {
+          return void 0;
+        }
+        throw this.logger.Error().Url(url.Ok()).Result("bytes:", bytes).Msg("gateway get").AsError();
+      }
+      const dbMetas = await this.handleByteHeads(bytes.Ok());
+      await this.loader?.handleDbMetasFromStore(dbMetas.map((m) => m.dbMeta));
+      this.updateParentsFromDbMetas(dbMetas);
+      return dbMetas.map((m) => m.dbMeta);
+    }
+    async save(meta, branch) {
+      branch = branch || "main";
+      this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
+      const event = await createDbMetaEventBlock(this.sthis, meta, this.parents);
+      const bytes = await encodeEventsWithParents(this.sthis, [event], this.parents);
+      const url = await this.gateway.buildUrl(this.url(), branch);
+      if (url.isErr()) {
+        throw this.logger.Error().Err(url.Err()).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
+      }
+      this.parents = [event.cid];
+      const res = await this.gateway.put(url.Ok(), bytes);
+      if (res.isErr()) {
+        throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
+      }
+      return res;
+    }
+    async close() {
+      await this.gateway.close(this.url());
+      this._onClosed.forEach((fn) => fn());
+      return Result.Ok(void 0);
+    }
+    async destroy() {
+      return this.gateway.destroy(this.url());
+    }
+  };
   var DataStoreImpl = class extends BaseStoreImpl {
     // readonly tag: string = "car-base";
     constructor(sthis, name6, url, opts) {
-      super(
-        name6,
-        url,
-        {
-          ...opts
-        },
-        sthis,
-        ensureLogger(sthis, "DataStoreImpl")
-      );
+      super(name6, url, { ...opts }, sthis, ensureLogger(sthis, "DataStoreImpl"));
       this.storeType = "data";
     }
     async load(cid) {
@@ -27146,46 +27313,43 @@ You can use close({ resize: true }) to resize header`);
   };
   var WALStoreImpl = class extends BaseStoreImpl {
     constructor(loader, url, opts) {
-      super(
-        loader.name,
-        url,
-        {
-          ...opts
-        },
-        loader.sthis,
-        ensureLogger(loader.sthis, "WALStoreImpl")
-      );
+      super(loader.name, url, { ...opts }, loader.sthis, ensureLogger(loader.sthis, "WALStoreImpl"));
       this.storeType = "wal";
       this._ready = new ResolveOnce();
       this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
       this.processing = void 0;
       this.processQueue = new CommitQueue();
-      this.ready = async () => {
-        return this._ready.once(async () => {
-          const walState = await this.load().catch((e) => {
-            this.logger.Error().Any("error", e).Msg("error loading wal");
-            return void 0;
-          });
-          if (!walState) {
-            this.walState.operations = [];
-            this.walState.fileOperations = [];
-          } else {
-            this.walState.operations = walState.operations || [];
-            this.walState.fileOperations = walState.fileOperations || [];
-          }
-        });
-      };
       this.loader = loader;
     }
+    async ready() {
+      return this._ready.once(async () => {
+        const walState = await this.load().catch((e) => {
+          this.logger.Error().Any("error", e).Msg("error loading wal");
+          return void 0;
+        });
+        if (!walState) {
+          this.walState.operations = [];
+          this.walState.fileOperations = [];
+        } else {
+          this.walState.operations = walState.operations || [];
+          this.walState.fileOperations = walState.fileOperations || [];
+        }
+      });
+    }
     async enqueue(dbMeta, opts) {
       await this.ready();
-      if (opts.noLoader) {
+      if (opts.compact) {
+        this.walState.operations = [];
+        this.walState.noLoaderOps = [dbMeta];
+      } else if (opts.noLoader) {
         this.walState.noLoaderOps.push(dbMeta);
       } else {
         this.walState.operations.push(dbMeta);
       }
       await this.save(this.walState);
-      void this.process();
+      if (!opts.noLoader) {
+        void this.process();
+      }
     }
     async enqueueFile(fileCid, publicFile = false) {
       await this.ready();
@@ -27212,7 +27376,7 @@ You can use close({ resize: true }) to resize header`);
         const fileOperations = [...this.walState.fileOperations];
         const uploads = [];
         const noLoaderOps = [...this.walState.noLoaderOps];
-        const limit = pLimit(5);
+        const limit = pLimit(3);
         if (operations.length + fileOperations.length + noLoaderOps.length === 0) return;
         for (const dbMeta of noLoaderOps) {
           const uploadP = limit(async () => {
@@ -27319,259 +27483,6 @@ You can use close({ resize: true }) to resize header`);
     }
   };
 
-  // src/blockstore/store-meta.ts
-  init_cement();
-  init_utils();
-
-  // src/runtime/index.ts
-  var runtime_exports = {};
-  __export(runtime_exports, {
-    FILESTORE_VERSION: () => FILESTORE_VERSION,
-    INDEXDB_VERSION: () => INDEXDB_VERSION,
-    files: () => files_exports,
-    getFileName: () => getFileName,
-    getFileSystem: () => getFileSystem,
-    getPath: () => getPath,
-    kb: () => key_bag_exports,
-    kc: () => keyed_crypto_exports,
-    mf: () => wait_pr_multiformats_exports,
-    runtimeFn: () => runtimeFn,
-    toArrayBuffer: () => toArrayBuffer
-  });
-  init_utils2();
-
-  // src/runtime/wait-pr-multiformats/index.ts
-  var wait_pr_multiformats_exports = {};
-  __export(wait_pr_multiformats_exports, {
-    block: () => block_exports,
-    codec: () => codec_interface_exports
-  });
-
-  // src/runtime/wait-pr-multiformats/codec-interface.ts
-  var codec_interface_exports = {};
-
-  // src/runtime/index.ts
-  init_cement();
-
-  // src/runtime/gateways/file/version.ts
-  var FILESTORE_VERSION = "v0.19-file";
-
-  // src/runtime/index.ts
-  init_version();
-
-  // src/blockstore/store-meta.ts
-  async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
-    const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
-    return Promise.all(
-      crdtEntries.map(async (crdtEntry) => {
-        const eventBlock = await decodeEventBlock(decodeFromBase64(crdtEntry.data));
-        const dbMeta = parse3(sthis.txt.decode(eventBlock.value.data.dbMeta));
-        return {
-          eventCid: eventBlock.cid,
-          parents: crdtEntry.parents,
-          dbMeta
-        };
-      })
-    );
-  }
-  async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
-    try {
-      sthis.logger.Debug().Str("uri", uri.toString()).Msg("Setting crypto key from gateway meta payload");
-      const keyInfo = await decodeGatewayMetaBytesToDbMeta(sthis, data);
-      if (keyInfo.length) {
-        const dbMeta = keyInfo[0].dbMeta;
-        if (dbMeta.key) {
-          const kb = await key_bag_exports.getKeyBag(sthis);
-          const keyName = getStoreKeyName(uri);
-          const res = await kb.setNamedKey(keyName, dbMeta.key);
-          if (res.isErr()) {
-            sthis.logger.Debug().Str("keyName", keyName).Str("dbMeta.key", dbMeta.key).Msg("Failed to set named key");
-            throw res.Err();
-          }
-        }
-        sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
-        return Result.Ok(dbMeta);
-      }
-      sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
-      return Result.Ok(void 0);
-    } catch (error) {
-      sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
-      return Result.Err(error);
-    }
-  }
-  async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
-    try {
-      sthis.logger.Debug().Str("uri", uri.toString()).Msg("Adding crypto key to gateway meta payload");
-      const keyName = getStoreKeyName(uri);
-      const kb = await key_bag_exports.getKeyBag(sthis);
-      const res = await kb.getNamedExtractableKey(keyName, true);
-      if (res.isErr()) {
-        sthis.logger.Error().Str("keyName", keyName).Msg("Failed to get named extractable key");
-        throw res.Err();
-      }
-      const keyData = await res.Ok().extract();
-      const dbMetas = await decodeGatewayMetaBytesToDbMeta(sthis, body);
-      const { dbMeta, parents } = dbMetas[0];
-      const parentLinks = parents.map((p) => CID.parse(p));
-      dbMeta.key = keyData.keyStr;
-      const events = await Promise.all([dbMeta].map((dbMeta2) => createDbMetaEventBlock(sthis, dbMeta2, parentLinks)));
-      const encoded = await encodeEventsWithParents(sthis, events, parentLinks);
-      sthis.logger.Debug().Str("uri", uri.toString()).Msg("Added crypto key to gateway meta payload");
-      return Result.Ok(encoded);
-    } catch (error) {
-      sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
-      return Result.Err(error);
-    }
-  }
-  function getStoreKeyName(url) {
-    const storeKeyName = [url.getParam("localName") || url.getParam("name")];
-    const idx = url.getParam("index");
-    if (idx) {
-      storeKeyName.push(idx);
-    }
-    storeKeyName.push("data");
-    return `@${storeKeyName.join(":")}@`;
-  }
-  async function createDbMetaEventBlock(sthis, dbMeta, parents) {
-    const event = await EventBlock.create(
-      {
-        dbMeta: sthis.txt.encode(format2(dbMeta))
-      },
-      parents
-    );
-    return event;
-  }
-  async function encodeEventsWithParents(sthis, events, parents) {
-    const crdtEntries = events.map((event) => {
-      const base64String = encodeToBase64(event.bytes);
-      return {
-        cid: event.cid.toString(),
-        data: base64String,
-        parents: parents.map((p) => p.toString())
-      };
-    });
-    return sthis.txt.encode(JSON.stringify(crdtEntries));
-  }
-  var MetaStoreImpl = class extends BaseStoreImpl {
-    constructor(sthis, name6, url, opts, remote) {
-      super(
-        name6,
-        url,
-        {
-          ...opts
-        },
-        sthis,
-        ensureLogger(sthis, "MetaStoreImpl")
-      );
-      this.storeType = "meta";
-      this.subscribers = /* @__PURE__ */ new Map();
-      this.parents = [];
-      if (remote && opts.gateway.subscribe) {
-        this.onStarted(async () => {
-          this.logger.Debug().Str("url", this.url().toString()).Msg("Subscribing to the gateway");
-          opts.gateway.subscribe?.(this.url(), async (message2) => {
-            this.logger.Debug().Msg("Received message from gateway");
-            const dbMetas = await decodeGatewayMetaBytesToDbMeta(this.sthis, message2);
-            await Promise.all(
-              dbMetas.map((dbMeta) => this.loader?.taskManager?.handleEvent(dbMeta.eventCid, dbMeta.parents, dbMeta.dbMeta))
-            );
-          });
-        });
-      }
-    }
-    async handleByteHeads(byteHeads) {
-      return await decodeGatewayMetaBytesToDbMeta(this.sthis, byteHeads);
-    }
-    async load() {
-      const branch = "main";
-      const url = await this.gateway.buildUrl(this.url(), branch);
-      if (url.isErr()) {
-        throw this.logger.Error().Result("buildUrl", url).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
-      }
-      const bytes = await this.gateway.get(url.Ok());
-      if (bytes.isErr()) {
-        if (isNotFoundError(bytes)) {
-          return void 0;
-        }
-        throw this.logger.Error().Url(url.Ok()).Result("bytes:", bytes).Msg("gateway get").AsError();
-      }
-      const dbMetas = await this.handleByteHeads(bytes.Ok());
-      await this.loader?.handleDbMetasFromStore(dbMetas.map((m) => m.dbMeta));
-      const cids = dbMetas.map((m) => m.eventCid);
-      const uniqueParentsMap = new Map([...this.parents, ...cids].map((p) => [p.toString(), p]));
-      this.parents = Array.from(uniqueParentsMap.values());
-      return dbMetas.map((m) => m.dbMeta);
-    }
-    async save(meta, branch) {
-      branch = branch || "main";
-      this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
-      const event = await createDbMetaEventBlock(this.sthis, meta, this.parents);
-      const bytes = await encodeEventsWithParents(this.sthis, [event], this.parents);
-      const url = await this.gateway.buildUrl(this.url(), branch);
-      if (url.isErr()) {
-        throw this.logger.Error().Err(url.Err()).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
-      }
-      const res = await this.gateway.put(url.Ok(), bytes);
-      if (res.isErr()) {
-        throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
-      }
-      await this.loader?.handleDbMetasFromStore([meta]);
-      this.parents = [event.cid];
-      return res;
-    }
-    async close() {
-      await this.gateway.close(this.url());
-      this._onClosed.forEach((fn) => fn());
-      return Result.Ok(void 0);
-    }
-    async destroy() {
-      return this.gateway.destroy(this.url());
-    }
-  };
-  function encodeToBase64(bytes) {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    let base642 = "";
-    let i;
-    for (i = 0; i < bytes.length - 2; i += 3) {
-      base642 += chars[bytes[i] >> 2];
-      base642 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
-      base642 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
-      base642 += chars[bytes[i + 2] & 63];
-    }
-    if (i < bytes.length) {
-      base642 += chars[bytes[i] >> 2];
-      if (i === bytes.length - 1) {
-        base642 += chars[(bytes[i] & 3) << 4];
-        base642 += "==";
-      } else {
-        base642 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
-        base642 += chars[(bytes[i + 1] & 15) << 2];
-        base642 += "=";
-      }
-    }
-    return base642;
-  }
-  function decodeFromBase64(base642) {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    const bytes = new Uint8Array(base642.length * 3 / 4);
-    let i;
-    let j = 0;
-    for (i = 0; i < base642.length; i += 4) {
-      const a = chars.indexOf(base642[i]);
-      const b = chars.indexOf(base642[i + 1]);
-      const c = chars.indexOf(base642[i + 2]);
-      const d = chars.indexOf(base642[i + 3]);
-      bytes[j++] = a << 2 | b >> 4;
-      if (base642[i + 2] !== "=") {
-        bytes[j++] = (b & 15) << 4 | c >> 2;
-      }
-      if (base642[i + 3] !== "=") {
-        bytes[j++] = (c & 3) << 6 | d;
-      }
-    }
-    return bytes.slice(0, j);
-  }
-
   // src/blockstore/store-factory.ts
   init_utils();
   function ensureIsIndex(url, isIndex) {
@@ -27763,7 +27674,13 @@ You can use close({ resize: true }) to resize header`);
     return ds;
   }
   async function RemoteMetaStore(sthis, name6, url, opts) {
-    const ms = new MetaStoreImpl(sthis, name6, url, opts, true);
+    const ms = new MetaStoreImpl(
+      sthis,
+      name6,
+      url,
+      opts
+      /* , true*/
+    );
     await ms.start();
     return ms;
   }
@@ -29650,7 +29567,7 @@ You can use close({ resize: true }) to resize header`);
           queue.sort((a, b) => b.updates ? 1 : -1);
           const task = queue.shift();
           if (!task) continue;
-          await worker(task.newHead, task.prevHead, task.updates !== null).catch((e) => {
+          await worker(task.newHead, task.prevHead, task.updates !== void 0).catch((e) => {
             throw logger.Error().Err(e).Msg("int_applyHead worker error").AsError();
           });
           if (task.updates) {
@@ -29741,6 +29658,7 @@ You can use close({ resize: true }) to resize header`);
       this.zoomers.add(fn);
     }
     async int_applyHead(newHead, prevHead, localUpdates) {
+      const noLoader = !localUpdates;
       const ogHead = sortClockHead(this.head);
       newHead = sortClockHead(newHead);
       if (compareClockHeads(ogHead, newHead)) {
@@ -29751,7 +29669,6 @@ You can use close({ resize: true }) to resize header`);
         this.setHead(newHead);
         return;
       }
-      const noLoader = !localUpdates;
       if (!this.blockstore) {
         throw this.logger.Error().Msg("missing blockstore").AsError();
       }
@@ -29871,8 +29788,7 @@ You can use close({ resize: true }) to resize header`);
         try {
           await Promise.all([this.blockstore.ready(), this.indexBlockstore.ready(), this.clock.ready()]);
         } catch (e) {
-          const ee = e;
-          throw this.logger.Error().Err(e).Msg(`CRDT is not ready: ${ee.stack}`).AsError();
+          throw this.logger.Error().Err(e).Msg(`CRDT is not ready`).AsError();
         }
       });
     }
@@ -29976,7 +29892,7 @@ You can use close({ resize: true }) to resize header`);
       await this.ready();
       this.logger.Debug().Str("id", doc._id).Msg("put");
       const { _id, ...value } = doc;
-      const docId = _id || this.sthis.nextId().str;
+      const docId = _id || this.sthis.timeOrderedNextId().str;
       const result = await this._writeQueue.push({
         id: docId,
         value: {
@@ -30105,12 +30021,48 @@ You can use close({ resize: true }) to resize header`);
     }
   }
 
+  // src/runtime/index.ts
+  var runtime_exports = {};
+  __export(runtime_exports, {
+    FILESTORE_VERSION: () => FILESTORE_VERSION,
+    INDEXDB_VERSION: () => INDEXDB_VERSION,
+    files: () => files_exports,
+    getFileName: () => getFileName,
+    getFileSystem: () => getFileSystem,
+    getPath: () => getPath,
+    kb: () => key_bag_exports,
+    kc: () => keyed_crypto_exports,
+    mf: () => wait_pr_multiformats_exports,
+    runtimeFn: () => runtimeFn,
+    toArrayBuffer: () => toArrayBuffer
+  });
+  init_utils2();
+
+  // src/runtime/wait-pr-multiformats/index.ts
+  var wait_pr_multiformats_exports = {};
+  __export(wait_pr_multiformats_exports, {
+    block: () => block_exports,
+    codec: () => codec_interface_exports
+  });
+
+  // src/runtime/wait-pr-multiformats/codec-interface.ts
+  var codec_interface_exports = {};
+
+  // src/runtime/index.ts
+  init_cement();
+
+  // src/runtime/gateways/file/version.ts
+  var FILESTORE_VERSION = "v0.19-file";
+
+  // src/runtime/index.ts
+  init_version();
+
   // src/index.ts
   init_utils();
 
   // src/version.ts
   var PACKAGE_VERSION = Object.keys({
-    "0.19.11-dev-dryrun": "xxxx"
+    "0.19.11-dev-dryrun2": "xxxx"
   })[0];
   return __toCommonJS(src_exports6);
 })();