@fireproof/core 0.19.9-dev-frag → 0.19.11-dev-dryrun

package/index.js

@@ -6,7 +6,7 @@ import {
   getFileSystem,
   getPath,
   toArrayBuffer
-} from "./chunk-JO5AVWG7.js";
+} from "./chunk-XINRLWR3.js";
 import {
   INDEXDB_VERSION
 } from "./chunk-PB4BKL4O.js";
@@ -19,16 +19,15 @@ import {
   ensureLogger,
   ensureSuperLog,
   ensureSuperThis,
-  exception2Result,
   exceptionWrapper,
   getKey,
   getName,
   getStore,
   isNotFoundError
-} from "./chunk-YS4GL6OK.js";
+} from "./chunk-MAK4D54P.js";
 
 // src/database.ts
-import { ResolveOnce as ResolveOnce5 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
 
 // src/write-queue.ts
 function writeQueue(worker, payload = Infinity, unbounded = false) {
@@ -71,7 +70,7 @@ function writeQueue(worker, payload = Infinity, unbounded = false) {
 }
 
 // src/crdt.ts
-import { ResolveOnce as ResolveOnce4 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce5 } from "@adviser/cement";
 
 // src/runtime/wait-pr-multiformats/block.ts
 var block_exports = {};
@@ -145,7 +144,7 @@ async function createUnsafe({
 }
 
 // src/crdt-helpers.ts
-import { parse as parse2 } from "multiformats/link";
+import { parse as parse3 } from "multiformats/link";
 import { sha256 as hasher5 } from "multiformats/hashes/sha2";
 import * as codec from "@ipld/dag-cbor";
 import { put, get, entries, root } from "@web3-storage/pail/crdt";
@@ -162,10 +161,12 @@ __export(blockstore_exports, {
   EncryptedBlockstore: () => EncryptedBlockstore,
   FragmentGateway: () => FragmentGateway,
   Loader: () => Loader,
+  addCryptoKeyToGatewayMetaPayload: () => addCryptoKeyToGatewayMetaPayload,
   ensureStart: () => ensureStart,
   getGatewayFromURL: () => getGatewayFromURL,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
+  setCryptoKeyFromGatewayMetaPayload: () => setCryptoKeyFromGatewayMetaPayload,
   testStoreFactory: () => testStoreFactory,
   toCIDBlock: () => toCIDBlock,
   toStoreRuntime: () => toStoreRuntime
@@ -177,7 +178,7 @@ function toCIDBlock(block) {
 }
 
 // src/blockstore/store-factory.ts
-import { KeyedResolvOnce as KeyedResolvOnce2, URI as URI3 } from "@adviser/cement";
+import { KeyedResolvOnce as KeyedResolvOnce2, URI as URI5 } from "@adviser/cement";
 
 // src/runtime/files.ts
 var files_exports = {};
@@ -253,7 +254,7 @@ var UnixFSFileBuilder = class {
 // src/blockstore/store.ts
 import pLimit2 from "p-limit";
 import { format, parse } from "@ipld/dag-json";
-import { ResolveOnce as ResolveOnce2, Result as Result3 } from "@adviser/cement";
+import { exception2Result, ResolveOnce as ResolveOnce3, Result as Result4 } from "@adviser/cement";
 
 // src/types.ts
 function isFalsy(value) {
@@ -275,7 +276,7 @@ function falsyToUndef(value) {
 // src/blockstore/loader.ts
 import pLimit from "p-limit";
 import { CarReader } from "@ipld/car";
-import { ResolveOnce } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce2 } from "@adviser/cement";
 
 // src/blockstore/loader-helpers.ts
 import { sha256 as hasher } from "multiformats/hashes/sha2";
@@ -547,6 +548,7 @@ __export(key_bag_exports, {
 });
 import {
   KeyedResolvOnce,
+  ResolveOnce,
   ResolveSeq,
   Result as Result2,
   runtimeFn,
@@ -557,21 +559,25 @@ import { base58btc } from "multiformats/bases/base58";
 var KeyBag = class {
   constructor(rt) {
     this.rt = rt;
+    this._warnOnce = new ResolveOnce();
     this._seq = new ResolveSeq();
-    this.logger = ensureLogger(rt.sthis, "KeyBag", {
-      id: rt.id()
-    });
+    this.logger = ensureLogger(rt.sthis, "KeyBag");
     this.logger.Debug().Msg("KeyBag created");
   }
   async subtleKey(key) {
+    const extractable = this.rt.url.getParam("extractKey") === "_deprecated_internal_api";
+    if (extractable) {
+      this._warnOnce.once(
+        () => this.logger.Warn().Msg("extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!")
+      );
+    }
     return await this.rt.crypto.importKey(
       "raw",
       // raw or jwk
       base58btc.decode(key),
       // hexStringToUint8Array(key), // raw data
       "AES-GCM",
-      false,
-      // extractable
+      extractable,
       ["encrypt", "decrypt"]
     );
   }
@@ -620,6 +626,23 @@ var KeyBag = class {
     await bag.set(name, item);
     return await this.toKeyWithFingerPrint(item.key);
   }
+  async getNamedExtractableKey(name, failIfNotFound = false) {
+    const ret = await this.getNamedKey(name, failIfNotFound);
+    if (ret.isErr()) {
+      return ret;
+    }
+    const named = ret.Ok();
+    return Result2.Ok({
+      ...named,
+      extract: async () => {
+        const ext = new Uint8Array(await this.rt.crypto.exportKey("raw", named.key));
+        return {
+          key: ext,
+          keyStr: base58btc.encode(ext)
+        };
+      }
+    });
+  }
   async getNamedKey(name, failIfNotFound = false) {
     const id = this.rt.sthis.nextId(4).str;
     return this._seq.add(async () => {
@@ -645,14 +668,14 @@ var keyBagProviderFactories = new Map(
     {
       protocol: "file:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderFile } = await import("./key-bag-file-NMEBFSPM.js");
+        const { KeyBagProviderFile } = await import("./key-bag-file-DFMW6ZM6.js");
         return new KeyBagProviderFile(url, sthis);
       }
     },
     {
       protocol: "indexdb:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderIndexDB } = await import("./key-bag-indexdb-X5V6GNBZ.js");
+        const { KeyBagProviderIndexDB } = await import("./key-bag-indexdb-R2RWGSQ4.js");
         return new KeyBagProviderIndexDB(url, sthis);
       }
     }
@@ -689,23 +712,11 @@ function defaultKeyBagOpts(sthis, kbo) {
     }
     logger.Debug().Url(url).Msg("from env");
   }
-  let keyProviderFactory;
-  switch (url.protocol) {
-    case "file:":
-      keyProviderFactory = async () => {
-        const { KeyBagProviderFile } = await import("./key-bag-file-NMEBFSPM.js");
-        return new KeyBagProviderFile(url, sthis);
-      };
-      break;
-    case "indexdb:":
-      keyProviderFactory = async () => {
-        const { KeyBagProviderIndexDB } = await import("./key-bag-indexdb-X5V6GNBZ.js");
-        return new KeyBagProviderIndexDB(url, sthis);
-      };
-      break;
-    default:
-      throw logger.Error().Url(url).Msg("unsupported protocol").AsError();
+  const kitem = keyBagProviderFactories.get(url.protocol);
+  if (!kitem) {
+    throw logger.Error().Url(url).Msg("unsupported protocol").AsError();
   }
+  const getBag = async () => kitem.factory(url, sthis);
   if (url.hasParam("masterkey")) {
     throw logger.Error().Url(url).Msg("masterkey is not supported").AsError();
   }
@@ -715,7 +726,7 @@ function defaultKeyBagOpts(sthis, kbo) {
     sthis,
     logger,
     keyLength: kbo.keyLength || 16,
-    getBag: keyProviderFactory,
+    getBag,
     id: () => {
       return url.toString();
     }
@@ -832,6 +843,53 @@ async function prepareCarFiles(encoder, threshold, rootBlock, t) {
 
 // src/blockstore/loader.ts
 import { sha256 as hasher3 } from "multiformats/hashes/sha2";
+
+// src/blockstore/task-manager.ts
+var TaskManager = class {
+  constructor(sthis, callback) {
+    this.eventsWeHandled = /* @__PURE__ */ new Set();
+    this.queue = [];
+    this.isProcessing = false;
+    this.logger = ensureLogger(sthis, "TaskManager");
+    this.callback = callback;
+  }
+  async handleEvent(cid, parents, dbMeta) {
+    for (const parent of parents) {
+      this.eventsWeHandled.add(parent.toString());
+    }
+    this.queue.push({ cid: cid.toString(), dbMeta, retries: 0 });
+    this.queue = this.queue.filter(({ cid: cid2 }) => !this.eventsWeHandled.has(cid2));
+    void this.processQueue();
+  }
+  async processQueue() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    const filteredQueue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
+    const first = filteredQueue[0];
+    if (!first) {
+      return;
+    }
+    try {
+      await this.callback(first.dbMeta);
+      this.eventsWeHandled.add(first.cid);
+      this.queue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
+    } catch (err) {
+      if (first.retries++ > 3) {
+        this.logger.Error().Str("cid", first.cid).Msg("failed to process event block after 3 retries");
+        this.queue = this.queue.filter(({ cid }) => cid !== first.cid);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      throw this.logger.Error().Err(err).Msg("failed to process event block").AsError();
+    } finally {
+      this.isProcessing = false;
+      if (this.queue.length > 0) {
+        void this.processQueue();
+      }
+    }
+  }
+};
+
+// src/blockstore/loader.ts
 function carLogIncludesGroup(list, cids) {
   return list.some((arr) => {
     return arr.toString() === cids.toString();
@@ -856,7 +914,7 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = pLimit(1);
-    this.onceReady = new ResolveOnce();
+    this.onceReady = new ResolveOnce2();
     this.name = name;
     this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
@@ -868,6 +926,9 @@ var Loader = class {
       "Loader"
     );
     this.logger = this.ebOpts.logger;
+    this.taskManager = new TaskManager(sthis, async (dbMeta) => {
+      await this.handleDbMetasFromStore([dbMeta]);
+    });
   }
   // readonly id = uuidv4();
   async keyBag() {
@@ -887,8 +948,10 @@ var Loader = class {
   }
   async ready() {
     return this.onceReady.once(async () => {
-      const metas = this.ebOpts.meta ? [this.ebOpts.meta] : await (await this.metaStore()).load("main");
-      if (metas) {
+      const metas = await (await this.metaStore()).load();
+      if (this.ebOpts.meta) {
+        await this.handleDbMetasFromStore([this.ebOpts.meta]);
+      } else if (metas) {
         await this.handleDbMetasFromStore(metas);
       }
     });
@@ -1193,7 +1256,7 @@ var generateIV = {
     calc: async (ko, crypto, data) => {
       const hash = await hasher4.digest(data);
       const hashBytes = new Uint8Array(hash.bytes);
-      const hashArray = new Uint8Array(ko.ivLength * 8);
+      const hashArray = new Uint8Array(ko.ivLength);
       for (let i = 0; i < hashBytes.length; i++) {
         hashArray[i % ko.ivLength] ^= hashBytes[i];
       }
@@ -1271,7 +1334,7 @@ var keyedCrypto = class {
     };
   }
   async _decrypt(data) {
-    this.logger.Debug().Len(data.bytes).Str("fp", this.key.fingerPrint).Msg("decrypting");
+    this.logger.Debug().Len(data.bytes, "bytes").Len(data.iv, "iv").Str("fp", this.key.fingerPrint).Msg("decrypting");
     return new Uint8Array(await this.crypto.decrypt(this.algo(data.iv), this.key.key, data.bytes));
   }
   async _encrypt(data) {
@@ -1342,6 +1405,7 @@ async function keyedCryptoFactory(url, kb, sthis) {
 }
 
 // src/blockstore/fragment-gateway.ts
+import { Result as Result3 } from "@adviser/cement";
 import { base58btc as base58btc3 } from "multiformats/bases/base58";
 import { encode as encode3, decode as decode3 } from "cborg";
 function getFragSize(url) {
@@ -1364,7 +1428,7 @@ async function getFrags(url, innerGW, headerSize, logger) {
     }
     const data = res.unwrap();
     return [
-      Result.Ok({
+      Result3.Ok({
         fid: new Uint8Array(0),
         ofs: 0,
         len: data.length,
@@ -1378,7 +1442,7 @@ async function getFrags(url, innerGW, headerSize, logger) {
   }
   const firstFragment = decode3(firstRaw.unwrap());
   const blockSize = firstFragment.data.length;
-  const ops = [Promise.resolve(Result.Ok(firstFragment))];
+  const ops = [Promise.resolve(Result3.Ok(firstFragment))];
   const fidStr = base58btc3.encode(firstFragment.fid);
   const fragUrl = url.build().setParam("fid", fidStr).setParam("len", firstFragment.len.toString()).setParam("headerSize", headerSize.toString());
   for (let ofs = blockSize; ofs < firstFragment.len; ofs += blockSize) {
@@ -1390,12 +1454,12 @@ async function getFrags(url, innerGW, headerSize, logger) {
         }
         const fragment = decode3(raw2.unwrap());
         if (base58btc3.encode(fragment.fid) !== fidStr) {
-          return Result.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
+          return Result3.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
         }
         if (fragment.ofs !== ofs2) {
-          return Result.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
+          return Result3.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
         }
-        return Result.Ok(fragment);
+        return Result3.Ok(fragment);
       })(fragUrl.setParam("ofs", ofs.toString()).URI(), ofs)
     );
   }
@@ -1457,42 +1521,68 @@ var FragmentGateway = class {
   }
   async put(url, body) {
     await Promise.all(this.slicer(url, body));
-    return Result.Ok(void 0);
+    return Result3.Ok(void 0);
   }
   async get(url) {
     const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
     let buffer = void 0;
     for (const rfrag of rfrags) {
       if (rfrag.isErr()) {
-        return Result.Err(rfrag.Err());
+        return Result3.Err(rfrag.Err());
       }
       const frag = rfrag.Ok();
       buffer = buffer || new Uint8Array(frag.len);
       buffer.set(frag.data, frag.ofs);
     }
-    return Result.Ok(buffer || new Uint8Array(0));
+    return Result3.Ok(buffer || new Uint8Array(0));
+  }
+  async subscribe(url, callback) {
+    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);
+      });
+    }
   }
   async delete(url) {
     const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
     for (const rfrag of rfrags) {
       if (rfrag.isErr()) {
-        return Result.Err(rfrag.Err());
+        return Result3.Err(rfrag.Err());
       }
       const frag = rfrag.Ok();
       const fidStr = base58btc3.encode(frag.fid);
       const fragUrl = url.build().setParam("fid", fidStr).setParam("len", frag.len.toString()).setParam("headerSize", this.headerSize.toString()).URI();
       await this.innerGW.delete(fragUrl);
     }
-    return Result.Ok(void 0);
+    return Result3.Ok(void 0);
   }
 };
 
 // src/blockstore/store.ts
 function guardVersion(url) {
   if (!url.hasParam("version")) {
-    return Result3.Err(`missing version: ${url.toString()}`);
+    return Result4.Err(`missing version: ${url.toString()}`);
   }
-  return Result3.Ok(url);
+  return Result4.Ok(url);
 }
 var BaseStoreImpl = class {
   constructor(name, url, opts, sthis, logger) {
@@ -1504,6 +1594,7 @@ var BaseStoreImpl = class {
     this.sthis = sthis;
     this.logger = logger.With().Ref("url", () => this._url.toString()).Str("name", name).Logger();
     this.gateway = new FragmentGateway(this.sthis, opts.gateway);
+    this.loader = opts.loader;
   }
   url() {
     return this._url;
@@ -1559,102 +1650,6 @@ var BaseStoreImpl = class {
     return version;
   }
 };
-var MetaStoreImpl = class extends BaseStoreImpl {
-  constructor(sthis, name, url, opts) {
-    super(
-      name,
-      url,
-      {
-        ...opts
-      },
-      sthis,
-      ensureLogger(sthis, "MetaStoreImpl")
-    );
-    this.storeType = "meta";
-    this.subscribers = /* @__PURE__ */ new Map();
-  }
-  onLoad(branch, loadHandler) {
-    const subscribers = this.subscribers.get(branch) || [];
-    subscribers.push(loadHandler);
-    this.subscribers.set(branch, subscribers);
-    return () => {
-      const subscribers2 = this.subscribers.get(branch) || [];
-      const idx = subscribers2.indexOf(loadHandler);
-      if (idx > -1) subscribers2.splice(idx, 1);
-    };
-  }
-  makeHeader({ cars }) {
-    const toEncode = { cars };
-    return format(toEncode);
-  }
-  parseHeader(headerData) {
-    const got = parse(headerData);
-    return got;
-  }
-  async handleSubscribers(dbMetas, branch) {
-    try {
-      const subscribers = this.subscribers.get(branch) || [];
-      await Promise.all(subscribers.map((subscriber) => subscriber(dbMetas)));
-    } catch (e) {
-      this.logger.Error().Err(e).Msg("handleSubscribers").AsError();
-    }
-  }
-  async handleByteHeads(byteHeads, branch = "main") {
-    let dbMetas;
-    try {
-      dbMetas = this.dbMetasForByteHeads(byteHeads);
-    } catch (e) {
-      throw this.logger.Error().Err(e).Msg("parseHeader").AsError();
-    }
-    await this.handleSubscribers(dbMetas, branch);
-    return dbMetas;
-  }
-  dbMetasForByteHeads(byteHeads) {
-    return byteHeads.map((bytes) => {
-      const txt = this.sthis.txt.decode(bytes);
-      return this.parseHeader(txt);
-    });
-  }
-  async load(branch) {
-    branch = branch || "main";
-    this.logger.Debug().Str("branch", branch).Msg("loading");
-    const url = await this.gateway.buildUrl(this.url(), branch);
-    if (url.isErr()) {
-      throw this.logger.Error().Result("buidUrl", 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();
-    }
-    return this.handleByteHeads([bytes.Ok()], branch);
-  }
-  async save(meta, branch) {
-    branch = branch || "main";
-    this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
-    const bytes = this.makeHeader(meta);
-    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(), this.sthis.txt.encode(bytes));
-    if (res.isErr()) {
-      throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
-    }
-    await this.handleSubscribers([meta], branch);
-    return res;
-  }
-  async close() {
-    await this.gateway.close(this.url());
-    this._onClosed.forEach((fn) => fn());
-    return Result3.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) {
@@ -1704,7 +1699,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return Result3.Ok(void 0);
+    return Result4.Ok(void 0);
   }
   destroy() {
     return this.gateway.destroy(this.url());
@@ -1722,7 +1717,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
       ensureLogger(loader.sthis, "WALStoreImpl")
     );
     this.storeType = "wal";
-    this._ready = new ResolveOnce2();
+    this._ready = new ResolveOnce3();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
@@ -1878,13 +1873,261 @@ var WALStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return Result3.Ok(void 0);
+    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() {
+    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) {
   if (isIndex) {
@@ -1904,10 +2147,10 @@ function buildURL(optURL, loader) {
   const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
   let obuUrl;
   if (obuItem && obuItem.overrideBaseURL) {
-    obuUrl = URI3.from(obuItem.overrideBaseURL);
+    obuUrl = URI5.from(obuItem.overrideBaseURL);
   }
   const ret = ensureIsIndex(
-    URI3.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
+    URI5.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
     storeOpts.isIndex
   );
   return ret;
@@ -1954,52 +2197,61 @@ function registerStoreProtocol(item) {
     storeFactory.delete(protocol);
   };
 }
+var onceDataStoreFactory = new KeyedResolvOnce2();
 async function dataStoreFactory(loader) {
   const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.data, loader)).build().setParam("store", "data").URI();
   const sthis = ensureSuperLog(loader.sthis, "dataStoreFactory", { url: url.toString() });
-  const gateway = await getGatewayFromURL(url, sthis);
-  if (!gateway) {
-    throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-  }
-  const store = new DataStoreImpl(sthis, loader.name, url, {
-    gateway: gateway.gateway,
-    keybag: () => getKeyBag(loader.sthis, {
-      ...loader.ebOpts.keyBag
-    })
+  return onceDataStoreFactory.get(url.toString()).once(async () => {
+    const gateway = await getGatewayFromURL(url, sthis);
+    if (!gateway) {
+      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
+    }
+    const store = new DataStoreImpl(sthis, loader.name, url, {
+      gateway: gateway.gateway,
+      keybag: () => getKeyBag(loader.sthis, {
+        ...loader.ebOpts.keyBag
+      })
+    });
+    return store;
   });
-  return store;
 }
+var onceMetaStoreFactory = new KeyedResolvOnce2();
 async function metaStoreFactory(loader) {
   const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.meta, loader)).build().setParam("store", "meta").URI();
   const sthis = ensureSuperLog(loader.sthis, "metaStoreFactory", { url: () => url.toString() });
-  sthis.logger.Debug().Str("protocol", url.protocol).Msg("pre-protocol switch");
-  const gateway = await getGatewayFromURL(url, sthis);
-  if (!gateway) {
-    throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-  }
-  const store = new MetaStoreImpl(loader.sthis, loader.name, url, {
-    gateway: gateway.gateway,
-    keybag: () => getKeyBag(loader.sthis, {
-      ...loader.ebOpts.keyBag
-    })
+  return onceMetaStoreFactory.get(url.toString()).once(async () => {
+    sthis.logger.Debug().Str("protocol", url.protocol).Msg("pre-protocol switch");
+    const gateway = await getGatewayFromURL(url, sthis);
+    if (!gateway) {
+      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
+    }
+    const store = new MetaStoreImpl(loader.sthis, loader.name, url, {
+      gateway: gateway.gateway,
+      keybag: () => getKeyBag(loader.sthis, {
+        ...loader.ebOpts.keyBag
+      })
+    });
+    return store;
   });
-  return store;
 }
+var onceRemoteWalFactory = new KeyedResolvOnce2();
 async function remoteWalFactory(loader) {
   const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.wal, loader)).build().setParam("store", "wal").URI();
   const sthis = ensureSuperLog(loader.sthis, "remoteWalFactory", { url: url.toString() });
-  const gateway = await getGatewayFromURL(url, sthis);
-  if (!gateway) {
-    throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-  }
-  sthis.logger.Debug().Str("prepared", url.toString()).Msg("produced");
-  const store = new WALStoreImpl(loader, url, {
-    gateway: gateway.gateway,
-    keybag: () => getKeyBag(loader.sthis, {
-      ...loader.ebOpts.keyBag
-    })
+  return onceRemoteWalFactory.get(url.toString()).once(async () => {
+    const gateway = await getGatewayFromURL(url, sthis);
+    if (!gateway) {
+      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
+    }
+    sthis.logger.Debug().Str("prepared", url.toString()).Msg("produced");
+    const store = new WALStoreImpl(loader, url, {
+      gateway: gateway.gateway,
+      keybag: () => getKeyBag(loader.sthis, {
+        ...loader.ebOpts.keyBag
+      })
+    });
+    return store;
   });
-  return store;
 }
 async function testStoreFactory(url, sthis) {
   sthis = ensureSuperLog(sthis, "testStoreFactory");
@@ -2038,78 +2290,27 @@ function toStoreRuntime(opts, sthis) {
 }
 registerStoreProtocol({
   protocol: "file:",
-  gateway: async (logger) => {
-    const { FileGateway } = await import("./gateway-YSNUK2L3.js");
-    return new FileGateway(logger);
+  gateway: async (sthis) => {
+    const { FileGateway } = await import("./gateway-VWWKLHUI.js");
+    return new FileGateway(sthis);
   },
-  test: async (logger) => {
-    const { FileTestStore } = await import("./gateway-YSNUK2L3.js");
-    return new FileTestStore(logger);
+  test: async (sthis) => {
+    const { FileTestStore } = await import("./gateway-VWWKLHUI.js");
+    return new FileTestStore(sthis);
   }
 });
 registerStoreProtocol({
   protocol: "indexdb:",
-  gateway: async (logger) => {
-    const { IndexDBGateway } = await import("./gateway-IZRHJWPE.js");
-    return new IndexDBGateway(logger);
+  gateway: async (sthis) => {
+    const { IndexDBGateway } = await import("./gateway-7OM6OSYK.js");
+    return new IndexDBGateway(sthis);
   },
-  test: async (logger) => {
-    const { IndexDBTestStore } = await import("./gateway-IZRHJWPE.js");
-    return new IndexDBTestStore(logger);
+  test: async (sthis) => {
+    const { IndexDBTestStore } = await import("./gateway-7OM6OSYK.js");
+    return new IndexDBTestStore(sthis);
   }
 });
 
-// src/blockstore/connection-base.ts
-import { EventBlock, decodeEventBlock } from "@web3-storage/pail/clock";
-import { MemoryBlockstore as MemoryBlockstore2 } from "@web3-storage/pail/block";
-
-// src/blockstore/task-manager.ts
-var TaskManager = class {
-  constructor(loader) {
-    this.eventsWeHandled = /* @__PURE__ */ new Set();
-    this.queue = [];
-    this.isProcessing = false;
-    this.loader = loader;
-    this.logger = ensureLogger(loader.sthis, "TaskManager");
-  }
-  async handleEvent(eventBlock) {
-    const cid = eventBlock.cid.toString();
-    const parents = eventBlock.value.parents.map((cid2) => cid2.toString());
-    for (const parent of parents) {
-      this.eventsWeHandled.add(parent);
-    }
-    this.queue.push({ cid, eventBlock, retries: 0 });
-    this.queue = this.queue.filter(({ cid: cid2 }) => !this.eventsWeHandled.has(cid2));
-    void this.processQueue();
-  }
-  async processQueue() {
-    if (this.isProcessing) return;
-    this.isProcessing = true;
-    const filteredQueue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
-    const first = filteredQueue[0];
-    if (!first) {
-      return;
-    }
-    try {
-      this.loader?.remoteMetaStore?.handleByteHeads([first.eventBlock.value.data.dbMeta]);
-      this.eventsWeHandled.add(first.cid);
-      this.queue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
-    } catch (err) {
-      if (first.retries++ > 3) {
-        this.logger.Error().Str("cid", first.cid).Msg("failed to process event block after 3 retries");
-        this.queue = this.queue.filter(({ cid }) => cid !== first.cid);
-      }
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      throw this.logger.Error().Err(err).Msg("failed to process event block").AsError();
-    } finally {
-      this.isProcessing = false;
-      if (this.queue.length > 0) {
-        void this.processQueue();
-      }
-    }
-  }
-};
-
 // src/blockstore/store-remote.ts
 async function RemoteDataStore(sthis, name, url, opts) {
   const ds = new DataStoreImpl(sthis, name, url, opts);
@@ -2117,7 +2318,7 @@ async function RemoteDataStore(sthis, name, url, opts) {
   return ds;
 }
 async function RemoteMetaStore(sthis, name, url, opts) {
-  const ms = new MetaStoreImpl(sthis, name, url, opts);
+  const ms = new MetaStoreImpl(sthis, name, url, opts, true);
   await ms.start();
   return ms;
 }
@@ -2125,16 +2326,12 @@ async function RemoteMetaStore(sthis, name, url, opts) {
 // src/blockstore/connection-base.ts
 var ConnectionBase = class {
   constructor(url, logger) {
-    // readonly ready: Promise<unknown>;
-    // todo move to LRU blockstore https://github.com/web3-storage/w3clock/blob/main/src/worker/block.js
-    this.eventBlocks = new MemoryBlockstore2();
-    this.parents = [];
     this.loaded = Promise.resolve();
     this.logger = logger;
     this.url = url;
   }
   async refresh() {
-    await throwFalsy(throwFalsy(this.loader).remoteMetaStore).load("main");
+    await throwFalsy(throwFalsy(this.loader).remoteMetaStore).load();
     await (await throwFalsy(this.loader).WALStore()).process();
   }
   async connect_X({ loader }) {
@@ -2145,26 +2342,20 @@ var ConnectionBase = class {
   async connectMeta_X({ loader }) {
     if (!loader) throw this.logger.Error().Msg("connectMeta_X: loader is required").AsError();
     this.loader = loader;
-    this.taskManager = new TaskManager(loader);
     await this.onConnect();
     const metaUrl = this.url.build().defParam("store", "meta").URI();
     const gateway = await getGatewayFromURL(metaUrl, this.loader.sthis);
     if (!gateway) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: gateway is required").AsError();
-    const name = metaUrl.toString();
-    const remote = await RemoteMetaStore(loader.sthis, name, metaUrl, {
+    const dbName = metaUrl.getParam("name");
+    if (!dbName) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: name is required").AsError();
+    const remote = await RemoteMetaStore(loader.sthis, dbName, metaUrl, {
       gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, loader.ebOpts.keyBag)
-    });
-    remote.onLoad("main", async (metas) => {
-      if (metas) {
-        this.logger.Debug().Any("metas", metas).Bool("loader", this.loader).Msg("connectMeta_X: handleDbMetasFromStore pre");
-        await throwFalsy(this.loader).handleDbMetasFromStore(metas);
-        this.logger.Debug().Any("metas", metas).Msg("connectMeta_X: handleDbMetasFromStore post");
-      }
+      keybag: () => getKeyBag(loader.sthis, loader.ebOpts.keyBag),
+      loader
     });
     this.loader.remoteMetaStore = remote;
     this.loaded = this.loader.ready().then(async () => {
-      remote.load("main").then(async () => {
+      remote.load().then(async () => {
         (await throwFalsy(this.loader).WALStore()).process();
       });
     });
@@ -2175,28 +2366,14 @@ var ConnectionBase = class {
     const dataUrl = this.url.build().defParam("store", "data").URI();
     const gateway = await getGatewayFromURL(dataUrl, this.loader.sthis);
     if (!gateway) throw this.logger.Error().Url(dataUrl).Msg("connectStorage_X: gateway is required").AsError();
-    const name = dataUrl.toString();
+    const name = dataUrl.getParam("name");
+    if (!name) throw this.logger.Error().Url(dataUrl).Msg("connectStorage_X: name is required").AsError;
     loader.remoteCarStore = await RemoteDataStore(loader.sthis, name, this.url, {
       gateway: gateway.gateway,
       keybag: () => getKeyBag(loader.sthis, this.loader?.ebOpts.keyBag)
     });
     loader.remoteFileStore = loader.remoteCarStore;
   }
-  async createEventBlock(bytes) {
-    const data = {
-      dbMeta: bytes
-    };
-    const event = await EventBlock.create(
-      data,
-      this.parents
-    );
-    await this.eventBlocks.put(event.cid, event.bytes);
-    return event;
-  }
-  async decodeEventBlock(bytes) {
-    const event = await decodeEventBlock(bytes);
-    return event;
-  }
   // move this stuff to connect
   // async getDashboardURL(compact = true) {
   //   const baseUrl = 'https://dashboard.fireproof.storage/'
@@ -2490,7 +2667,7 @@ async function doCompact(blockLog, head, logger) {
   isCompacting = false;
 }
 async function getBlock(blocks, cidString) {
-  const block = await blocks.get(parse2(cidString));
+  const block = await blocks.get(parse3(cidString));
   if (!block) throw new Error(`Missing block ${cidString}`);
   const { cid, value } = await decode({ bytes: block.bytes, codec, hasher: hasher5 });
   return new Block({ cid, value, bytes: block.bytes });
@@ -2826,7 +3003,7 @@ var Index = class {
 // src/crdt-clock.ts
 import { advance } from "@web3-storage/pail/clock";
 import { root as root2 } from "@web3-storage/pail/crdt";
-import { ResolveOnce as ResolveOnce3 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce4 } from "@adviser/cement";
 
 // src/apply-head-queue.ts
 function applyHeadQueue(worker, logger) {
@@ -2883,7 +3060,7 @@ var CRDTClock = class {
     this.zoomers = /* @__PURE__ */ new Set();
     this.watchers = /* @__PURE__ */ new Set();
     this.emptyWatchers = /* @__PURE__ */ new Set();
-    this._ready = new ResolveOnce3();
+    this._ready = new ResolveOnce4();
     this.blockstore = blockstore;
     this.logger = ensureLogger(blockstore.sthis, "CRDTClock");
     this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
@@ -2994,7 +3171,7 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 var CRDT = class {
   constructor(sthis, name, opts = {}) {
     this.indexers = /* @__PURE__ */ new Map();
-    this.onceReady = new ResolveOnce4();
+    this.onceReady = new ResolveOnce5();
     this.sthis = sthis;
     this.name = name;
     this.logger = ensureLogger(sthis, "CRDT");
@@ -3060,7 +3237,8 @@ var CRDT = class {
       try {
         await Promise.all([this.blockstore.ready(), this.indexBlockstore.ready(), this.clock.ready()]);
       } catch (e) {
-        throw this.logger.Error().Err(e).Msg("CRDT not ready").AsError();
+        const ee = e;
+        throw this.logger.Error().Err(e).Msg(`CRDT is not ready: ${ee.stack}`).AsError();
       }
     });
   }
@@ -3114,7 +3292,7 @@ var Database = class {
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new ResolveOnce5();
+    this._ready = new ResolveOnce6();
     this.name = name;
     this.opts = opts || this.opts;
     this.sthis = ensureSuperThis(this.opts);
@@ -3292,34 +3470,9 @@ 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,
-  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/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.9-dev-frag": "xxxx"
+  "0.19.11-dev-dryrun": "xxxx"
 })[0];
 export {
   CRDT,
@@ -3335,7 +3488,6 @@ export {
   ensureLogger,
   ensureSuperLog,
   ensureSuperThis,
-  exception2Result,
   exceptionWrapper,
   falsyToUndef,
   fireproof,