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

package/index.js

@@ -6,7 +6,7 @@ import {
   getFileSystem,
   getPath,
   toArrayBuffer
-} from "./chunk-XINRLWR3.js";
+} from "./chunk-WS3YRPIA.js";
 import {
   INDEXDB_VERSION
 } from "./chunk-PB4BKL4O.js";
@@ -24,7 +24,7 @@ import {
   getName,
   getStore,
   isNotFoundError
-} from "./chunk-MAK4D54P.js";
+} from "./chunk-OFGPKRCM.js";
 
 // src/database.ts
 import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
@@ -253,8 +253,8 @@ var UnixFSFileBuilder = class {
 
 // src/blockstore/store.ts
 import pLimit2 from "p-limit";
-import { format, parse } from "@ipld/dag-json";
-import { exception2Result, ResolveOnce as ResolveOnce3, Result as Result4 } from "@adviser/cement";
+import { format as format2, parse as parse2 } from "@ipld/dag-json";
+import { exception2Result, ResolveOnce as ResolveOnce3, Result as Result5 } from "@adviser/cement";
 
 // src/types.ts
 function isFalsy(value) {
@@ -668,14 +668,14 @@ var keyBagProviderFactories = new Map(
     {
       protocol: "file:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderFile } = await import("./key-bag-file-DFMW6ZM6.js");
+        const { KeyBagProviderFile } = await import("./key-bag-file-WADZBHYG.js");
         return new KeyBagProviderFile(url, sthis);
       }
     },
     {
       protocol: "indexdb:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderIndexDB } = await import("./key-bag-indexdb-R2RWGSQ4.js");
+        const { KeyBagProviderIndexDB } = await import("./key-bag-indexdb-PGVAI3FJ.js");
         return new KeyBagProviderIndexDB(url, sthis);
       }
     }
@@ -820,7 +820,7 @@ async function commit(params, t, done, opts = { noLoader: false, compact: false
 }
 async function prepareCarFiles(encoder, 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 = CBW.blockLength(toCIDBlock(rootBlock));
@@ -1032,7 +1032,8 @@ var Loader = class {
       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);
@@ -1540,26 +1541,7 @@ var FragmentGateway = class {
     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 Result3.Ok(() => {
-        clearTimeout(timeoutId);
-      });
+      return Result3.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
     }
   }
   async delete(url) {
@@ -1577,12 +1559,119 @@ var FragmentGateway = class {
   }
 };
 
+// src/blockstore/meta-key-helper.ts
+import { format, parse } from "@ipld/dag-json";
+import { EventBlock, decodeEventBlock } from "@web3-storage/pail/clock";
+import { CID as CID2 } from "multiformats";
+import { base64pad } from "multiformats/bases/base64";
+import { Result as Result4 } from "@adviser/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 = parse(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 Result4.Ok(dbMeta);
+    }
+    sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
+    return Result4.Ok(void 0);
+  } catch (error) {
+    sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
+    return Result4.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) => CID2.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 Result4.Ok(encoded);
+  } catch (error) {
+    sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
+    return Result4.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(format(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")) {
-    return Result4.Err(`missing version: ${url.toString()}`);
+    return Result5.Err(`missing version: ${url.toString()}`);
   }
-  return Result4.Ok(url);
+  return Result5.Ok(url);
 }
 var BaseStoreImpl = class {
   constructor(name, url, opts, sthis, logger) {
@@ -1605,6 +1694,9 @@ var BaseStoreImpl = class {
   onClosed(fn) {
     this._onClosed.push(fn);
   }
+  async ready() {
+    return;
+  }
   async keyedCrypto() {
     return keyedCryptoFactory(this._url, await this.keybag(), this.sthis);
   }
@@ -1650,18 +1742,87 @@ var BaseStoreImpl = class {
     return version;
   }
 };
+var MetaStoreImpl = class extends BaseStoreImpl {
+  // remote: boolean;
+  constructor(sthis, name, url, opts) {
+    super(name, 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 (message) => {
+          this.logger.Debug().Msg("Received message from gateway");
+          const dbMetas = await decodeGatewayMetaBytesToDbMeta(this.sthis, message);
+          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 Result5.Ok(void 0);
+  }
+  async destroy() {
+    return this.gateway.destroy(this.url());
+  }
+};
 var DataStoreImpl = class extends BaseStoreImpl {
   // readonly tag: string = "car-base";
   constructor(sthis, name, url, opts) {
-    super(
-      name,
-      url,
-      {
-        ...opts
-      },
-      sthis,
-      ensureLogger(sthis, "DataStoreImpl")
-    );
+    super(name, url, { ...opts }, sthis, ensureLogger(sthis, "DataStoreImpl"));
     this.storeType = "data";
   }
   async load(cid) {
@@ -1699,7 +1860,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return Result4.Ok(void 0);
+    return Result5.Ok(void 0);
   }
   destroy() {
     return this.gateway.destroy(this.url());
@@ -1707,46 +1868,43 @@ var DataStoreImpl = class extends BaseStoreImpl {
 };
 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 ResolveOnce3();
     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();
@@ -1773,7 +1931,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
       const fileOperations = [...this.walState.fileOperations];
       const uploads = [];
       const noLoaderOps = [...this.walState.noLoaderOps];
-      const limit = pLimit2(5);
+      const limit = pLimit2(3);
       if (operations.length + fileOperations.length + noLoaderOps.length === 0) return;
       for (const dbMeta of noLoaderOps) {
         const uploadP = limit(async () => {
@@ -1849,7 +2007,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
       throw this.logger.Error().Err(bytes.Err()).Msg("error get").AsError();
     }
     try {
-      return bytes && parse(this.sthis.txt.decode(bytes.Ok()));
+      return bytes && parse2(this.sthis.txt.decode(bytes.Ok()));
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("error parse").AsError();
     }
@@ -1861,7 +2019,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     }
     let encoded;
     try {
-      encoded = format(state);
+      encoded = format2(state);
     } catch (e) {
       throw this.logger.Error().Err(e).Any("state", state).Msg("error format").AsError();
     }
@@ -1870,263 +2028,15 @@ var WALStoreImpl = class extends BaseStoreImpl {
       throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
     }
   }
-  async close() {
-    await this.gateway.close(this.url());
-    this._onClosed.forEach((fn) => fn());
-    return Result4.Ok(void 0);
-  }
-  destroy() {
-    return this.gateway.destroy(this.url());
-  }
-};
-
-// src/blockstore/store-meta.ts
-import { format as format2, parse as parse2 } from "@ipld/dag-json";
-import { EventBlock, decodeEventBlock } from "@web3-storage/pail/clock";
-import { CID as CID2 } from "multiformats";
-import { Result as Result5 } from "@adviser/cement";
-
-// 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: () => runtimeFn2,
-  toArrayBuffer: () => toArrayBuffer
-});
-
-// 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
-import { runtimeFn as runtimeFn2 } from "@adviser/cement";
-
-// 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 = parse2(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 Result5.Ok(dbMeta);
-    }
-    sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
-    return Result5.Ok(void 0);
-  } catch (error) {
-    sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
-    return Result5.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) => CID2.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 Result5.Ok(encoded);
-  } catch (error) {
-    sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
-    return Result5.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, name, url, opts, remote) {
-    super(
-      name,
-      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 (message) => {
-          this.logger.Debug().Msg("Received message from gateway");
-          const dbMetas = await decodeGatewayMetaBytesToDbMeta(this.sthis, message);
-          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 Result5.Ok(void 0);
   }
-  async destroy() {
+  destroy() {
     return this.gateway.destroy(this.url());
   }
 };
-function encodeToBase64(bytes) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  let base64 = "";
-  let i;
-  for (i = 0; i < bytes.length - 2; i += 3) {
-    base64 += chars[bytes[i] >> 2];
-    base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
-    base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
-    base64 += chars[bytes[i + 2] & 63];
-  }
-  if (i < bytes.length) {
-    base64 += chars[bytes[i] >> 2];
-    if (i === bytes.length - 1) {
-      base64 += chars[(bytes[i] & 3) << 4];
-      base64 += "==";
-    } else {
-      base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
-      base64 += chars[(bytes[i + 1] & 15) << 2];
-      base64 += "=";
-    }
-  }
-  return base64;
-}
-function decodeFromBase64(base64) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  const bytes = new Uint8Array(base64.length * 3 / 4);
-  let i;
-  let j = 0;
-  for (i = 0; i < base64.length; i += 4) {
-    const a = chars.indexOf(base64[i]);
-    const b = chars.indexOf(base64[i + 1]);
-    const c = chars.indexOf(base64[i + 2]);
-    const d = chars.indexOf(base64[i + 3]);
-    bytes[j++] = a << 2 | b >> 4;
-    if (base64[i + 2] !== "=") {
-      bytes[j++] = (b & 15) << 4 | c >> 2;
-    }
-    if (base64[i + 3] !== "=") {
-      bytes[j++] = (c & 3) << 6 | d;
-    }
-  }
-  return bytes.slice(0, j);
-}
 
 // src/blockstore/store-factory.ts
 function ensureIsIndex(url, isIndex) {
@@ -2291,22 +2201,22 @@ function toStoreRuntime(opts, sthis) {
 registerStoreProtocol({
   protocol: "file:",
   gateway: async (sthis) => {
-    const { FileGateway } = await import("./gateway-VWWKLHUI.js");
+    const { FileGateway } = await import("./gateway-5FCWPX5W.js");
     return new FileGateway(sthis);
   },
   test: async (sthis) => {
-    const { FileTestStore } = await import("./gateway-VWWKLHUI.js");
+    const { FileTestStore } = await import("./gateway-5FCWPX5W.js");
     return new FileTestStore(sthis);
   }
 });
 registerStoreProtocol({
   protocol: "indexdb:",
   gateway: async (sthis) => {
-    const { IndexDBGateway } = await import("./gateway-7OM6OSYK.js");
+    const { IndexDBGateway } = await import("./gateway-H7UD6TNB.js");
     return new IndexDBGateway(sthis);
   },
   test: async (sthis) => {
-    const { IndexDBTestStore } = await import("./gateway-7OM6OSYK.js");
+    const { IndexDBTestStore } = await import("./gateway-H7UD6TNB.js");
     return new IndexDBTestStore(sthis);
   }
 });
@@ -2318,7 +2228,13 @@ async function RemoteDataStore(sthis, name, url, opts) {
   return ds;
 }
 async function RemoteMetaStore(sthis, name, url, opts) {
-  const ms = new MetaStoreImpl(sthis, name, url, opts, true);
+  const ms = new MetaStoreImpl(
+    sthis,
+    name,
+    url,
+    opts
+    /* , true*/
+  );
   await ms.start();
   return ms;
 }
@@ -3018,7 +2934,7 @@ function applyHeadQueue(worker, logger) {
         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) {
@@ -3108,6 +3024,7 @@ var CRDTClock = class {
     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)) {
@@ -3118,7 +3035,6 @@ var CRDTClock = class {
       this.setHead(newHead);
       return;
     }
-    const noLoader = !localUpdates;
     if (!this.blockstore) {
       throw this.logger.Error().Msg("missing blockstore").AsError();
     }
@@ -3237,8 +3153,7 @@ var CRDT = class {
       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();
       }
     });
   }
@@ -3341,7 +3256,7 @@ var Database = class {
     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: {
@@ -3470,9 +3385,38 @@ function makeName(fnString) {
   }
 }
 
+// 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: () => runtimeFn2,
+  toArrayBuffer: () => toArrayBuffer
+});
+
+// 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
+import { runtimeFn as runtimeFn2 } from "@adviser/cement";
+
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.11-dev-dryrun": "xxxx"
+  "0.19.11-dev-dryrun4": "xxxx"
 })[0];
 export {
   CRDT,