@fireproof/core 0.20.0-dev-preview-53 → 0.20.0-dev-preview-54

package/index.cjs

@@ -74,7 +74,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/ledger.ts
-var import_cement20 = require("@adviser/cement");
+var import_cement21 = require("@adviser/cement");
 
 // src/utils.ts
 var import_cement = require("@adviser/cement");
@@ -569,70 +569,34 @@ __export(files_exports, {
   decodeFile: () => decodeFile,
   encodeFile: () => encodeFile
 });
-var UnixFS = __toESM(require("@ipld/unixfs"), 1);
 var raw = __toESM(require("multiformats/codecs/raw"), 1);
-var import_fixed = require("@ipld/unixfs/file/chunker/fixed");
-var import_balanced = require("@ipld/unixfs/file/layout/balanced");
-var import_ipfs_unixfs_exporter = require("ipfs-unixfs-exporter");
-var queuingStrategy = UnixFS.withCapacity();
-var settings = UnixFS.configure({
-  fileChunkEncoder: raw,
-  smallFileEncoder: raw,
-  chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
-  fileLayout: (0, import_balanced.withWidth)(1024)
-});
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
-}
+var import_cid = require("multiformats/cid");
+var import_sha2 = require("multiformats/hashes/sha2");
+var import_cement3 = require("@adviser/cement");
 async function encodeFile(blob) {
-  const readable = createFileEncoderStream(blob);
-  const blocks = await collect(readable);
-  return { cid: blocks.at(-1).cid, blocks };
+  const data = await (0, import_cement3.top_uint8)(blob);
+  const bytes = raw.encode(data);
+  const hash = await import_sha2.sha256.digest(bytes);
+  const cid = import_cid.CID.create(1, raw.code, hash);
+  const block = { cid, bytes };
+  return { cid, blocks: [block] };
 }
-async function decodeFile(blocks, cid, meta) {
-  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
-  const chunks = [];
-  for await (const chunk of entry.content()) {
-    chunks.push(chunk);
-  }
-  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
+function isHasBlockAGet(obj) {
+  return typeof obj.get === "function";
 }
-function createFileEncoderStream(blob) {
-  const { readable, writable } = new TransformStream({}, queuingStrategy);
-  const unixfsWriter = UnixFS.createWriter({ writable, settings });
-  const fileBuilder = new UnixFSFileBuilder("", blob);
-  void (async () => {
-    await fileBuilder.finalize(unixfsWriter);
-    await unixfsWriter.close();
-  })();
-  return readable;
+async function decodeFile(blocks, cid, meta) {
+  if (!isHasBlockAGet(blocks)) {
+    return import_cement3.Result.Err(new Error("Invalid block storage"));
+  }
+  return (0, import_cement3.exception2Result)(async () => {
+    const bytes = await blocks.get(cid);
+    const data = raw.decode(bytes);
+    return new File([data], "file", {
+      type: meta.type,
+      lastModified: meta.lastModified || 0
+    });
+  });
 }
-var UnixFSFileBuilder = class {
-  #file;
-  constructor(name, file) {
-    this.name = name;
-    this.#file = file;
-  }
-  async finalize(writer) {
-    const unixfsFileWriter = UnixFS.createFileWriter(writer);
-    await this.#file.stream().pipeTo(
-      new WritableStream({
-        async write(chunk) {
-          await unixfsFileWriter.write(chunk);
-        }
-      })
-    );
-    return await unixfsFileWriter.close();
-  }
-};
 
 // src/runtime/key-bag.ts
 var key_bag_exports = {};
@@ -645,13 +609,13 @@ __export(key_bag_exports, {
   registerKeyBagProviderFactory: () => registerKeyBagProviderFactory,
   toKeyWithFingerPrint: () => toKeyWithFingerPrint
 });
-var import_cement4 = require("@adviser/cement");
+var import_cement5 = require("@adviser/cement");
 var import_base582 = require("multiformats/bases/base58");
 
 // src/runtime/gateways/file/sys-file-system-factory.ts
-var import_cement3 = require("@adviser/cement");
+var import_cement4 = require("@adviser/cement");
 function sysFileSystemFactory(uri) {
-  const rt = (0, import_cement3.runtimeFn)();
+  const rt = (0, import_cement4.runtimeFn)();
   switch (true) {
     case rt.isNodeIsh:
       return import("@fireproof/core/node").then((m) => m.getSysFileSystem(uri));
@@ -771,7 +735,7 @@ async function toKeyWithFingerPrint(keybag, materialStrOrUint8) {
   }
   const key = await keybag.subtleKey(material);
   const fpr = await keybag.rt.crypto.digestSHA256(material);
-  return import_cement4.Result.Ok({
+  return import_cement5.Result.Ok({
     key,
     fingerPrint: import_base582.base58btc.encode(new Uint8Array(fpr)),
     extract: async () => {
@@ -827,13 +791,13 @@ var keysByFingerprint = class _keysByFingerprint {
     def = !!def;
     const rKfp = await toKeyWithFingerPrint(this.keybag, materialStrOrUint8);
     if (rKfp.isErr()) {
-      return import_cement4.Result.Err(rKfp);
+      return import_cement5.Result.Err(rKfp);
     }
     const kfp = rKfp.Ok();
     let found = this.keys[kfp.fingerPrint];
     if (found) {
       if (found.default === def) {
-        return import_cement4.Result.Ok({
+        return import_cement5.Result.Ok({
           modified: false,
           kfp: found
         });
@@ -853,7 +817,7 @@ var keysByFingerprint = class _keysByFingerprint {
     if (keyBagAction) {
       this.keybag._upsertNamedKey(this);
     }
-    return import_cement4.Result.Ok({
+    return import_cement5.Result.Ok({
       modified: keyBagAction && true,
       kfp: found
     });
@@ -883,8 +847,8 @@ var keysByFingerprint = class _keysByFingerprint {
 };
 var KeyBag = class {
   constructor(rt) {
-    this._warnOnce = new import_cement4.ResolveOnce();
-    this._seq = new import_cement4.ResolveSeq();
+    this._warnOnce = new import_cement5.ResolveOnce();
+    this._seq = new import_cement5.ResolveSeq();
     // async getNamedExtractableKey(name: string, failIfNotFound = false): Promise<Result<KeysByFingerprint>> {
     //   const ret = await this.getNamedKey(name, failIfNotFound);
     //   if (ret.isErr()) {
@@ -902,7 +866,7 @@ var KeyBag = class {
     //     },
     //   });
     // }
-    this._namedKeyCache = new import_cement4.KeyedResolvOnce();
+    this._namedKeyCache = new import_cement5.KeyedResolvOnce();
     this.rt = rt;
     this.logger = ensureLogger(rt.sthis, "KeyBag");
   }
@@ -932,24 +896,24 @@ var KeyBag = class {
   async ensureKeyFromUrl(url, keyFactory) {
     const storeKey = url.getParam(PARAM.STORE_KEY);
     if (storeKey === "insecure") {
-      return import_cement4.Result.Ok(url);
+      return import_cement5.Result.Ok(url);
     }
     if (!storeKey) {
       const keyName = `@${keyFactory()}@`;
       const ret = await this.getNamedKey(keyName);
       if (ret.isErr()) {
-        return import_cement4.Result.Err(ret);
+        return import_cement5.Result.Err(ret);
       }
       const urb = url.build().setParam(PARAM.STORE_KEY, keyName);
-      return import_cement4.Result.Ok(urb.URI());
+      return import_cement5.Result.Ok(urb.URI());
     }
     if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
       const ret = await this.getNamedKey(storeKey);
       if (ret.isErr()) {
-        return import_cement4.Result.Err(ret);
+        return import_cement5.Result.Err(ret);
       }
     }
-    return import_cement4.Result.Ok(url);
+    return import_cement5.Result.Ok(url);
   }
   async toKeysItem(ki) {
     if (!ki) return void 0;
@@ -1008,7 +972,7 @@ var KeyBag = class {
         this._namedKeyCache.unget(ksi.name);
       }
       await bag.set(await ksi.asKeysItem());
-      return import_cement4.Result.Ok(ksi);
+      return import_cement5.Result.Ok(ksi);
     });
   }
   async _getNamedKey(name, failIfNotFound, material) {
@@ -1018,7 +982,7 @@ var KeyBag = class {
       const named = await this.toKeysItem(await bag.get(name));
       if (named) {
         this.logger.Debug().Str("id", id).Str("name", name).Any("fprs", Object.keys(named.keys)).Msg("fingerPrint getNamedKey");
-        return import_cement4.Result.Ok(await keysByFingerprint.from(this, named));
+        return import_cement5.Result.Ok(await keysByFingerprint.from(this, named));
       }
       if (!named && failIfNotFound) {
         this._namedKeyCache.unget(name);
@@ -1039,10 +1003,10 @@ var KeyBag = class {
       }
       const res = await kp.upsert(keyMaterial, true);
       if (res.isErr()) {
-        return import_cement4.Result.Err(res);
+        return import_cement5.Result.Err(res);
       }
       this.logger.Debug().Str("id", id).Str("name", name).Str("fpr", res.Ok().kfp.fingerPrint).Msg("createKey getNamedKey-post");
-      return import_cement4.Result.Ok(kp);
+      return import_cement5.Result.Ok(kp);
     });
   }
   async getNamedKey(name, failIfNotFound = false, material) {
@@ -1084,15 +1048,15 @@ function registerKeyBagProviderFactory(item) {
 function defaultKeyBagUrl(sthis) {
   let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
   let url;
-  if ((0, import_cement4.runtimeFn)().isBrowser) {
-    url = import_cement4.URI.from(bagFnameOrUrl || "indexeddb://fp-keybag");
+  if ((0, import_cement5.runtimeFn)().isBrowser) {
+    url = import_cement5.URI.from(bagFnameOrUrl || "indexeddb://fp-keybag");
   } else {
     if (!bagFnameOrUrl) {
       const home = sthis.env.get("HOME");
       bagFnameOrUrl = `${home}/.fireproof/keybag`;
-      url = import_cement4.URI.from(`file://${bagFnameOrUrl}`);
+      url = import_cement5.URI.from(`file://${bagFnameOrUrl}`);
     } else {
-      url = import_cement4.URI.from(bagFnameOrUrl);
+      url = import_cement5.URI.from(bagFnameOrUrl);
     }
   }
   const logger = ensureLogger(sthis, "defaultKeyBagUrl");
@@ -1107,19 +1071,19 @@ function defaultKeyBagOpts(sthis, kbo) {
   const logger = ensureLogger(sthis, "KeyBag");
   let url;
   if (kbo.url) {
-    url = import_cement4.URI.from(kbo.url);
+    url = import_cement5.URI.from(kbo.url);
     logger.Debug().Url(url).Msg("from opts");
   } else {
     let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
-    if ((0, import_cement4.runtimeFn)().isBrowser) {
-      url = import_cement4.URI.from(bagFnameOrUrl || "indexeddb://fp-keybag");
+    if ((0, import_cement5.runtimeFn)().isBrowser) {
+      url = import_cement5.URI.from(bagFnameOrUrl || "indexeddb://fp-keybag");
     } else {
       if (!bagFnameOrUrl) {
         const home = sthis.env.get("HOME");
         bagFnameOrUrl = `${home}/.fireproof/keybag`;
-        url = import_cement4.URI.from(`file://${bagFnameOrUrl}`);
+        url = import_cement5.URI.from(`file://${bagFnameOrUrl}`);
       } else {
-        url = import_cement4.URI.from(bagFnameOrUrl);
+        url = import_cement5.URI.from(bagFnameOrUrl);
       }
     }
     logger.Debug().Url(url).Msg("from env");
@@ -1133,7 +1097,7 @@ function defaultKeyBagOpts(sthis, kbo) {
   }
   return {
     url,
-    crypto: kbo.crypto || (0, import_cement4.toCryptoRuntime)({}),
+    crypto: kbo.crypto || (0, import_cement5.toCryptoRuntime)({}),
     sthis,
     logger,
     keyLength: kbo.keyLength || 16,
@@ -1143,7 +1107,7 @@ function defaultKeyBagOpts(sthis, kbo) {
     }
   };
 }
-var _keyBags = new import_cement4.KeyedResolvOnce();
+var _keyBags = new import_cement5.KeyedResolvOnce();
 async function getKeyBag(sthis, kbo = {}) {
   await sthis.start();
   const rt = defaultKeyBagOpts(sthis, kbo);
@@ -1151,7 +1115,7 @@ async function getKeyBag(sthis, kbo = {}) {
 }
 
 // src/blockstore/register-store-protocol.ts
-var import_cement10 = require("@adviser/cement");
+var import_cement11 = require("@adviser/cement");
 
 // src/runtime/gateways/file/version.ts
 var FILESTORE_VERSION = "v0.19-file";
@@ -1160,10 +1124,9 @@ var FILESTORE_VERSION = "v0.19-file";
 var INDEXEDDB_VERSION = "v0.19-indexeddb";
 
 // src/runtime/gateways/file/gateway-impl.ts
-var import_cement5 = require("@adviser/cement");
+var import_cement6 = require("@adviser/cement");
 
 // src/runtime/gateways/file/utils.ts
-var import_core = require("@fireproof/core");
 function getPath(url, sthis) {
   const basePath = url.pathname;
   const name = url.getParam("name");
@@ -1175,7 +1138,7 @@ function getPath(url, sthis) {
 function getFileName(url, sthis) {
   const key = url.getParam("key");
   if (!key) throw sthis.logger.Error().Url(url).Msg(`key not found`).AsError();
-  const res = (0, import_core.getStore)(url, sthis, (...a) => a.join("-"));
+  const res = getStore(url, sthis, (...a) => a.join("-"));
   switch (res.fromUrl) {
     case "file":
       return sthis.pathOps.join(res.name, key);
@@ -1190,7 +1153,7 @@ function getFileName(url, sthis) {
 }
 
 // src/runtime/gateways/file/gateway-impl.ts
-var versionFiles = new import_cement5.KeyedResolvOnce();
+var versionFiles = new import_cement6.KeyedResolvOnce();
 var FileGateway = class {
   constructor(sthis, fs) {
     this.fs = fs;
@@ -1215,7 +1178,7 @@ var FileGateway = class {
     });
   }
   start(baseURL, sthis) {
-    return (0, import_cement5.exception2Result)(async () => {
+    return (0, import_cement6.exception2Result)(async () => {
       await this.fs.start();
       const url = baseURL.build();
       url.defParam(PARAM.VERSION, FILESTORE_VERSION);
@@ -1229,10 +1192,10 @@ var FileGateway = class {
     });
   }
   async buildUrl(baseUrl, key) {
-    return import_cement5.Result.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI());
+    return import_cement6.Result.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI());
   }
   async close() {
-    return import_cement5.Result.Ok(void 0);
+    return import_cement6.Result.Ok(void 0);
   }
   getFilePath(url, sthis) {
     const key = url.getParam(PARAM.KEY);
@@ -1240,7 +1203,7 @@ var FileGateway = class {
     return sthis.pathOps.join(getPath(url, sthis), getFileName(url, sthis));
   }
   async put(url, bytes, sthis) {
-    return (0, import_cement5.exception2Result)(async () => {
+    return (0, import_cement6.exception2Result)(async () => {
       const file = await this.getFilePath(url, sthis);
       sthis.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
       await this.fs.writefile(file, bytes);
@@ -1252,17 +1215,17 @@ var FileGateway = class {
       try {
         sthis.logger.Debug().Url(url).Str("file", file).Msg("get");
         const res = await this.fs.readfile(file);
-        return import_cement5.Result.Ok(res);
+        return import_cement6.Result.Ok(res);
       } catch (e) {
         if (isNotFoundError(e)) {
-          return import_cement5.Result.Err(new NotFoundError(`file not found: ${file}`));
+          return import_cement6.Result.Err(new NotFoundError(`file not found: ${file}`));
         }
-        return import_cement5.Result.Err(e);
+        return import_cement6.Result.Err(e);
       }
     });
   }
   async delete(url, sthis) {
-    return (0, import_cement5.exception2Result)(async () => {
+    return (0, import_cement6.exception2Result)(async () => {
       await this.fs.unlink(this.getFilePath(url, sthis));
     });
   }
@@ -1288,7 +1251,7 @@ var FileGateway = class {
         }
       }
     }
-    return import_cement5.Result.Ok(void 0);
+    return import_cement6.Result.Ok(void 0);
   }
   async getPlain(iurl, key, sthis) {
     const url = iurl.build().setParam(PARAM.KEY, key).URI();
@@ -1296,7 +1259,7 @@ var FileGateway = class {
     sthis.logger.Debug().Url(url).Str("dbFile", dbFile).Msg("get");
     const buffer = await this.fs.readfile(dbFile);
     sthis.logger.Debug().Url(url).Str("dbFile", dbFile).Len(buffer).Msg("got");
-    return import_cement5.Result.Ok(buffer);
+    return import_cement6.Result.Ok(buffer);
   }
 };
 
@@ -1305,7 +1268,7 @@ var gateway_exports = {};
 __export(gateway_exports, {
   MemoryGateway: () => MemoryGateway
 });
-var import_cement6 = require("@adviser/cement");
+var import_cement7 = require("@adviser/cement");
 
 // src/runtime/gateways/memory/version.ts
 var MEMORY_VERSION = "v0.19-memory";
@@ -1318,14 +1281,14 @@ var MemoryGateway = class {
     this.sthis = sthis;
   }
   buildUrl(baseUrl, key) {
-    return Promise.resolve(import_cement6.Result.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI()));
+    return Promise.resolve(import_cement7.Result.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI()));
   }
   start(baseUrl) {
-    return Promise.resolve(import_cement6.Result.Ok(baseUrl.build().setParam(PARAM.VERSION, MEMORY_VERSION).URI()));
+    return Promise.resolve(import_cement7.Result.Ok(baseUrl.build().setParam(PARAM.VERSION, MEMORY_VERSION).URI()));
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   close(baseUrl) {
-    return Promise.resolve(import_cement6.Result.Ok(void 0));
+    return Promise.resolve(import_cement7.Result.Ok(void 0));
   }
   destroy(baseUrl) {
     const keyUrl = baseUrl.toString();
@@ -1335,38 +1298,38 @@ var MemoryGateway = class {
       }
     }
     this.memorys.clear();
-    return Promise.resolve(import_cement6.Result.Ok(void 0));
+    return Promise.resolve(import_cement7.Result.Ok(void 0));
   }
   async put(url, bytes) {
     this.memorys.set(url.toString(), bytes);
-    return import_cement6.Result.Ok(void 0);
+    return import_cement7.Result.Ok(void 0);
   }
   // get could return a NotFoundError if the key is not found
   get(url) {
     const x = this.memorys.get(url.toString());
     if (!x) {
-      return Promise.resolve(import_cement6.Result.Err(new NotFoundError(`not found: ${url.toString()}`)));
+      return Promise.resolve(import_cement7.Result.Err(new NotFoundError(`not found: ${url.toString()}`)));
     }
-    return Promise.resolve(import_cement6.Result.Ok(x));
+    return Promise.resolve(import_cement7.Result.Ok(x));
   }
   delete(url) {
     this.memorys.delete(url.toString());
-    return Promise.resolve(import_cement6.Result.Ok(void 0));
+    return Promise.resolve(import_cement7.Result.Ok(void 0));
   }
   async getPlain(url, key) {
     const x = this.memorys.get(url.build().setParam(PARAM.KEY, key).toString());
     if (!x) {
-      return import_cement6.Result.Err(new NotFoundError("not found"));
+      return import_cement7.Result.Err(new NotFoundError("not found"));
     }
-    return import_cement6.Result.Ok(x);
+    return import_cement7.Result.Ok(x);
   }
 };
 
 // src/runtime/gateways/def-serde-gateway.ts
-var import_cement9 = require("@adviser/cement");
+var import_cement10 = require("@adviser/cement");
 
 // src/blockstore/fp-envelope.ts
-var import_cement7 = require("@adviser/cement");
+var import_cement8 = require("@adviser/cement");
 var FPEnvelopeTypes = {
   CAR: "car",
   FILE: "file",
@@ -1374,14 +1337,14 @@ var FPEnvelopeTypes = {
   WAL: "wal"
 };
 function Car2FPMsg(fpcar) {
-  return import_cement7.Result.Ok({ type: FPEnvelopeTypes.CAR, payload: fpcar });
+  return import_cement8.Result.Ok({ type: FPEnvelopeTypes.CAR, payload: fpcar });
 }
 function File2FPMsg(fpfile) {
-  return import_cement7.Result.Ok({ type: FPEnvelopeTypes.FILE, payload: fpfile });
+  return import_cement8.Result.Ok({ type: FPEnvelopeTypes.FILE, payload: fpfile });
 }
 
 // src/runtime/gateways/fp-envelope-serialize.ts
-var import_cement8 = require("@adviser/cement");
+var import_cement9 = require("@adviser/cement");
 var import_clock = require("@fireproof/vendor/@web3-storage/pail/clock");
 var import_base64 = require("multiformats/bases/base64");
 var import_multiformats = require("multiformats");
@@ -1420,10 +1383,10 @@ function WALState2Serialized(sthis, wal) {
   return serializedWAL;
 }
 var defaultEncoder = {
-  car: async (sthis, payload) => import_cement8.Result.Ok(payload),
-  file: async (sthis, payload) => import_cement8.Result.Ok(payload),
-  meta: async (sthis, payload) => import_cement8.Result.Ok(sthis.txt.encode(JSON.stringify(payload))),
-  wal: async (sthis, payload) => import_cement8.Result.Ok(sthis.txt.encode(JSON.stringify(payload)))
+  car: async (sthis, payload) => import_cement9.Result.Ok(payload),
+  file: async (sthis, payload) => import_cement9.Result.Ok(payload),
+  meta: async (sthis, payload) => import_cement9.Result.Ok(sthis.txt.encode(JSON.stringify(payload))),
+  wal: async (sthis, payload) => import_cement9.Result.Ok(sthis.txt.encode(JSON.stringify(payload)))
 };
 async function fpSerialize(sthis, env, pencoder) {
   const encoder = {
@@ -1445,13 +1408,13 @@ async function fpSerialize(sthis, env, pencoder) {
 }
 async function decode2DbMetaEvents(sthis, rserializedMeta) {
   if (rserializedMeta.isErr()) {
-    return import_cement8.Result.Err(rserializedMeta.Err());
+    return import_cement9.Result.Err(rserializedMeta.Err());
   }
   const serializedMeta = rserializedMeta.unwrap();
   if (!Array.isArray(serializedMeta)) {
     return sthis.logger.Debug().Any("metaEntries", serializedMeta).Msg("No data in MetaEntries").ResultError();
   }
-  return import_cement8.Result.Ok(
+  return import_cement9.Result.Ok(
     await Promise.all(
       serializedMeta.map(async (metaEntry) => {
         const eventBlock = await (0, import_clock.decodeEventBlock)(import_base64.base64pad.decode(metaEntry.data));
@@ -1473,10 +1436,10 @@ function toCid(sthis, link) {
 }
 async function decode2WalState(sthis, rserializedWAL) {
   if (rserializedWAL.isErr()) {
-    return import_cement8.Result.Err(rserializedWAL.Err());
+    return import_cement9.Result.Err(rserializedWAL.Err());
   }
   const serializedWAL = rserializedWAL.unwrap();
-  return import_cement8.Result.Ok({
+  return import_cement9.Result.Ok({
     fileOperations: (serializedWAL.fileOperations || []).map((fop) => ({
       cid: toCid(sthis, fop.cid),
       public: !!fop.public
@@ -1490,16 +1453,16 @@ async function decode2WalState(sthis, rserializedWAL) {
   });
 }
 var defaultDecoder = {
-  car: async (sthis, payload) => import_cement8.Result.Ok(payload),
-  file: async (sthis, payload) => import_cement8.Result.Ok(payload),
-  meta: async (sthis, payload) => (0, import_cement8.exception2Result)(() => JSON.parse(sthis.txt.decode(payload))),
-  wal: async (sthis, payload) => (0, import_cement8.exception2Result)(() => JSON.parse(sthis.txt.decode(payload)))
+  car: async (sthis, payload) => import_cement9.Result.Ok(payload),
+  file: async (sthis, payload) => import_cement9.Result.Ok(payload),
+  meta: async (sthis, payload) => (0, import_cement9.exception2Result)(() => JSON.parse(sthis.txt.decode(payload))),
+  wal: async (sthis, payload) => (0, import_cement9.exception2Result)(() => JSON.parse(sthis.txt.decode(payload)))
 };
 function makeFPEnvelope(type, payload) {
   if (payload.isErr()) {
-    return import_cement8.Result.Err(payload.Err());
+    return import_cement9.Result.Err(payload.Err());
   }
-  return import_cement8.Result.Ok({
+  return import_cement9.Result.Ok({
     type,
     payload: payload.unwrap()
   });
@@ -1507,7 +1470,7 @@ function makeFPEnvelope(type, payload) {
 async function fpDeserialize(sthis, url, intoRaw, pdecoder) {
   const rraw = await coercePromiseIntoUint8(intoRaw);
   if (rraw.isErr()) {
-    return import_cement8.Result.Err(rraw.Err());
+    return import_cement9.Result.Err(rraw.Err());
   }
   const raw2 = rraw.unwrap();
   const decoder = {
@@ -1558,12 +1521,12 @@ var DefSerdeGateway = class {
   }
   async get({ loader: { sthis }, decoder }, url) {
     const res = await this.gw.get(url, sthis);
-    if (res.isErr()) return import_cement9.Result.Err(res.Err());
+    if (res.isErr()) return import_cement10.Result.Err(res.Err());
     return fpDeserialize(sthis, url, res, decoder);
   }
   async subscribe({ loader: { sthis }, decoder }, url, callback) {
     function rawCallback(raw2) {
-      return fpDeserialize(sthis, url, import_cement9.Result.Ok(raw2), decoder).then((res) => {
+      return fpDeserialize(sthis, url, import_cement10.Result.Ok(raw2), decoder).then((res) => {
         if (res.isErr()) {
           sthis.logger.Error().Err(res).Msg("Failed to deserialize");
           return;
@@ -1573,12 +1536,12 @@ var DefSerdeGateway = class {
     }
     if (!this.gw.subscribe) {
       if (!url.hasParam(PARAM.SELF_REFLECT)) {
-        return import_cement9.Result.Ok(() => {
+        return import_cement10.Result.Ok(() => {
         });
       }
       const urlWithoutKey = url.build().delParam(PARAM.KEY).delParam(PARAM.SELF_REFLECT).toString();
       this.subscribeFn.set(urlWithoutKey, rawCallback);
-      return import_cement9.Result.Ok(() => {
+      return import_cement10.Result.Ok(() => {
         this.subscribeFn.delete(urlWithoutKey);
       });
     }
@@ -1655,10 +1618,10 @@ function defaultGatewayFactoryItem() {
   return found;
 }
 function defaultURI(sthis) {
-  const rt = (0, import_cement10.runtimeFn)();
-  return import_cement10.BuildURI.from("file://").pathname(`${sthis.env.get("HOME")}/.fireproof/${FILESTORE_VERSION.replace(/-.*$/, "")}`).setParam(PARAM.VERSION, FILESTORE_VERSION).setParam(PARAM.URL_GEN, "default").setParam(PARAM.RUNTIME, rt.isNodeIsh ? "node" : rt.isDeno ? "deno" : "unknown").URI();
+  const rt = (0, import_cement11.runtimeFn)();
+  return import_cement11.BuildURI.from("file://").pathname(`${sthis.env.get("HOME")}/.fireproof/${FILESTORE_VERSION.replace(/-.*$/, "")}`).setParam(PARAM.VERSION, FILESTORE_VERSION).setParam(PARAM.URL_GEN, "default").setParam(PARAM.RUNTIME, rt.isNodeIsh ? "node" : rt.isDeno ? "deno" : "unknown").URI();
 }
-if ((0, import_cement10.runtimeFn)().isNodeIsh || (0, import_cement10.runtimeFn)().isDeno) {
+if ((0, import_cement11.runtimeFn)().isNodeIsh || (0, import_cement11.runtimeFn)().isDeno) {
   registerStoreProtocol({
     protocol: "file:",
     isDefault: true,
@@ -1668,12 +1631,12 @@ if ((0, import_cement10.runtimeFn)().isNodeIsh || (0, import_cement10.runtimeFn)
     }
   });
 }
-if ((0, import_cement10.runtimeFn)().isBrowser) {
+if ((0, import_cement11.runtimeFn)().isBrowser) {
   registerStoreProtocol({
     protocol: "indexeddb:",
     isDefault: true,
     defaultURI: () => {
-      return import_cement10.BuildURI.from("indexeddb://").pathname("fp").setParam(PARAM.VERSION, INDEXEDDB_VERSION).setParam(PARAM.RUNTIME, "browser").URI();
+      return import_cement11.BuildURI.from("indexeddb://").pathname("fp").setParam(PARAM.VERSION, INDEXEDDB_VERSION).setParam(PARAM.RUNTIME, "browser").URI();
     },
     gateway: async () => {
       const { GatewayImpl } = await import("@fireproof/core/indexeddb");
@@ -1686,7 +1649,7 @@ registerStoreProtocol({
   protocol: "memory:",
   isDefault: false,
   defaultURI: () => {
-    return import_cement10.BuildURI.from("memory://").pathname("ram").URI();
+    return import_cement11.BuildURI.from("memory://").pathname("ram").URI();
   },
   gateway: async (sthis) => {
     return new MemoryGateway(sthis, memory);
@@ -1699,44 +1662,44 @@ __export(block_exports, {
   Block: () => Block,
   create: () => create,
   createUnsafe: () => createUnsafe,
-  decode: () => decode,
-  encode: () => encode
+  decode: () => decode2,
+  encode: () => encode2
 });
 var import_multiformats2 = require("multiformats");
 var import_block = require("multiformats/block");
 var Block = import_block.Block;
-async function decode({
+async function decode2({
   bytes,
   codec: codec3,
-  hasher: hasher6
+  hasher: hasher7
 }) {
   if (bytes == null) throw new Error('Missing required argument "bytes"');
-  if (codec3 == null || hasher6 == null) throw new Error("Missing required argument: codec or hasher");
+  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
   const value = await Promise.resolve(codec3.decode(bytes));
   let toHash = bytes;
   if (codec3.valueToHashBytes) {
     toHash = await Promise.resolve(codec3.valueToHashBytes(value));
   }
-  const hash = await hasher6.digest(toHash);
+  const hash = await hasher7.digest(toHash);
   const cid = import_multiformats2.CID.create(1, codec3.code, hash);
   return new import_block.Block({ value, bytes: toHash, cid });
 }
-async function encode({
+async function encode2({
   value,
   codec: codec3,
-  hasher: hasher6
+  hasher: hasher7
 }) {
   if (typeof value === "undefined") throw new Error('Missing required argument "value"');
-  if (codec3 == null || hasher6 == null) throw new Error("Missing required argument: codec or hasher");
+  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
   let bytes;
   let hash;
   if (codec3.bytesToHash) {
     const hashable = await Promise.resolve(codec3.bytesToHash(value));
-    hash = await hasher6.digest(hashable);
+    hash = await hasher7.digest(hashable);
     bytes = await Promise.resolve(codec3.encode(value));
   } else {
     bytes = await Promise.resolve(codec3.encode(value));
-    hash = await hasher6.digest(bytes);
+    hash = await hasher7.digest(bytes);
   }
   const cid = import_multiformats2.CID.create(1, codec3.code, hash);
   return new Block({ value, bytes, cid });
@@ -1744,13 +1707,13 @@ async function encode({
 async function create({
   bytes,
   cid,
-  hasher: hasher6,
+  hasher: hasher7,
   codec: codec3
 }) {
   if (bytes == null) throw new Error('Missing required argument "bytes"');
-  if (hasher6 == null) throw new Error('Missing required argument "hasher"');
+  if (hasher7 == null) throw new Error('Missing required argument "hasher"');
   const value = await Promise.resolve(codec3.decode(bytes));
-  const hash = await hasher6.digest(bytes);
+  const hash = await hasher7.digest(bytes);
   if (!import_multiformats2.bytes.equals(cid.multihash.bytes, hash.bytes)) {
     throw new Error("CID hash does not match bytes");
   }
@@ -1777,11 +1740,11 @@ async function createUnsafe({
 }
 
 // src/indexer-helpers.ts
-var import_sha2 = require("multiformats/hashes/sha2");
+var import_sha22 = require("multiformats/hashes/sha2");
 var codec = __toESM(require("@ipld/dag-cbor"), 1);
 var import_charwise = __toESM(require("charwise"), 1);
 var DbIndex = __toESM(require("prolly-trees/db-index"), 1);
-var import_utils8 = require("prolly-trees/utils");
+var import_utils9 = require("prolly-trees/utils");
 var import_cache = require("prolly-trees/cache");
 var IndexTree = class {
 };
@@ -1789,17 +1752,17 @@ function refCompare(aRef, bRef) {
   if (Number.isNaN(aRef)) return -1;
   if (Number.isNaN(bRef)) throw new Error("ref may not be Infinity or NaN");
   if (aRef === Infinity) return 1;
-  return (0, import_utils8.simpleCompare)(aRef, bRef);
+  return (0, import_utils9.simpleCompare)(aRef, bRef);
 }
 function compare(a, b) {
   const [aKey, aRef] = a;
   const [bKey, bRef] = b;
-  const comp = (0, import_utils8.simpleCompare)(aKey, bKey);
+  const comp = (0, import_utils9.simpleCompare)(aKey, bKey);
   if (comp !== 0) return comp;
   return refCompare(aRef, bRef);
 }
-var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils8.bf)(30), codec, hasher: import_sha2.sha256, compare };
-var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils8.bf)(30), codec, hasher: import_sha2.sha256, compare: import_utils8.simpleCompare };
+var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils9.bf)(30), codec, hasher: import_sha22.sha256, compare };
+var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils9.bf)(30), codec, hasher: import_sha22.sha256, compare: import_utils9.simpleCompare };
 function indexEntriesForChanges(changes, mapFn) {
   const indexEntries = [];
   changes.forEach(({ id: key, value, del }) => {
@@ -1827,7 +1790,7 @@ function makeProllyGetBlock(blocks) {
     const block = await blocks.get(address);
     if (!block) throw new Error(`Missing block ${address.toString()}`);
     const { cid, bytes } = block;
-    return create({ cid, bytes, hasher: import_sha2.sha256, codec });
+    return create({ cid, bytes, hasher: import_sha22.sha256, codec });
   };
 }
 async function bulkIndex(logger, tblocks, inIndex, indexEntries, opts) {
@@ -2242,7 +2205,7 @@ var DatabaseImpl = class {
 };
 
 // src/crdt.ts
-var import_cement19 = require("@adviser/cement");
+var import_cement20 = require("@adviser/cement");
 
 // src/blockstore/index.ts
 var blockstore_exports = {};
@@ -2333,24 +2296,24 @@ var WALActiveStore = class extends BaseActiveStore {
 };
 
 // src/blockstore/store-factory.ts
-var import_cement17 = require("@adviser/cement");
+var import_cement18 = require("@adviser/cement");
 
 // src/blockstore/store.ts
-var import_cement16 = require("@adviser/cement");
+var import_cement17 = require("@adviser/cement");
 
 // src/blockstore/loader.ts
 var import_p_limit = __toESM(require("p-limit"), 1);
 var import_reader = require("@ipld/car/reader");
-var import_cement14 = require("@adviser/cement");
+var import_cement15 = require("@adviser/cement");
 
 // src/blockstore/loader-helpers.ts
-var import_sha22 = require("multiformats/hashes/sha2");
+var import_sha23 = require("multiformats/hashes/sha2");
 var dagCodec = __toESM(require("@ipld/dag-cbor"), 1);
 async function parseCarFile(reader, logger) {
   const roots = await reader.roots;
   const header = reader.blocks.find((i) => i.cid.equals(roots[0]));
   if (!header) throw logger.Error().Msg("missing header block").AsError();
-  const dec = await decode({ bytes: header.bytes, hasher: import_sha22.sha256, codec: dagCodec });
+  const dec = await decode2({ bytes: header.bytes, hasher: import_sha23.sha256, codec: dagCodec });
   const fpvalue = dec.value;
   if (fpvalue && !fpvalue.fp) {
     throw logger.Error().Msg("missing fp").AsError();
@@ -2360,7 +2323,7 @@ async function parseCarFile(reader, logger) {
 
 // src/blockstore/transaction.ts
 var import_block4 = require("@fireproof/vendor/@web3-storage/pail/block");
-var import_cement11 = require("@adviser/cement");
+var import_cement12 = require("@adviser/cement");
 var CarTransactionImpl = class {
   #memblock = new import_block4.MemoryBlockstore();
   #hackUnshift;
@@ -2415,7 +2378,7 @@ function defaultedBlockstoreRuntime(sthis, opts, component, ctx) {
     ...opts,
     logger,
     keyBag: opts.keyBag || {},
-    crypto: (0, import_cement11.toCryptoRuntime)(opts.crypto),
+    crypto: (0, import_cement12.toCryptoRuntime)(opts.crypto),
     storeUrls: opts.storeUrls,
     taskManager: {
       removeAfter: 3,
@@ -2591,7 +2554,7 @@ var CompactionFetcher = class {
 };
 
 // src/blockstore/commit-queue.ts
-var import_cement12 = require("@adviser/cement");
+var import_cement13 = require("@adviser/cement");
 var CommitQueue = class {
   constructor() {
     this.queue = [];
@@ -2602,7 +2565,7 @@ var CommitQueue = class {
     if (this.queue.length === 0 && !this.processing) {
       return Promise.resolve();
     }
-    const fn = new import_cement12.Future();
+    const fn = new import_cement13.Future();
     this._waitIdleItems.add(fn);
     return fn.asPromise();
   }
@@ -2644,7 +2607,7 @@ var CommitQueue = class {
 // src/blockstore/commitor.ts
 var CBW = __toESM(require("@ipld/car/buffer-writer"), 1);
 var dagCodec2 = __toESM(require("@ipld/dag-cbor"), 1);
-var import_sha23 = require("multiformats/hashes/sha2");
+var import_sha24 = require("multiformats/hashes/sha2");
 async function encodeCarFile(roots, t, codec3) {
   let size = 0;
   const headerSize = CBW.headerLength({ roots });
@@ -2661,7 +2624,7 @@ async function encodeCarFile(roots, t, codec3) {
     writer.write({ cid, bytes });
   }
   writer.close();
-  return await encode({ value: writer.bytes, hasher: import_sha23.sha256, codec: codec3 });
+  return await encode2({ value: writer.bytes, hasher: import_sha24.sha256, codec: codec3 });
 }
 async function createCarFile(encoder, cid, t) {
   return encodeCarFile([cid], t, encoder);
@@ -2699,9 +2662,9 @@ function makeCarHeader(meta, cars, compact = false) {
   return { ...coreHeader, meta };
 }
 async function encodeCarHeader(fp) {
-  return await encode({
+  return await encode2({
     value: { fp },
-    hasher: import_sha23.sha256,
+    hasher: import_sha24.sha256,
     codec: dagCodec2
   });
 }
@@ -2744,7 +2707,7 @@ async function prepareCarFiles(encoder, threshold, rootBlock, t) {
 }
 
 // src/blockstore/loader.ts
-var import_sha24 = require("multiformats/hashes/sha2");
+var import_sha25 = require("multiformats/hashes/sha2");
 
 // src/blockstore/task-manager.ts
 var TaskManager = class {
@@ -2795,7 +2758,7 @@ var TaskManager = class {
 };
 
 // src/blockstore/attachable-store.ts
-var import_cement13 = require("@adviser/cement");
+var import_cement14 = require("@adviser/cement");
 var AttachedImpl = class {
   constructor(gws, stores, unreg) {
     this.gatewayUrls = gws;
@@ -2962,7 +2925,7 @@ async function createAttachedStores(urlOrGup, arOrLoadable, name = "local") {
   if (!urlOrGup) {
     throw new Error("urlOrGup is required");
   }
-  if ((0, import_cement13.isCoerceURI)(urlOrGup)) {
+  if ((0, import_cement14.isCoerceURI)(urlOrGup)) {
     const url = urlOrGup;
     gup = {
       car: { url },
@@ -2980,7 +2943,7 @@ async function createAttachedStores(urlOrGup, arOrLoadable, name = "local") {
 }
 var AttachedRemotesImpl = class {
   constructor(loadable) {
-    this._remotes = new import_cement13.KeyedResolvOnce();
+    this._remotes = new import_cement14.KeyedResolvOnce();
     this.loadable = loadable;
   }
   forRemotes(action) {
@@ -2996,8 +2959,8 @@ var AttachedRemotesImpl = class {
     return new ActiveStoreImpl(this._local.stores, this);
   }
   activate(store) {
-    if ((0, import_cement13.isCoerceURI)(store)) {
-      const activateUrl = import_cement13.URI.from(store);
+    if ((0, import_cement14.isCoerceURI)(store)) {
+      const activateUrl = import_cement14.URI.from(store);
       let maxScore = 0;
       let maxStore;
       for (const { value } of this._remotes.values()) {
@@ -3033,19 +2996,19 @@ var AttachedRemotesImpl = class {
     const gws = {
       car: {
         ...gwp.car,
-        url: ensureURIDefaults(this.loadable.sthis, attached.name, gwp.car.url, import_cement13.URI.from(gwp.car.url), "car")
+        url: ensureURIDefaults(this.loadable.sthis, attached.name, gwp.car.url, import_cement14.URI.from(gwp.car.url), "car")
       },
       file: {
         ...gwp.file,
-        url: ensureURIDefaults(this.loadable.sthis, attached.name, void 0, import_cement13.URI.from(gwp.file.url), "file", { file: true })
+        url: ensureURIDefaults(this.loadable.sthis, attached.name, void 0, import_cement14.URI.from(gwp.file.url), "file", { file: true })
       },
       meta: {
         ...gwp.meta,
-        url: ensureURIDefaults(this.loadable.sthis, attached.name, void 0, import_cement13.URI.from(gwp.meta.url), "meta")
+        url: ensureURIDefaults(this.loadable.sthis, attached.name, void 0, import_cement14.URI.from(gwp.meta.url), "meta")
       },
       wal: gwp.wal ? {
         ...gwp.wal,
-        url: ensureURIDefaults(this.loadable.sthis, attached.name, void 0, import_cement13.URI.from(gwp.wal.url), "wal")
+        url: ensureURIDefaults(this.loadable.sthis, attached.name, void 0, import_cement14.URI.from(gwp.wal.url), "wal")
       } : void 0
     };
     const key = JSON.stringify(
@@ -3086,7 +3049,7 @@ function carLogIncludesGroup(list, cids) {
     (arr) => cidSet === arr.map((cid) => cid.toString()).sort().join(",")
   );
 }
-function uniqueCids(list, remove = new import_cement14.LRUSet()) {
+function uniqueCids(list, remove = new import_cement15.LRUSet()) {
   const byString = /* @__PURE__ */ new Map();
   for (const cid of list) {
     if (remove.has(cid.toString())) continue;
@@ -3100,7 +3063,7 @@ var Loader = class {
     this.isCompacting = false;
     this.maxConcurrentWrite = (0, import_p_limit.default)(1);
     this.carLog = new CarLog();
-    this.onceReady = new import_cement14.ResolveOnce();
+    this.onceReady = new import_cement15.ResolveOnce();
     this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
       sthis,
@@ -3111,15 +3074,15 @@ var Loader = class {
       "Loader"
     );
     this.logger = ensureLogger(sthis, "Loader");
-    this.cidCache = new import_cement14.KeyedResolvOnce({
+    this.cidCache = new import_cement15.KeyedResolvOnce({
       lru: {
         maxEntries: parseInt(this.ebOpts.storeUrls.car.getParam(PARAM.CAR_CACHE_SIZE, "1000"), 10)
       }
     });
-    this.seenMeta = new import_cement14.LRUSet({
+    this.seenMeta = new import_cement15.LRUSet({
       maxEntries: parseInt(this.ebOpts.storeUrls.meta.getParam(PARAM.CAR_META_CACHE_SIZE, "1000"), 10)
     });
-    this.seenCompacted = new import_cement14.LRUSet({
+    this.seenCompacted = new import_cement15.LRUSet({
       maxEntries: parseInt(this.ebOpts.storeUrls.car.getParam(PARAM.CAR_COMPACT_CACHE_SIZE, "1000"), 10)
     });
     this.maxConcurrentCarReader = (0, import_p_limit.default)(parseInt(this.ebOpts.storeUrls.car.getParam(PARAM.CAR_PARALLEL, "5"), 10));
@@ -3424,7 +3387,7 @@ var Loader = class {
     if (!loadedCar) {
       throw this.logger.Error().Url(store.local().url()).Str("cid", carCidStr).Msg("missing car files").AsError();
     }
-    const bytes = await decode({ bytes: loadedCar.bytes, hasher: import_sha24.sha256, codec: (await activeStore.keyedCrypto()).codec() });
+    const bytes = await decode2({ bytes: loadedCar.bytes, hasher: import_sha25.sha256, codec: (await activeStore.keyedCrypto()).codec() });
     const rawReader = await import_reader.CarReader.fromBytes(bytes.value.data);
     const blocks = [];
     for await (const block of rawReader.blocks()) {
@@ -3465,7 +3428,7 @@ __export(keyed_crypto_exports, {
   keyedCryptoFactory: () => keyedCryptoFactory
 });
 var import_base583 = require("multiformats/bases/base58");
-var import_sha25 = require("multiformats/hashes/sha2");
+var import_sha26 = require("multiformats/hashes/sha2");
 var CBOR = __toESM(require("cborg"), 1);
 var generateIV = {
   random: {
@@ -3480,7 +3443,7 @@ var generateIV = {
   },
   hash: {
     calc: async (ko, crypto, data) => {
-      const hash = await import_sha25.sha256.digest(data);
+      const hash = await import_sha26.sha256.digest(data);
       const hashBytes = new Uint8Array(hash.bytes);
       const hashArray = new Uint8Array(ko.ivLength);
       for (let i = 0; i < hashBytes.length; i++) {
@@ -3668,39 +3631,39 @@ var import_p_retry = __toESM(require("p-retry"), 1);
 var import_p_map = __toESM(require("p-map"), 1);
 
 // src/blockstore/interceptor-gateway.ts
-var import_cement15 = require("@adviser/cement");
+var import_cement16 = require("@adviser/cement");
 var PassThroughGateway = class {
   async buildUrl(ctx, url, key) {
     const op = { url, key };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async start(ctx, url) {
     const op = { url };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async close(ctx, url) {
     const op = { url };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async delete(ctx, url) {
     const op = { url };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async destroy(ctx, url) {
     const op = { url };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async put(ctx, url, body) {
     const op = { url, body };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async get(ctx, url) {
     const op = { url };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
   async subscribe(ctx, url, callback) {
     const op = { url, callback };
-    return import_cement15.Result.Ok({ op });
+    return import_cement16.Result.Ok({ op });
   }
 };
 var passThrougthGateway = new PassThroughGateway();
@@ -3712,7 +3675,7 @@ var InterceptorGateway = class {
   async buildUrl(ctx, baseUrl, key) {
     const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3723,7 +3686,7 @@ var InterceptorGateway = class {
   async destroy(ctx, iurl) {
     const rret = await this.interceptor.destroy(ctx, iurl);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3734,7 +3697,7 @@ var InterceptorGateway = class {
   async start(ctx, url) {
     const rret = await this.interceptor.start(ctx, url);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3745,7 +3708,7 @@ var InterceptorGateway = class {
   async close(ctx, url) {
     const rret = await this.interceptor.close(ctx, url);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3756,7 +3719,7 @@ var InterceptorGateway = class {
   async put(ctx, url, fpEnv) {
     const rret = await this.interceptor.put(ctx, url, fpEnv);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3767,7 +3730,7 @@ var InterceptorGateway = class {
   async get(ctx, url) {
     const rret = await this.interceptor.get(ctx, url);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3777,11 +3740,11 @@ var InterceptorGateway = class {
   }
   async subscribe(ctx, url, callback) {
     if (!this.innerGW.subscribe) {
-      return import_cement15.Result.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+      return import_cement16.Result.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
     }
     const rret = await this.interceptor.subscribe(ctx, url, callback);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3792,7 +3755,7 @@ var InterceptorGateway = class {
   async delete(ctx, url) {
     const rret = await this.interceptor.delete(ctx, url);
     if (rret.isErr()) {
-      return import_cement15.Result.Err(rret.Err());
+      return import_cement16.Result.Err(rret.Err());
     }
     const ret = rret.unwrap();
     if (ret.stop && ret.value) {
@@ -3808,9 +3771,9 @@ var InterceptorGateway = class {
 // src/blockstore/store.ts
 function guardVersion(url) {
   if (!url.hasParam("version")) {
-    return import_cement16.Result.Err(`missing version: ${url.toString()}`);
+    return import_cement17.Result.Err(`missing version: ${url.toString()}`);
   }
-  return import_cement16.Result.Ok(url);
+  return import_cement17.Result.Ok(url);
 }
 var BaseStoreImpl = class {
   // readonly loader: Loadable;
@@ -3870,7 +3833,7 @@ var BaseStoreImpl = class {
     }
     if (this.ready) {
       const fn = this.ready.bind(this);
-      const ready = await (0, import_cement16.exception2Result)(fn);
+      const ready = await (0, import_cement17.exception2Result)(fn);
       if (ready.isErr()) {
         await this.close();
         return ready;
@@ -3977,7 +3940,7 @@ var MetaStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement16.Result.Ok(void 0);
+    return import_cement17.Result.Ok(void 0);
   }
   async destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4044,7 +4007,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement16.Result.Ok(void 0);
+    return import_cement17.Result.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4069,7 +4032,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     this.storeType = "wal";
     // readonly tag: string = "rwal-base";
     // readonly loader: Loadable;
-    this._ready = new import_cement16.ResolveOnce();
+    this._ready = new import_cement17.ResolveOnce();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
@@ -4246,7 +4209,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement16.Result.Ok(void 0);
+    return import_cement17.Result.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4255,8 +4218,8 @@ var WALStoreImpl = class extends BaseStoreImpl {
 };
 
 // src/blockstore/store-factory.ts
-var onceGateway = new import_cement17.KeyedResolvOnce();
-var gatewayInstances = new import_cement17.KeyedResolvOnce();
+var onceGateway = new import_cement18.KeyedResolvOnce();
+var gatewayInstances = new import_cement18.KeyedResolvOnce();
 async function getStartedGateway(ctx, url) {
   return onceGateway.get(url.toString()).once(async () => {
     const item = getGatewayFactoryItem(url.protocol);
@@ -4269,12 +4232,12 @@ async function getStartedGateway(ctx, url) {
       };
       const res = await ret.gateway.start(ctx, url);
       if (res.isErr()) {
-        return import_cement17.Result.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
+        return import_cement18.Result.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
       }
       ret.url = res.Ok();
-      return import_cement17.Result.Ok(ret);
+      return import_cement18.Result.Ok(ret);
     }
-    return import_cement17.Result.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
+    return import_cement18.Result.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
   });
 }
 async function carStoreFactory(ctx, uai) {
@@ -4378,7 +4341,7 @@ function toStoreRuntime(sthis, endeOpts = {}) {
 
 // src/crdt-helpers.ts
 var import_link2 = require("multiformats/link");
-var import_sha26 = require("multiformats/hashes/sha2");
+var import_sha27 = require("multiformats/hashes/sha2");
 var codec2 = __toESM(require("@ipld/dag-cbor"), 1);
 var import_crdt = require("@fireproof/vendor/@web3-storage/pail/crdt");
 var import_clock3 = require("@fireproof/vendor/@web3-storage/pail/clock");
@@ -4465,7 +4428,7 @@ async function writeDocContent(store, blocks, update, logger) {
     await processFiles(store, blocks, update.value, logger);
     value = { doc: update.value };
   }
-  const block = await encode({ value, hasher: import_sha26.sha256, codec: codec2 });
+  const block = await encode2({ value, hasher: import_sha27.sha256, codec: codec2 });
   blocks.putSync(block.cid, block.bytes);
   return block.cid;
 }
@@ -4496,11 +4459,11 @@ async function processFileset(logger, store, blocks, files) {
       for (const block of fileBlocks) {
         t.putSync(block.cid, block.bytes);
       }
-      files[filename] = { cid, type: file.type, size: file.size };
+      files[filename] = { cid, type: file.type, size: file.size, lastModified: file.lastModified };
     } else {
-      const { cid, type, size, car } = files[filename];
+      const { cid, type, size, car, lastModified } = files[filename];
       if (cid && type && size && car) {
-        files[filename] = { cid, type, size, car };
+        files[filename] = { cid, type, size, car, lastModified };
       }
     }
   }
@@ -4540,15 +4503,21 @@ function readFileset(blocks, files, isPublic = false) {
         fileMeta.url = `https://${fileMeta.cid.toString()}.ipfs.w3s.link/`;
       }
       if (fileMeta.car) {
-        fileMeta.file = async () => await blocks.ebOpts.storeRuntime.decodeFile(
-          {
-            get: async (cid) => {
-              return await blocks.getFile(throwFalsy(fileMeta.car), cid);
-            }
-          },
-          fileMeta.cid,
-          fileMeta
-        );
+        fileMeta.file = async () => {
+          const result = await blocks.ebOpts.storeRuntime.decodeFile(
+            {
+              get: async (cid) => {
+                return await blocks.getFile(throwFalsy(fileMeta.car), cid);
+              }
+            },
+            fileMeta.cid,
+            fileMeta
+          );
+          if (result.isErr()) {
+            throw blocks.logger.Error().Any("error", result.Err()).Any("cid", fileMeta.cid).Msg("Error decoding file").AsError();
+          }
+          return result.unwrap();
+        };
       }
     }
     files[filename] = fileMeta;
@@ -4557,7 +4526,7 @@ function readFileset(blocks, files, isPublic = false) {
 async function getValueFromLink(blocks, link, logger) {
   const block = await blocks.get(link);
   if (!block) throw logger.Error().Str("link", link.toString()).Msg(`Missing linked block`).AsError();
-  const { value } = await decode({ bytes: block.bytes, hasher: import_sha26.sha256, codec: codec2 });
+  const { value } = await decode2({ bytes: block.bytes, hasher: import_sha27.sha256, codec: codec2 });
   const cvalue = {
     ...value,
     cid: link
@@ -4683,14 +4652,14 @@ async function doCompact(blockLog, head, logger) {
 async function getBlock(blocks, cidString) {
   const block = await blocks.get((0, import_link2.parse)(cidString));
   if (!block) throw new Error(`Missing block ${cidString}`);
-  const { cid, value } = await decode({ bytes: block.bytes, codec: codec2, hasher: import_sha26.sha256 });
+  const { cid, value } = await decode2({ bytes: block.bytes, codec: codec2, hasher: import_sha27.sha256 });
   return new Block({ cid, value, bytes: block.bytes });
 }
 
 // src/crdt-clock.ts
 var import_clock4 = require("@fireproof/vendor/@web3-storage/pail/clock");
 var import_crdt2 = require("@fireproof/vendor/@web3-storage/pail/crdt");
-var import_cement18 = require("@adviser/cement");
+var import_cement19 = require("@adviser/cement");
 
 // src/apply-head-queue.ts
 function applyHeadQueue(worker, logger) {
@@ -4747,7 +4716,7 @@ var CRDTClockImpl = class {
     this.zoomers = /* @__PURE__ */ new Map();
     this.watchers = /* @__PURE__ */ new Map();
     this.emptyWatchers = /* @__PURE__ */ new Map();
-    this._ready = new import_cement18.ResolveOnce();
+    this._ready = new import_cement19.ResolveOnce();
     this.sthis = blockstore.sthis;
     this.blockstore = blockstore;
     this.logger = ensureLogger(blockstore.sthis, "CRDTClock");
@@ -4877,7 +4846,7 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 var CRDTImpl = class {
   constructor(sthis, opts) {
     this.indexers = /* @__PURE__ */ new Map();
-    this.onceReady = new import_cement19.ResolveOnce();
+    this.onceReady = new import_cement20.ResolveOnce();
     this.sthis = sthis;
     this.crdt = this;
     this.logger = ensureLogger(sthis, "CRDT");
@@ -5023,7 +4992,7 @@ var Context = class {
 };
 
 // src/ledger.ts
-var ledgers = new import_cement20.KeyedResolvOnce();
+var ledgers = new import_cement21.KeyedResolvOnce();
 function keyConfigOpts(sthis, name, opts) {
   return JSON.stringify(
     toSortedArray({
@@ -5115,7 +5084,7 @@ var LedgerImpl = class {
     this.shells = /* @__PURE__ */ new Set();
     this.context = new Context();
     this._onClosedFns = /* @__PURE__ */ new Map();
-    this._ready = new import_cement20.ResolveOnce();
+    this._ready = new import_cement21.ResolveOnce();
     this.opts = opts;
     this.sthis = sthis;
     this.id = sthis.timeOrderedNextId().str;
@@ -5223,12 +5192,12 @@ function toStoreURIRuntime(sthis, name, sopts) {
   if (!sopts.base) {
     const fp_env = sthis.env.get("FP_STORAGE_URL");
     if (fp_env) {
-      sopts = { ...sopts, base: import_cement20.BuildURI.from(fp_env).setParam(PARAM.URL_GEN, "fromEnv") };
+      sopts = { ...sopts, base: import_cement21.BuildURI.from(fp_env).setParam(PARAM.URL_GEN, "fromEnv") };
     } else {
       sopts = { ...sopts, base: getDefaultURI(sthis).build().setParam(PARAM.URL_GEN, "default") };
     }
   }
-  const base = import_cement20.URI.from(sopts.base);
+  const base = import_cement21.URI.from(sopts.base);
   return {
     idx: {
       car: ensureURIDefaults(sthis, name, sopts.idx?.car ?? sopts.data?.car, base, "car", { idx: true }),
@@ -5269,7 +5238,7 @@ __export(runtime_exports, {
   keysByFingerprint: () => keysByFingerprint,
   mf: () => wait_pr_multiformats_exports,
   registerKeyBagProviderFactory: () => registerKeyBagProviderFactory,
-  runtimeFn: () => import_cement21.runtimeFn,
+  runtimeFn: () => import_cement22.runtimeFn,
   toKeyWithFingerPrint: () => toKeyWithFingerPrint
 });
 
@@ -5284,7 +5253,7 @@ __export(wait_pr_multiformats_exports, {
 var codec_interface_exports = {};
 
 // src/runtime/index.ts
-var import_cement21 = require("@adviser/cement");
+var import_cement22 = require("@adviser/cement");
 
 // src/runtime/gateways/index.ts
 var gateways_exports = {};
@@ -5307,6 +5276,6 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-53": "xxxx"
+  "0.20.0-dev-preview-54": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map