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

package/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/ledger.ts
-import { BuildURI as BuildURI2, KeyedResolvOnce as KeyedResolvOnce6, ResolveOnce as ResolveOnce7, URI as URI13 } from "@adviser/cement";
+import { BuildURI as BuildURI2, KeyedResolvOnce as KeyedResolvOnce5, ResolveOnce as ResolveOnce7, URI as URI13 } from "@adviser/cement";
 
 // src/utils.ts
 import {
@@ -511,70 +511,34 @@ __export(files_exports, {
   decodeFile: () => decodeFile,
   encodeFile: () => encodeFile
 });
-import * as UnixFS from "@ipld/unixfs";
 import * as raw from "multiformats/codecs/raw";
-import { withMaxChunkSize } from "@ipld/unixfs/file/chunker/fixed";
-import { withWidth } from "@ipld/unixfs/file/layout/balanced";
-import { exporter } from "ipfs-unixfs-exporter";
-var queuingStrategy = UnixFS.withCapacity();
-var settings = UnixFS.configure({
-  fileChunkEncoder: raw,
-  smallFileEncoder: raw,
-  chunker: withMaxChunkSize(1024 * 1024),
-  fileLayout: withWidth(1024)
-});
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
-}
+import { CID } from "multiformats/cid";
+import { sha256 as hasher } from "multiformats/hashes/sha2";
+import { exception2Result, Result as Result2, top_uint8 } from "@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 top_uint8(blob);
+  const bytes = raw.encode(data);
+  const hash = await hasher.digest(bytes);
+  const cid = CID.create(1, raw.code, hash);
+  const block = { cid, bytes };
+  return { cid, blocks: [block] };
 }
-async function decodeFile(blocks, cid, meta) {
-  const entry = await 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 Result2.Err(new Error("Invalid block storage"));
+  }
+  return 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 = {};
@@ -591,7 +555,7 @@ import {
   KeyedResolvOnce,
   ResolveOnce as ResolveOnce2,
   ResolveSeq,
-  Result as Result2,
+  Result as Result3,
   runtimeFn as runtimeFn2,
   toCryptoRuntime as toCryptoRuntime2,
   URI as URI3
@@ -721,7 +685,7 @@ async function toKeyWithFingerPrint(keybag, materialStrOrUint8) {
   }
   const key = await keybag.subtleKey(material);
   const fpr = await keybag.rt.crypto.digestSHA256(material);
-  return Result2.Ok({
+  return Result3.Ok({
     key,
     fingerPrint: base58btc2.encode(new Uint8Array(fpr)),
     extract: async () => {
@@ -777,13 +741,13 @@ var keysByFingerprint = class _keysByFingerprint {
     def = !!def;
     const rKfp = await toKeyWithFingerPrint(this.keybag, materialStrOrUint8);
     if (rKfp.isErr()) {
-      return Result2.Err(rKfp);
+      return Result3.Err(rKfp);
     }
     const kfp = rKfp.Ok();
     let found = this.keys[kfp.fingerPrint];
     if (found) {
       if (found.default === def) {
-        return Result2.Ok({
+        return Result3.Ok({
           modified: false,
           kfp: found
         });
@@ -803,7 +767,7 @@ var keysByFingerprint = class _keysByFingerprint {
     if (keyBagAction) {
       this.keybag._upsertNamedKey(this);
     }
-    return Result2.Ok({
+    return Result3.Ok({
       modified: keyBagAction && true,
       kfp: found
     });
@@ -882,24 +846,24 @@ var KeyBag = class {
   async ensureKeyFromUrl(url, keyFactory) {
     const storeKey = url.getParam(PARAM.STORE_KEY);
     if (storeKey === "insecure") {
-      return Result2.Ok(url);
+      return Result3.Ok(url);
     }
     if (!storeKey) {
       const keyName = `@${keyFactory()}@`;
       const ret = await this.getNamedKey(keyName);
       if (ret.isErr()) {
-        return Result2.Err(ret);
+        return Result3.Err(ret);
       }
       const urb = url.build().setParam(PARAM.STORE_KEY, keyName);
-      return Result2.Ok(urb.URI());
+      return Result3.Ok(urb.URI());
     }
     if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
       const ret = await this.getNamedKey(storeKey);
       if (ret.isErr()) {
-        return Result2.Err(ret);
+        return Result3.Err(ret);
       }
     }
-    return Result2.Ok(url);
+    return Result3.Ok(url);
   }
   async toKeysItem(ki) {
     if (!ki) return void 0;
@@ -958,7 +922,7 @@ var KeyBag = class {
         this._namedKeyCache.unget(ksi.name);
       }
       await bag.set(await ksi.asKeysItem());
-      return Result2.Ok(ksi);
+      return Result3.Ok(ksi);
     });
   }
   async _getNamedKey(name, failIfNotFound, material) {
@@ -968,7 +932,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 Result2.Ok(await keysByFingerprint.from(this, named));
+        return Result3.Ok(await keysByFingerprint.from(this, named));
       }
       if (!named && failIfNotFound) {
         this._namedKeyCache.unget(name);
@@ -989,10 +953,10 @@ var KeyBag = class {
       }
       const res = await kp.upsert(keyMaterial, true);
       if (res.isErr()) {
-        return Result2.Err(res);
+        return Result3.Err(res);
       }
       this.logger.Debug().Str("id", id).Str("name", name).Str("fpr", res.Ok().kfp.fingerPrint).Msg("createKey getNamedKey-post");
-      return Result2.Ok(kp);
+      return Result3.Ok(kp);
     });
   }
   async getNamedKey(name, failIfNotFound = false, material) {
@@ -1110,10 +1074,9 @@ var FILESTORE_VERSION = "v0.19-file";
 var INDEXEDDB_VERSION = "v0.19-indexeddb";
 
 // src/runtime/gateways/file/gateway-impl.ts
-import { exception2Result, KeyedResolvOnce as KeyedResolvOnce2, Result as Result3 } from "@adviser/cement";
+import { exception2Result as exception2Result2, KeyedResolvOnce as KeyedResolvOnce2, Result as Result4 } from "@adviser/cement";
 
 // src/runtime/gateways/file/utils.ts
-import { getStore as getStore2 } from "@fireproof/core";
 function getPath(url, sthis) {
   const basePath = url.pathname;
   const name = url.getParam("name");
@@ -1125,7 +1088,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 = getStore2(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);
@@ -1165,7 +1128,7 @@ var FileGateway = class {
     });
   }
   start(baseURL, sthis) {
-    return exception2Result(async () => {
+    return exception2Result2(async () => {
       await this.fs.start();
       const url = baseURL.build();
       url.defParam(PARAM.VERSION, FILESTORE_VERSION);
@@ -1179,10 +1142,10 @@ var FileGateway = class {
     });
   }
   async buildUrl(baseUrl, key) {
-    return Result3.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI());
+    return Result4.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI());
   }
   async close() {
-    return Result3.Ok(void 0);
+    return Result4.Ok(void 0);
   }
   getFilePath(url, sthis) {
     const key = url.getParam(PARAM.KEY);
@@ -1190,7 +1153,7 @@ var FileGateway = class {
     return sthis.pathOps.join(getPath(url, sthis), getFileName(url, sthis));
   }
   async put(url, bytes, sthis) {
-    return exception2Result(async () => {
+    return exception2Result2(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);
@@ -1202,17 +1165,17 @@ var FileGateway = class {
       try {
         sthis.logger.Debug().Url(url).Str("file", file).Msg("get");
         const res = await this.fs.readfile(file);
-        return Result3.Ok(res);
+        return Result4.Ok(res);
       } catch (e) {
         if (isNotFoundError(e)) {
-          return Result3.Err(new NotFoundError(`file not found: ${file}`));
+          return Result4.Err(new NotFoundError(`file not found: ${file}`));
         }
-        return Result3.Err(e);
+        return Result4.Err(e);
       }
     });
   }
   async delete(url, sthis) {
-    return exception2Result(async () => {
+    return exception2Result2(async () => {
       await this.fs.unlink(this.getFilePath(url, sthis));
     });
   }
@@ -1238,7 +1201,7 @@ var FileGateway = class {
         }
       }
     }
-    return Result3.Ok(void 0);
+    return Result4.Ok(void 0);
   }
   async getPlain(iurl, key, sthis) {
     const url = iurl.build().setParam(PARAM.KEY, key).URI();
@@ -1246,7 +1209,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 Result3.Ok(buffer);
+    return Result4.Ok(buffer);
   }
 };
 
@@ -1255,7 +1218,7 @@ var gateway_exports = {};
 __export(gateway_exports, {
   MemoryGateway: () => MemoryGateway
 });
-import { Result as Result4 } from "@adviser/cement";
+import { Result as Result5 } from "@adviser/cement";
 
 // src/runtime/gateways/memory/version.ts
 var MEMORY_VERSION = "v0.19-memory";
@@ -1268,14 +1231,14 @@ var MemoryGateway = class {
     this.sthis = sthis;
   }
   buildUrl(baseUrl, key) {
-    return Promise.resolve(Result4.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI()));
+    return Promise.resolve(Result5.Ok(baseUrl.build().setParam(PARAM.KEY, key).URI()));
   }
   start(baseUrl) {
-    return Promise.resolve(Result4.Ok(baseUrl.build().setParam(PARAM.VERSION, MEMORY_VERSION).URI()));
+    return Promise.resolve(Result5.Ok(baseUrl.build().setParam(PARAM.VERSION, MEMORY_VERSION).URI()));
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   close(baseUrl) {
-    return Promise.resolve(Result4.Ok(void 0));
+    return Promise.resolve(Result5.Ok(void 0));
   }
   destroy(baseUrl) {
     const keyUrl = baseUrl.toString();
@@ -1285,38 +1248,38 @@ var MemoryGateway = class {
       }
     }
     this.memorys.clear();
-    return Promise.resolve(Result4.Ok(void 0));
+    return Promise.resolve(Result5.Ok(void 0));
   }
   async put(url, bytes) {
     this.memorys.set(url.toString(), bytes);
-    return Result4.Ok(void 0);
+    return Result5.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(Result4.Err(new NotFoundError(`not found: ${url.toString()}`)));
+      return Promise.resolve(Result5.Err(new NotFoundError(`not found: ${url.toString()}`)));
     }
-    return Promise.resolve(Result4.Ok(x));
+    return Promise.resolve(Result5.Ok(x));
   }
   delete(url) {
     this.memorys.delete(url.toString());
-    return Promise.resolve(Result4.Ok(void 0));
+    return Promise.resolve(Result5.Ok(void 0));
   }
   async getPlain(url, key) {
     const x = this.memorys.get(url.build().setParam(PARAM.KEY, key).toString());
     if (!x) {
-      return Result4.Err(new NotFoundError("not found"));
+      return Result5.Err(new NotFoundError("not found"));
     }
-    return Result4.Ok(x);
+    return Result5.Ok(x);
   }
 };
 
 // src/runtime/gateways/def-serde-gateway.ts
-import { Result as Result7 } from "@adviser/cement";
+import { Result as Result8 } from "@adviser/cement";
 
 // src/blockstore/fp-envelope.ts
-import { Result as Result5 } from "@adviser/cement";
+import { Result as Result6 } from "@adviser/cement";
 var FPEnvelopeTypes = {
   CAR: "car",
   FILE: "file",
@@ -1324,17 +1287,17 @@ var FPEnvelopeTypes = {
   WAL: "wal"
 };
 function Car2FPMsg(fpcar) {
-  return Result5.Ok({ type: FPEnvelopeTypes.CAR, payload: fpcar });
+  return Result6.Ok({ type: FPEnvelopeTypes.CAR, payload: fpcar });
 }
 function File2FPMsg(fpfile) {
-  return Result5.Ok({ type: FPEnvelopeTypes.FILE, payload: fpfile });
+  return Result6.Ok({ type: FPEnvelopeTypes.FILE, payload: fpfile });
 }
 
 // src/runtime/gateways/fp-envelope-serialize.ts
-import { exception2Result as exception2Result2, Result as Result6 } from "@adviser/cement";
+import { exception2Result as exception2Result3, Result as Result7 } from "@adviser/cement";
 import { decodeEventBlock, EventBlock } from "@fireproof/vendor/@web3-storage/pail/clock";
 import { base64pad } from "multiformats/bases/base64";
-import { CID } from "multiformats";
+import { CID as CID2 } from "multiformats";
 import { fromJSON } from "multiformats/link";
 import { format, parse } from "@ipld/dag-json";
 async function dbMetaEvent2Serialized(sthis, dbEvents) {
@@ -1370,10 +1333,10 @@ function WALState2Serialized(sthis, wal) {
   return serializedWAL;
 }
 var defaultEncoder = {
-  car: async (sthis, payload) => Result6.Ok(payload),
-  file: async (sthis, payload) => Result6.Ok(payload),
-  meta: async (sthis, payload) => Result6.Ok(sthis.txt.encode(JSON.stringify(payload))),
-  wal: async (sthis, payload) => Result6.Ok(sthis.txt.encode(JSON.stringify(payload)))
+  car: async (sthis, payload) => Result7.Ok(payload),
+  file: async (sthis, payload) => Result7.Ok(payload),
+  meta: async (sthis, payload) => Result7.Ok(sthis.txt.encode(JSON.stringify(payload))),
+  wal: async (sthis, payload) => Result7.Ok(sthis.txt.encode(JSON.stringify(payload)))
 };
 async function fpSerialize(sthis, env, pencoder) {
   const encoder = {
@@ -1395,20 +1358,20 @@ async function fpSerialize(sthis, env, pencoder) {
 }
 async function decode2DbMetaEvents(sthis, rserializedMeta) {
   if (rserializedMeta.isErr()) {
-    return Result6.Err(rserializedMeta.Err());
+    return Result7.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 Result6.Ok(
+  return Result7.Ok(
     await Promise.all(
       serializedMeta.map(async (metaEntry) => {
         const eventBlock = await decodeEventBlock(base64pad.decode(metaEntry.data));
         const dbMeta = parse(sthis.txt.decode(eventBlock.value.data.dbMeta));
         return {
           eventCid: eventBlock.cid,
-          parents: metaEntry.parents.map((i) => CID.parse(i)),
+          parents: metaEntry.parents.map((i) => CID2.parse(i)),
           dbMeta
         };
       })
@@ -1417,16 +1380,16 @@ async function decode2DbMetaEvents(sthis, rserializedMeta) {
 }
 function toCid(sthis, link) {
   if (typeof link === "string") {
-    return CID.parse(link);
+    return CID2.parse(link);
   }
   return fromJSON(link);
 }
 async function decode2WalState(sthis, rserializedWAL) {
   if (rserializedWAL.isErr()) {
-    return Result6.Err(rserializedWAL.Err());
+    return Result7.Err(rserializedWAL.Err());
   }
   const serializedWAL = rserializedWAL.unwrap();
-  return Result6.Ok({
+  return Result7.Ok({
     fileOperations: (serializedWAL.fileOperations || []).map((fop) => ({
       cid: toCid(sthis, fop.cid),
       public: !!fop.public
@@ -1440,16 +1403,16 @@ async function decode2WalState(sthis, rserializedWAL) {
   });
 }
 var defaultDecoder = {
-  car: async (sthis, payload) => Result6.Ok(payload),
-  file: async (sthis, payload) => Result6.Ok(payload),
-  meta: async (sthis, payload) => exception2Result2(() => JSON.parse(sthis.txt.decode(payload))),
-  wal: async (sthis, payload) => exception2Result2(() => JSON.parse(sthis.txt.decode(payload)))
+  car: async (sthis, payload) => Result7.Ok(payload),
+  file: async (sthis, payload) => Result7.Ok(payload),
+  meta: async (sthis, payload) => exception2Result3(() => JSON.parse(sthis.txt.decode(payload))),
+  wal: async (sthis, payload) => exception2Result3(() => JSON.parse(sthis.txt.decode(payload)))
 };
 function makeFPEnvelope(type, payload) {
   if (payload.isErr()) {
-    return Result6.Err(payload.Err());
+    return Result7.Err(payload.Err());
   }
-  return Result6.Ok({
+  return Result7.Ok({
     type,
     payload: payload.unwrap()
   });
@@ -1457,7 +1420,7 @@ function makeFPEnvelope(type, payload) {
 async function fpDeserialize(sthis, url, intoRaw, pdecoder) {
   const rraw = await coercePromiseIntoUint8(intoRaw);
   if (rraw.isErr()) {
-    return Result6.Err(rraw.Err());
+    return Result7.Err(rraw.Err());
   }
   const raw2 = rraw.unwrap();
   const decoder = {
@@ -1508,12 +1471,12 @@ var DefSerdeGateway = class {
   }
   async get({ loader: { sthis }, decoder }, url) {
     const res = await this.gw.get(url, sthis);
-    if (res.isErr()) return Result7.Err(res.Err());
+    if (res.isErr()) return Result8.Err(res.Err());
     return fpDeserialize(sthis, url, res, decoder);
   }
   async subscribe({ loader: { sthis }, decoder }, url, callback) {
     function rawCallback(raw2) {
-      return fpDeserialize(sthis, url, Result7.Ok(raw2), decoder).then((res) => {
+      return fpDeserialize(sthis, url, Result8.Ok(raw2), decoder).then((res) => {
         if (res.isErr()) {
           sthis.logger.Error().Err(res).Msg("Failed to deserialize");
           return;
@@ -1523,12 +1486,12 @@ var DefSerdeGateway = class {
     }
     if (!this.gw.subscribe) {
       if (!url.hasParam(PARAM.SELF_REFLECT)) {
-        return Result7.Ok(() => {
+        return Result8.Ok(() => {
         });
       }
       const urlWithoutKey = url.build().delParam(PARAM.KEY).delParam(PARAM.SELF_REFLECT).toString();
       this.subscribeFn.set(urlWithoutKey, rawCallback);
-      return Result7.Ok(() => {
+      return Result8.Ok(() => {
         this.subscribeFn.delete(urlWithoutKey);
       });
     }
@@ -1649,58 +1612,58 @@ __export(block_exports, {
   Block: () => Block,
   create: () => create,
   createUnsafe: () => createUnsafe,
-  decode: () => decode,
-  encode: () => encode
+  decode: () => decode2,
+  encode: () => encode2
 });
-import { bytes as binary, CID as CID2 } from "multiformats";
+import { bytes as binary, CID as CID3 } from "multiformats";
 import { Block as mfBlock } from "multiformats/block";
 var Block = mfBlock;
-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 cid = CID2.create(1, codec3.code, hash);
+  const hash = await hasher7.digest(toHash);
+  const cid = CID3.create(1, codec3.code, hash);
   return new mfBlock({ 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 = CID2.create(1, codec3.code, hash);
+  const cid = CID3.create(1, codec3.code, hash);
   return new Block({ value, bytes, cid });
 }
 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 (!binary.equals(cid.multihash.bytes, hash.bytes)) {
     throw new Error("CID hash does not match bytes");
   }
@@ -1727,7 +1690,7 @@ async function createUnsafe({
 }
 
 // src/indexer-helpers.ts
-import { sha256 as hasher } from "multiformats/hashes/sha2";
+import { sha256 as hasher2 } from "multiformats/hashes/sha2";
 import * as codec from "@ipld/dag-cbor";
 import charwise from "charwise";
 import * as DbIndex from "prolly-trees/db-index";
@@ -1748,8 +1711,8 @@ function compare(a, b) {
   if (comp !== 0) return comp;
   return refCompare(aRef, bRef);
 }
-var byKeyOpts = { cache, chunker: bf(30), codec, hasher, compare };
-var byIdOpts = { cache, chunker: bf(30), codec, hasher, compare: simpleCompare };
+var byKeyOpts = { cache, chunker: bf(30), codec, hasher: hasher2, compare };
+var byIdOpts = { cache, chunker: bf(30), codec, hasher: hasher2, compare: simpleCompare };
 function indexEntriesForChanges(changes, mapFn) {
   const indexEntries = [];
   changes.forEach(({ id: key, value, del }) => {
@@ -1777,7 +1740,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, codec });
+    return create({ cid, bytes, hasher: hasher2, codec });
   };
 }
 async function bulkIndex(logger, tblocks, inIndex, indexEntries, opts) {
@@ -2150,6 +2113,9 @@ var DatabaseImpl = class {
     const result = await this.ledger.writeQueue.push({ id, del: true });
     return { id, clock: result?.head, name: this.name };
   }
+  async remove(id) {
+    return this.del(id);
+  }
   async changes(since = [], opts = {}) {
     await this.ready();
     this.logger.Debug().Any("since", since).Any("opts", opts).Msg("changes");
@@ -2216,6 +2182,7 @@ __export(blockstore_exports, {
   MetaActiveStore: () => MetaActiveStore,
   PassThroughGateway: () => PassThroughGateway,
   TaskManager: () => TaskManager,
+  URIInterceptor: () => URIInterceptor,
   WALActiveStore: () => WALActiveStore,
   createAttachedStores: () => createAttachedStores,
   createDbMetaEvent: () => createDbMetaEvent,
@@ -2223,7 +2190,7 @@ __export(blockstore_exports, {
   ensureStoreEnDeFile: () => ensureStoreEnDeFile,
   getDefaultURI: () => getDefaultURI,
   getGatewayFactoryItem: () => getGatewayFactoryItem,
-  getStartedGateway: () => getStartedGateway,
+  getInterceptableGateway: () => getInterceptableGateway,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
   toCIDBlock: () => toCIDBlock,
@@ -2283,10 +2250,10 @@ var WALActiveStore = class extends BaseActiveStore {
 };
 
 // src/blockstore/store-factory.ts
-import { KeyedResolvOnce as KeyedResolvOnce5, Result as Result10 } from "@adviser/cement";
+import { Result as Result11 } from "@adviser/cement";
 
 // src/blockstore/store.ts
-import { exception2Result as exception2Result3, ResolveOnce as ResolveOnce4, Result as Result9 } from "@adviser/cement";
+import { exception2Result as exception2Result4, ResolveOnce as ResolveOnce4, Result as Result9 } from "@adviser/cement";
 
 // src/blockstore/loader.ts
 import pLimit from "p-limit";
@@ -2294,13 +2261,13 @@ import { CarReader } from "@ipld/car/reader";
 import { KeyedResolvOnce as KeyedResolvOnce4, LRUSet, ResolveOnce as ResolveOnce3 } from "@adviser/cement";
 
 // src/blockstore/loader-helpers.ts
-import { sha256 as hasher2 } from "multiformats/hashes/sha2";
+import { sha256 as hasher3 } from "multiformats/hashes/sha2";
 import * as dagCodec from "@ipld/dag-cbor";
 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: hasher2, codec: dagCodec });
+  const dec = await decode2({ bytes: header.bytes, hasher: hasher3, codec: dagCodec });
   const fpvalue = dec.value;
   if (fpvalue && !fpvalue.fp) {
     throw logger.Error().Msg("missing fp").AsError();
@@ -2611,7 +2578,7 @@ async function encodeCarFile(roots, t, codec3) {
     writer.write({ cid, bytes });
   }
   writer.close();
-  return await encode({ value: writer.bytes, hasher: sha256, codec: codec3 });
+  return await encode2({ value: writer.bytes, hasher: sha256, codec: codec3 });
 }
 async function createCarFile(encoder, cid, t) {
   return encodeCarFile([cid], t, encoder);
@@ -2649,7 +2616,7 @@ function makeCarHeader(meta, cars, compact = false) {
   return { ...coreHeader, meta };
 }
 async function encodeCarHeader(fp) {
-  return await encode({
+  return await encode2({
     value: { fp },
     hasher: sha256,
     codec: dagCodec2
@@ -2694,7 +2661,7 @@ async function prepareCarFiles(encoder, threshold, rootBlock, t) {
 }
 
 // src/blockstore/loader.ts
-import { sha256 as hasher3 } from "multiformats/hashes/sha2";
+import { sha256 as hasher4 } from "multiformats/hashes/sha2";
 
 // src/blockstore/task-manager.ts
 var TaskManager = class {
@@ -3374,7 +3341,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: hasher3, codec: (await activeStore.keyedCrypto()).codec() });
+    const bytes = await decode2({ bytes: loadedCar.bytes, hasher: hasher4, codec: (await activeStore.keyedCrypto()).codec() });
     const rawReader = await CarReader.fromBytes(bytes.value.data);
     const blocks = [];
     for await (const block of rawReader.blocks()) {
@@ -3415,7 +3382,7 @@ __export(keyed_crypto_exports, {
   keyedCryptoFactory: () => keyedCryptoFactory
 });
 import { base58btc as base58btc3 } from "multiformats/bases/base58";
-import { sha256 as hasher4 } from "multiformats/hashes/sha2";
+import { sha256 as hasher5 } from "multiformats/hashes/sha2";
 import * as CBOR from "cborg";
 var generateIV = {
   random: {
@@ -3430,7 +3397,7 @@ var generateIV = {
   },
   hash: {
     calc: async (ko, crypto, data) => {
-      const hash = await hasher4.digest(data);
+      const hash = await hasher5.digest(data);
       const hashBytes = new Uint8Array(hash.bytes);
       const hashArray = new Uint8Array(ko.ivLength);
       for (let i = 0; i < hashBytes.length; i++) {
@@ -3616,146 +3583,6 @@ import { EventBlock as EventBlock2 } from "@fireproof/vendor/@web3-storage/pail/
 import { format as format2 } from "@ipld/dag-json";
 import pRetry from "p-retry";
 import pMap from "p-map";
-
-// src/blockstore/interceptor-gateway.ts
-import { Result as Result8 } from "@adviser/cement";
-var PassThroughGateway = class {
-  async buildUrl(ctx, url, key) {
-    const op = { url, key };
-    return Result8.Ok({ op });
-  }
-  async start(ctx, url) {
-    const op = { url };
-    return Result8.Ok({ op });
-  }
-  async close(ctx, url) {
-    const op = { url };
-    return Result8.Ok({ op });
-  }
-  async delete(ctx, url) {
-    const op = { url };
-    return Result8.Ok({ op });
-  }
-  async destroy(ctx, url) {
-    const op = { url };
-    return Result8.Ok({ op });
-  }
-  async put(ctx, url, body) {
-    const op = { url, body };
-    return Result8.Ok({ op });
-  }
-  async get(ctx, url) {
-    const op = { url };
-    return Result8.Ok({ op });
-  }
-  async subscribe(ctx, url, callback) {
-    const op = { url, callback };
-    return Result8.Ok({ op });
-  }
-};
-var passThrougthGateway = new PassThroughGateway();
-var InterceptorGateway = class {
-  constructor(sthis, innerGW, interceptor) {
-    this.innerGW = innerGW;
-    this.interceptor = interceptor || passThrougthGateway;
-  }
-  async buildUrl(ctx, baseUrl, key) {
-    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
-  }
-  async destroy(ctx, iurl) {
-    const rret = await this.interceptor.destroy(ctx, iurl);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.destroy(ctx, ret.op.url);
-  }
-  async start(ctx, url) {
-    const rret = await this.interceptor.start(ctx, url);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return await this.innerGW.start(ctx, ret.op.url);
-  }
-  async close(ctx, url) {
-    const rret = await this.interceptor.close(ctx, url);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return await this.innerGW.close(ctx, ret.op.url);
-  }
-  async put(ctx, url, fpEnv) {
-    const rret = await this.interceptor.put(ctx, url, fpEnv);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
-  }
-  async get(ctx, url) {
-    const rret = await this.interceptor.get(ctx, url);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.get(ctx, ret.op.url);
-  }
-  async subscribe(ctx, url, callback) {
-    if (!this.innerGW.subscribe) {
-      return Result8.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 Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
-  }
-  async delete(ctx, url) {
-    const rret = await this.interceptor.delete(ctx, url);
-    if (rret.isErr()) {
-      return Result8.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.delete(ctx, url);
-  }
-  async getPlain(ctx, url, key) {
-    return this.innerGW.getPlain(ctx, url, key);
-  }
-};
-
-// src/blockstore/store.ts
 function guardVersion(url) {
   if (!url.hasParam("version")) {
     return Result9.Err(`missing version: ${url.toString()}`);
@@ -3776,8 +3603,10 @@ var BaseStoreImpl = class {
       throw logger.Error().Url(this._url).Msg("missing name").AsError();
     }
     this.logger = logger.With().Str("this", this.sthis.nextId().str).Ref("url", () => this._url.toString()).Logger();
-    this.realGateway = opts.gateway;
-    this.gateway = new InterceptorGateway(this.sthis, opts.gateway, opts.gatewayInterceptor);
+    this.gateway = opts.gateway;
+  }
+  get realGateway() {
+    return this.gateway.innerGW;
   }
   url() {
     return this._url;
@@ -3820,7 +3649,7 @@ var BaseStoreImpl = class {
     }
     if (this.ready) {
       const fn = this.ready.bind(this);
-      const ready = await exception2Result3(fn);
+      const ready = await exception2Result4(fn);
       if (ready.isErr()) {
         await this.close();
         return ready;
@@ -4081,7 +3910,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     const retryableUpload = (fn, description) => pRetry(fn, {
       retries: 5,
       onFailedAttempt: (error) => {
-        this.logger.Warn().Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
+        this.logger.Warn().Any("error", error).Any("fn", fn.toString()).Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
       }
     });
     try {
@@ -4204,81 +4033,200 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
 };
 
-// src/blockstore/store-factory.ts
-var onceGateway = new KeyedResolvOnce5();
-var gatewayInstances = new KeyedResolvOnce5();
-async function getStartedGateway(ctx, url) {
-  return onceGateway.get(url.toString()).once(async () => {
-    const item = getGatewayFactoryItem(url.protocol);
-    if (item) {
-      const ret = {
-        url,
-        ...await gatewayInstances.get(url.protocol).once(async () => ({
-          gateway: await item.serdegateway(ctx.loader.sthis)
-        }))
-      };
-      const res = await ret.gateway.start(ctx, url);
-      if (res.isErr()) {
-        return Result10.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
-      }
-      ret.url = res.Ok();
-      return Result10.Ok(ret);
+// src/blockstore/interceptor-gateway.ts
+import { Result as Result10 } from "@adviser/cement";
+var PassThroughGateway = class {
+  async buildUrl(ctx, url, key) {
+    const op = { url, key };
+    return Result10.Ok({ op });
+  }
+  async start(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async close(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async delete(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async destroy(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async put(ctx, url, body) {
+    const op = { url, body };
+    return Result10.Ok({ op });
+  }
+  async get(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async subscribe(ctx, url, callback) {
+    const op = { url, callback };
+    return Result10.Ok({ op });
+  }
+};
+var passThrougthGateway = new PassThroughGateway();
+var InterceptorGateway = class {
+  constructor(sthis, innerGW, interceptor) {
+    this.innerGW = innerGW;
+    this.interceptor = interceptor || passThrougthGateway;
+  }
+  async buildUrl(ctx, baseUrl, key) {
+    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
     }
-    return Result10.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
-  });
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
+  }
+  async destroy(ctx, iurl) {
+    const rret = await this.interceptor.destroy(ctx, iurl);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.destroy(ctx, ret.op.url);
+  }
+  async start(ctx, url) {
+    const rret = await this.interceptor.start(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.start(ctx, ret.op.url);
+  }
+  async close(ctx, url) {
+    const rret = await this.interceptor.close(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.close(ctx, ret.op.url);
+  }
+  async put(ctx, url, fpEnv) {
+    const rret = await this.interceptor.put(ctx, url, fpEnv);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
+  }
+  async get(ctx, url) {
+    const rret = await this.interceptor.get(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.get(ctx, ret.op.url);
+  }
+  async subscribe(ctx, url, callback) {
+    if (!this.innerGW.subscribe) {
+      return Result10.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 Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
+  }
+  async delete(ctx, url) {
+    const rret = await this.interceptor.delete(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.delete(ctx, url);
+  }
+  async getPlain(ctx, url, key) {
+    return this.innerGW.getPlain(ctx, url, key);
+  }
+};
+
+// src/blockstore/store-factory.ts
+async function getInterceptableGateway(ctx, url, opt) {
+  const item = getGatewayFactoryItem(url.protocol);
+  if (item) {
+    return Result11.Ok(new InterceptorGateway(ctx.loader.sthis, await item.serdegateway(ctx.loader.sthis), opt.gatewayInterceptor));
+  }
+  return Result11.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
 }
 async function carStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "car").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new CarStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new CarStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function fileStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "file").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new FileStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new FileStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function metaStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "meta").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new MetaStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new MetaStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function WALStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "wal").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new WALStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new WALStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
@@ -4326,9 +4274,60 @@ function toStoreRuntime(sthis, endeOpts = {}) {
   };
 }
 
+// src/blockstore/uri-interceptor.ts
+var URIInterceptor = class _URIInterceptor extends PassThroughGateway {
+  static withMapper(mapper) {
+    return new _URIInterceptor().addMapper(mapper);
+  }
+  #uriMapper = /* @__PURE__ */ new Set();
+  addMapper(mapper) {
+    this.#uriMapper.add(mapper);
+    return this;
+  }
+  async #map(uri) {
+    let ret = uri;
+    for (const mapper of this.#uriMapper) {
+      ret = await mapper(ret);
+    }
+    return ret;
+  }
+  async buildUrl(ctx, url, key) {
+    const ret = await super.buildUrl(ctx, await this.#map(url), key);
+    return ret;
+  }
+  async start(ctx, url) {
+    const ret = await super.start(ctx, await this.#map(url));
+    return ret;
+  }
+  async close(ctx, url) {
+    const ret = await super.close(ctx, await this.#map(url));
+    return ret;
+  }
+  async delete(ctx, url) {
+    const ret = await super.delete(ctx, await this.#map(url));
+    return ret;
+  }
+  async destroy(ctx, url) {
+    const ret = await super.destroy(ctx, await this.#map(url));
+    return ret;
+  }
+  async put(ctx, url, body) {
+    const ret = await super.put(ctx, await this.#map(url), body);
+    return ret;
+  }
+  async get(ctx, url) {
+    const ret = await super.get(ctx, await this.#map(url));
+    return ret;
+  }
+  async subscribe(ctx, url, callback) {
+    const ret = await super.subscribe(ctx, await this.#map(url), callback);
+    return ret;
+  }
+};
+
 // src/crdt-helpers.ts
 import { parse as parse2 } from "multiformats/link";
-import { sha256 as hasher5 } from "multiformats/hashes/sha2";
+import { sha256 as hasher6 } from "multiformats/hashes/sha2";
 import * as codec2 from "@ipld/dag-cbor";
 import { put, get, entries, root } from "@fireproof/vendor/@web3-storage/pail/crdt";
 import { EventFetcher, vis } from "@fireproof/vendor/@web3-storage/pail/clock";
@@ -4415,7 +4414,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: hasher5, codec: codec2 });
+  const block = await encode2({ value, hasher: hasher6, codec: codec2 });
   blocks.putSync(block.cid, block.bytes);
   return block.cid;
 }
@@ -4446,11 +4445,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 };
       }
     }
   }
@@ -4490,15 +4489,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;
@@ -4507,7 +4512,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: hasher5, codec: codec2 });
+  const { value } = await decode2({ bytes: block.bytes, hasher: hasher6, codec: codec2 });
   const cvalue = {
     ...value,
     cid: link
@@ -4633,7 +4638,7 @@ async function doCompact(blockLog, head, logger) {
 async function getBlock(blocks, cidString) {
   const block = await blocks.get(parse2(cidString));
   if (!block) throw new Error(`Missing block ${cidString}`);
-  const { cid, value } = await decode({ bytes: block.bytes, codec: codec2, hasher: hasher5 });
+  const { cid, value } = await decode2({ bytes: block.bytes, codec: codec2, hasher: hasher6 });
   return new Block({ cid, value, bytes: block.bytes });
 }
 
@@ -4973,7 +4978,7 @@ var Context = class {
 };
 
 // src/ledger.ts
-var ledgers = new KeyedResolvOnce6();
+var ledgers = new KeyedResolvOnce5();
 function keyConfigOpts(sthis, name, opts) {
   return JSON.stringify(
     toSortedArray({
@@ -5257,7 +5262,7 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-53": "xxxx"
+  "0.20.0-dev-preview-55": "xxxx"
 })[0];
 export {
   CRDTImpl,