@fireproof/core 0.20.0-dev-preview-39 → 0.20.0-dev-preview-41

package/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/ledger.ts
-import { BuildURI as BuildURI2, KeyedResolvOnce as KeyedResolvOnce4, ResolveOnce as ResolveOnce7, URI as URI13 } from "@adviser/cement";
+import { BuildURI as BuildURI3, KeyedResolvOnce as KeyedResolvOnce5, ResolveOnce as ResolveOnce7, URI as URI12 } from "@adviser/cement";
 
 // src/utils.ts
 import {
@@ -60,6 +60,18 @@ function falsyToUndef(value) {
   }
   return value;
 }
+var DataAndMetaAndWalAndBaseStore = class {
+  constructor(dam) {
+    this.wal = dam.wal;
+    this.file = dam.file;
+    this.car = dam.car;
+    this.meta = dam.meta;
+    this.baseStores = [this.file, this.car, this.meta];
+    if (this.wal) {
+      this.baseStores.push(this.wal);
+    }
+  }
+};
 
 // src/utils.ts
 import { base58btc } from "multiformats/bases/base58";
@@ -1237,7 +1249,7 @@ var MemoryGateway = class {
   get(url) {
     const x = this.memorys.get(url.toString());
     if (!x) {
-      return Promise.resolve(Result4.Err(new NotFoundError("not found")));
+      return Promise.resolve(Result4.Err(new NotFoundError(`not found: ${url.getParam(PARAM.STORE)}`)));
     }
     return Promise.resolve(Result4.Ok(x));
   }
@@ -1343,9 +1355,6 @@ async function decode2DbMetaEvents(sthis, rserializedMeta) {
   if (!Array.isArray(serializedMeta)) {
     return sthis.logger.Debug().Any("metaEntries", serializedMeta).Msg("No data in MetaEntries").ResultError();
   }
-  if (!serializedMeta.length) {
-    return sthis.logger.Debug().Msg("No MetaEntries found").ResultError();
-  }
   return Result6.Ok(
     await Promise.all(
       serializedMeta.map(async (metaEntry) => {
@@ -2032,6 +2041,9 @@ var DatabaseImpl = class {
     this.id = ledger.id;
     this.logger = ensureLogger(this.sthis, "Database");
   }
+  attach(a) {
+    return this.ledger.attach(a);
+  }
   get name() {
     return this.ledger.name;
   }
@@ -2127,11 +2139,11 @@ import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
 // src/blockstore/index.ts
 var blockstore_exports = {};
 __export(blockstore_exports, {
+  AttachedRemotesImpl: () => AttachedRemotesImpl,
   BaseBlockstoreImpl: () => BaseBlockstoreImpl,
   Car2FPMsg: () => Car2FPMsg,
   CarTransactionImpl: () => CarTransactionImpl,
   CompactionFetcher: () => CompactionFetcher,
-  ConnectionBase: () => ConnectionBase,
   DbMetaEventEqual: () => DbMetaEventEqual,
   DbMetaEventsEqual: () => DbMetaEventsEqual,
   EncryptedBlockstore: () => EncryptedBlockstore,
@@ -2140,6 +2152,7 @@ __export(blockstore_exports, {
   InterceptorGateway: () => InterceptorGateway,
   Loader: () => Loader,
   PassThroughGateway: () => PassThroughGateway,
+  createAttachedStores: () => createAttachedStores,
   createDbMetaEvent: () => createDbMetaEvent,
   defaultGatewayFactoryItem: () => defaultGatewayFactoryItem,
   ensureStoreEnDeFile: () => ensureStoreEnDeFile,
@@ -2164,7 +2177,7 @@ function DbMetaEventsEqual(a, b) {
 }
 
 // src/blockstore/store-factory.ts
-import { KeyedResolvOnce as KeyedResolvOnce3, Result as Result10 } from "@adviser/cement";
+import { KeyedResolvOnce as KeyedResolvOnce4, Result as Result10 } from "@adviser/cement";
 
 // src/blockstore/store.ts
 import { exception2Result as exception2Result3, ResolveOnce as ResolveOnce4, Result as Result9 } from "@adviser/cement";
@@ -2333,7 +2346,7 @@ var EncryptedBlockstore = class extends BaseBlockstoreImpl {
     if (!this.loader) {
       return;
     }
-    return falsyToUndef(await this.loader.getBlock(cid));
+    return falsyToUndef(await this.loader.getBlock(cid, this.loader.attachedStores.local()));
   }
   async transaction(fn, opts = { noLoader: false }) {
     this.logger.Debug().Msg("enter transaction");
@@ -2353,10 +2366,7 @@ var EncryptedBlockstore = class extends BaseBlockstoreImpl {
   async getFile(car, cid) {
     await this.ready();
     if (!this.loader) throw this.logger.Error().Msg("loader required to get file, ledger must be named").AsError();
-    const reader = await this.loader.loadFileCar(
-      car
-      /*, isPublic */
-    );
+    const reader = await this.loader.loadFileCar(car, this.loader.attachedStores.local());
     const block = await reader.get(cid);
     if (!block) throw this.logger.Error().Str("cid", cid.toString()).Msg(`Missing block`).AsError();
     return block.bytes;
@@ -2577,11 +2587,11 @@ var TaskManager = class {
     this.logger = ensureLogger(sthis, "TaskManager");
     this.callback = callback;
   }
-  async handleEvent(cid, parents, dbMeta) {
+  async handleEvent(cid, parents, dbMeta, store) {
     for (const parent of parents) {
       this.eventsWeHandled.add(parent.toString());
     }
-    this.queue.push({ cid: cid.toString(), dbMeta, retries: 0 });
+    this.queue.push({ cid: cid.toString(), dbMeta, retries: 0, store });
     this.queue = this.queue.filter(({ cid: cid2 }) => !this.eventsWeHandled.has(cid2));
     void this.processQueue();
   }
@@ -2595,7 +2605,7 @@ var TaskManager = class {
       return;
     }
     try {
-      await this.callback(first.dbMeta);
+      await this.callback(first.dbMeta, first.store);
       this.eventsWeHandled.add(first.cid);
       this.queue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
     } catch (err) {
@@ -2614,6 +2624,237 @@ var TaskManager = class {
   }
 };
 
+// src/blockstore/attachable-store.ts
+import { KeyedResolvOnce as KeyedResolvOnce3, BuildURI as BuildURI2, isCoerceURI } from "@adviser/cement";
+var AttachedImpl = class {
+  constructor(gws, stores, unreg) {
+    this.gatewayUrls = gws;
+    this.stores = new DataAndMetaAndWalAndBaseStore(stores);
+    this.unreg = unreg;
+  }
+  async detach() {
+    const toClose = [this.stores.car.close(), this.stores.file.close(), this.stores.meta.close()];
+    if (this.stores.wal) {
+      toClose.push(this.stores.wal.close());
+    }
+    await Promise.all(toClose);
+    this.unreg();
+  }
+  status() {
+    return "attached";
+  }
+};
+var DataActiveStoreImpl = class {
+  constructor(ref, active, attached) {
+    this.ref = ref;
+    this.active = active;
+    this.attached = attached;
+  }
+};
+var CarAttachedStoresImpl = class {
+  constructor(attached) {
+    this.attached = attached;
+  }
+  local() {
+    return this.attached.local().active.car;
+  }
+  remotes() {
+    return this.attached.remotes().map(({ active }) => active.car);
+  }
+};
+var FileAttachedStoresImpl = class {
+  constructor(attached) {
+    this.attached = attached;
+  }
+  local() {
+    return this.attached.local().active.file;
+  }
+  remotes() {
+    return this.attached.remotes().map(({ active }) => active.file);
+  }
+};
+var MetaActiveStoreImpl = class {
+  constructor(ref, active, attached) {
+    this.ref = ref;
+    this.active = active;
+    this.attached = attached;
+  }
+};
+var MetaAttachedStoresImpl = class {
+  constructor(attached) {
+    this.attached = attached;
+  }
+  local() {
+    return this.attached.local().active.meta;
+  }
+  remotes() {
+    return this.attached.remotes().map(({ active }) => active.meta);
+  }
+};
+var WALActiveStoreImpl = class {
+  constructor(ref, active, attached) {
+    this.ref = ref;
+    this.active = active;
+    this.attached = attached;
+  }
+};
+var WALAttachedStoresImpl = class {
+  constructor(attached) {
+    this.attached = attached;
+  }
+  local() {
+    return this.attached.local().active.wal;
+  }
+  remotes() {
+    return this.attached.remotes().filter(({ active }) => active.wal).map(({ active }) => active.wal);
+  }
+};
+var ActiveStoreImpl = class {
+  constructor(active, attached) {
+    this.active = active;
+    this.attached = attached;
+  }
+  baseStores() {
+    const bs = [this.active.car, this.active.file, this.active.meta];
+    if (this.active.wal) {
+      bs.push(this.active.wal);
+    }
+    return bs;
+  }
+  carStore() {
+    return new DataActiveStoreImpl(this, this.active.car, new CarAttachedStoresImpl(this.attached));
+  }
+  fileStore() {
+    return new DataActiveStoreImpl(this, this.active.file, new FileAttachedStoresImpl(this.attached));
+  }
+  metaStore() {
+    return new MetaActiveStoreImpl(this, this.active.meta, new MetaAttachedStoresImpl(this.attached));
+  }
+  walStore() {
+    if (!this.active.wal) {
+      throw this.attached.loadable.sthis.logger.Error().Msg("wal store not set").AsError();
+    }
+    return new WALActiveStoreImpl(this, this.active.wal, new WALAttachedStoresImpl(this.attached));
+  }
+};
+function isLoadable(unknown) {
+  return !!unknown.sthis && !!unknown.attachedStores;
+}
+async function createAttachedStores(urlOrGup, arOrLoadable, name = "local") {
+  let ar;
+  if (!isLoadable(arOrLoadable)) {
+    ar = arOrLoadable;
+  } else {
+    ar = arOrLoadable.attachedStores;
+  }
+  let gup;
+  if (!urlOrGup) {
+    throw new Error("urlOrGup is required");
+  }
+  if (isCoerceURI(urlOrGup)) {
+    const url = urlOrGup;
+    gup = {
+      car: { url },
+      file: { url },
+      meta: { url },
+      wal: { url }
+    };
+  } else {
+    gup = urlOrGup;
+  }
+  return await ar.attach({
+    name,
+    prepare: async () => gup
+  });
+}
+var AttachedRemotesImpl = class {
+  constructor(loadable) {
+    this._remotes = new KeyedResolvOnce3();
+    this.loadable = loadable;
+  }
+  forRemotes(action) {
+    return Promise.all(this.remotes().map((i) => action(i))).then(() => void 0);
+  }
+  remotes() {
+    return this._remotes.values().filter(({ value }) => value.isOk() && !value.Ok().stores.wal).map(({ value }) => value.Ok().stores).map((i) => this.activate(i));
+  }
+  local() {
+    if (!this._local) {
+      throw this.loadable.sthis.logger.Error().Msg("local store not set").AsError();
+    }
+    return new ActiveStoreImpl(this._local.stores, this);
+  }
+  activate(store) {
+    if (isCoerceURI(store)) {
+      throw this.loadable.sthis.logger.Error().Msg("store must be an object").AsError();
+    }
+    return new ActiveStoreImpl(store, this);
+  }
+  async detach() {
+    await Promise.all(
+      this._remotes.values().map(async ({ value: rvalue }) => {
+        if (rvalue.isOk()) {
+          await rvalue.Ok().detach();
+        }
+      })
+    );
+  }
+  async attach(attached) {
+    const gwp = await attached.prepare();
+    const gws = {
+      car: {
+        ...gwp.car,
+        url: BuildURI2.from(gwp.car.url).defParam("name", attached.name).URI()
+      },
+      file: {
+        ...gwp.file,
+        url: BuildURI2.from(gwp.file.url).defParam("name", attached.name).URI()
+      },
+      meta: {
+        ...gwp.meta,
+        url: BuildURI2.from(gwp.meta.url).defParam("name", attached.name).URI()
+      },
+      wal: gwp.wal ? {
+        ...gwp.wal,
+        url: BuildURI2.from(gwp.wal.url).defParam("name", attached.name).URI()
+      } : void 0
+    };
+    const key = JSON.stringify(
+      toSortedArray({
+        carUrl: gws.car.url.toString(),
+        filesUrl: gws.file.url.toString(),
+        metaUrl: gws.meta.url.toString(),
+        walUrl: gws.wal?.url.toString()
+      })
+    );
+    return this._remotes.get(key).once(async () => {
+      const rt = toStoreRuntime(this.loadable.sthis);
+      const result = new AttachedImpl(
+        gws,
+        await rt.makeStores({
+          byStore: gws,
+          loader: this.loadable
+        }),
+        // {
+        //   car: await rt.makeDataStore({ url: gws.carUrl, loader: this.loadable }),
+        //   file: await rt.makeDataStore({ url: gws.filesUrl, loader: this.loadable }),
+        //   meta: await rt.makeMetaStore({ url: gws.metaUrl, loader: this.loadable }),
+        // },
+        () => {
+          this._remotes.unget(key);
+        }
+      );
+      if (result.stores.wal) {
+        if (this._local) {
+          throw this.loadable.sthis.logger.Error().Msg("local store could only set once").AsError();
+        }
+        this._local = result;
+      }
+      return result;
+    });
+  }
+};
+
 // src/blockstore/loader.ts
 function carLogIncludesGroup(list, cids) {
   return list.some((arr) => {
@@ -2639,10 +2880,6 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = pLimit(1);
-    this._carStore = new ResolveOnce3();
-    this._fileStore = new ResolveOnce3();
-    this._WALStore = new ResolveOnce3();
-    this._metaStore = new ResolveOnce3();
     this.onceReady = new ResolveOnce3();
     this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
@@ -2654,75 +2891,93 @@ var Loader = class {
       "Loader"
     );
     this.logger = this.ebOpts.logger;
-    this.taskManager = new TaskManager(sthis, async (dbMeta) => {
-      await this.handleDbMetasFromStore([dbMeta]);
+    this.taskManager = new TaskManager(sthis, async (dbMeta, activeStore) => {
+      await this.handleDbMetasFromStore([dbMeta], activeStore);
     });
-  }
-  async carStore() {
-    return this._carStore.once(
-      async () => this.ebOpts.storeRuntime.makeDataStore({
-        // sthis: this.sthis,
-        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
-        url: this.ebOpts.storeUrls.data,
-        // keybag: await this.keyBag(),
-        loader: this
-      })
-    );
-  }
-  async fileStore() {
-    return this._fileStore.once(
-      async () => this.ebOpts.storeRuntime.makeDataStore({
-        // sthis: this.sthis,
-        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
-        url: this.ebOpts.storeUrls.file,
-        // keybag: await this.keyBag(),
-        loader: this
-      })
-    );
-  }
-  async WALStore() {
-    return this._WALStore.once(
-      async () => this.ebOpts.storeRuntime.makeWALStore({
-        // sthis: this.sthis,
-        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
-        url: this.ebOpts.storeUrls.wal,
-        // keybag: await this.keyBag(),
-        loader: this
-      })
-    );
-  }
-  async metaStore() {
-    return this._metaStore.once(
-      async () => this.ebOpts.storeRuntime.makeMetaStore({
-        // sthis: this.sthis,
-        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
-        url: this.ebOpts.storeUrls.meta,
-        // keybag: await this.keyBag(),
-        loader: this
-      })
-    );
-  }
+    this.attachedStores = new AttachedRemotesImpl(this);
+  }
+  attach(attached) {
+    return this.attachedStores.attach(attached);
+  }
+  // private readonly _carStore = new ResolveOnce<DataStore>();
+  // async carStore(): Promise<DataStore> {
+  //   return this._carStore.once(async () =>
+  //     this.ebOpts.storeRuntime.makeDataStore({
+  //       // sthis: this.sthis,
+  //       gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+  //       url: this.ebOpts.storeUrls.data,
+  //       // keybag: await this.keyBag(),
+  //       loader: this,
+  //     }),
+  //   );
+  // }
+  // private readonly _fileStore = new ResolveOnce<DataStore>();
+  // async fileStore(): Promise<DataStore> {
+  //   return this._fileStore.once(async () =>
+  //     this.ebOpts.storeRuntime.makeDataStore({
+  //       // sthis: this.sthis,
+  //       gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+  //       url: this.ebOpts.storeUrls.file,
+  //       // keybag: await this.keyBag(),
+  //       loader: this,
+  //     }),
+  //   );
+  // }
+  // private readonly _WALStore = new ResolveOnce<WALStore>();
+  // async WALStore(): Promise<WALStore> {
+  //   return this._WALStore.once(async () =>
+  //     this.ebOpts.storeRuntime.makeWALStore({
+  //       // sthis: this.sthis,
+  //       gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+  //       url: this.ebOpts.storeUrls.wal,
+  //       // keybag: await this.keyBag(),
+  //       loader: this,
+  //     }),
+  //   );
+  // }
+  // private readonly _metaStore = new ResolveOnce<MetaStore>();
+  // async metaStore(): Promise<MetaStore> {
+  //   return this._metaStore.once(async () =>
+  //     this.ebOpts.storeRuntime.makeMetaStore({
+  //       // sthis: this.sthis,
+  //       gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+  //       url: this.ebOpts.storeUrls.meta,
+  //       // keybag: await this.keyBag(),
+  //       loader: this,
+  //     }),
+  //   );
+  // }
   keyBag() {
     return getKeyBag(this.sthis, this.ebOpts.keyBag);
   }
   async ready() {
     return this.onceReady.once(async () => {
-      const metas = await (await this.metaStore()).load();
+      await createAttachedStores(
+        {
+          car: { url: this.ebOpts.storeUrls.car, gatewayInterceptor: this.ebOpts.gatewayInterceptor },
+          file: { url: this.ebOpts.storeUrls.file, gatewayInterceptor: this.ebOpts.gatewayInterceptor },
+          meta: { url: this.ebOpts.storeUrls.meta, gatewayInterceptor: this.ebOpts.gatewayInterceptor },
+          wal: { url: this.ebOpts.storeUrls.wal, gatewayInterceptor: this.ebOpts.gatewayInterceptor }
+        },
+        this.attachedStores
+      );
+      const local = this.attachedStores.local();
+      const metas = await local.active.meta.load();
       if (this.ebOpts.meta) {
-        await this.handleDbMetasFromStore([this.ebOpts.meta]);
+        await this.handleDbMetasFromStore([this.ebOpts.meta, ...metas || []], local);
       } else if (metas) {
-        await this.handleDbMetasFromStore(metas);
+        await this.handleDbMetasFromStore(metas, local);
       }
     });
   }
   async close() {
     await this.commitQueue.waitIdle();
-    const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
-    await Promise.all(toClose.map((store) => store.close()));
+    await this.attachedStores.detach();
   }
   async destroy() {
-    const toDestroy = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
-    await Promise.all(toDestroy.map((store) => store.destroy()));
+    await Promise.all(
+      this.attachedStores.local().baseStores().map((store) => store.destroy())
+    );
   }
   // async snapToCar(carCid: AnyLink | string) {
   //   await this.ready
@@ -2734,15 +2989,15 @@ var Loader = class {
   //   await this.getMoreReaders(carHeader.cars)
   //   await this._applyCarHeader(carHeader, true)
   // }
-  async handleDbMetasFromStore(metas) {
+  async handleDbMetasFromStore(metas, activeStore) {
     this.logger.Debug().Any("metas", metas).Msg("handleDbMetasFromStore");
     for (const meta of metas) {
       await this.writeLimit(async () => {
-        await this.mergeDbMetaIntoClock(meta);
+        await this.mergeDbMetaIntoClock(meta, activeStore);
       });
     }
   }
-  async mergeDbMetaIntoClock(meta) {
+  async mergeDbMetaIntoClock(meta, activeStore) {
     if (this.isCompacting) {
       throw this.logger.Error().Msg("cannot merge while compacting").AsError();
     }
@@ -2751,9 +3006,9 @@ var Loader = class {
     if (carLogIncludesGroup(this.carLog, meta.cars)) {
       return;
     }
-    const carHeader = await this.loadCarHeaderFromMeta(meta);
+    const carHeader = await this.loadCarHeaderFromMeta(meta, activeStore);
     carHeader.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
-    await this.getMoreReaders(carHeader.cars.flat());
+    await this.getMoreReaders(carHeader.cars.flat(), activeStore);
     this.carLog = [...uniqueCids([meta.cars, ...this.carLog, ...carHeader.cars], this.seenCompacted)];
     await this.ebOpts.applyMeta?.(carHeader.meta);
   }
@@ -2763,8 +3018,8 @@ var Loader = class {
   //     await this.setKey(key);
   //   }
   // }
-  async loadCarHeaderFromMeta({ cars: cids }) {
-    const reader = await this.loadCar(cids[0]);
+  async loadCarHeaderFromMeta(dbm, astore) {
+    const reader = await this.loadCar(dbm.cars[0], astore);
     return await parseCarFile(reader, this.logger);
   }
   // async _getKey(): Promise<string | undefined> {
@@ -2777,22 +3032,22 @@ var Loader = class {
   // }
   async commitFiles(t, done) {
     await this.ready();
-    const fstore = await this.fileStore();
-    const wstore = await this.WALStore();
+    const fstore = this.attachedStores.local().active.file;
+    const wstore = this.attachedStores.local().active.wal;
     return this.commitQueue.enqueue(() => commitFiles(fstore, wstore, t, done));
   }
-  async loadFileCar(cid) {
-    return await this.storesLoadCar(cid, await this.fileStore(), this.remoteFileStore);
+  async loadFileCar(cid, store) {
+    return await this.storesLoadCar(cid, store.fileStore());
   }
   async commit(t, done, opts = { noLoader: false, compact: false }) {
     await this.ready();
-    const carStore = await this.carStore();
+    const carStore = await this.attachedStores.local().active.car;
     const params = {
       encoder: (await carStore.keyedCrypto()).codec(),
       carLog: this.carLog,
       carStore,
-      WALStore: await this.WALStore(),
-      metaStore: await this.metaStore(),
+      WALStore: await this.attachedStores.local().active.wal,
+      metaStore: await this.attachedStores.local().active.meta,
       threshold: this.ebOpts.threshold
     };
     return this.commitQueue.enqueue(async () => {
@@ -2807,7 +3062,7 @@ var Loader = class {
       const previousCompactCid = fp.compact[fp.compact.length - 1];
       fp.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
       this.carLog = [...uniqueCids([...this.carLog, ...fp.cars, cids], this.seenCompacted)];
-      await this.removeCidsForCompact(previousCompactCid[0]).catch((e) => e);
+      await this.removeCidsForCompact(previousCompactCid[0], this.attachedStores.local()).catch((e) => e);
     } else {
       this.carLog.unshift(cids);
     }
@@ -2830,13 +3085,16 @@ var Loader = class {
       }
     }
   }
-  async removeCidsForCompact(cid) {
-    const carHeader = await this.loadCarHeaderFromMeta({
-      cars: [cid]
-    });
+  async removeCidsForCompact(cid, store) {
+    const carHeader = await this.loadCarHeaderFromMeta(
+      {
+        cars: [cid]
+      },
+      store
+    );
     for (const cids of carHeader.compact) {
       for (const cid2 of cids) {
-        await (await this.carStore()).remove(cid2);
+        await this.attachedStores.local().active.car.remove(cid2);
       }
     }
   }
@@ -2860,7 +3118,7 @@ var Loader = class {
       }
       for (const cids of this.carLog) {
         for (const cid of cids) {
-          const reader = await this.loadCar(cid);
+          const reader = await this.loadCar(cid, this.attachedStores.local());
           if (!reader) throw this.logger.Error().Ref("cid", cid).Msg("missing car reader").AsError();
           for await (const block of reader.blocks()) {
             const sCid = block.cid.toString();
@@ -2872,13 +3130,13 @@ var Loader = class {
       }
     }
   }
-  async getBlock(cid) {
+  async getBlock(cid, store) {
     await this.ready();
     const sCid = cid.toString();
     if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
     const getCarCid = async (carCid) => {
       if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
-      const reader = await this.loadCar(carCid);
+      const reader = await this.loadCar(carCid, store);
       if (!reader) {
         throw this.logger.Error().Ref("cid", carCid).Msg("missing car reader").AsError();
       }
@@ -2889,7 +3147,7 @@ var Loader = class {
       throw this.logger.Error().Str("cid", sCid).Msg("block not in reader").AsError();
     };
     const getCompactCarCids = async (carCid) => {
-      const reader = await this.loadCar(carCid);
+      const reader = await this.loadCar(carCid, store);
       if (!reader) {
         throw this.logger.Error().Str("cid", carCid.toString()).Msg("missing car reader").AsError();
       }
@@ -2932,36 +3190,37 @@ var Loader = class {
     }
     return got;
   }
-  async loadCar(cid) {
-    if (!this.carStore) {
-      throw this.logger.Error().Msg("car store not initialized").AsError();
-    }
-    const loaded = await this.storesLoadCar(cid, await this.carStore(), this.remoteCarStore);
+  async loadCar(cid, store) {
+    const loaded = await this.storesLoadCar(cid, store.carStore());
     return loaded;
   }
-  async makeDecoderAndCarReader(cid, local, remote) {
+  async makeDecoderAndCarReader(cid, store) {
     const cidsString = cid.toString();
     let loadedCar = void 0;
-    let activeStore = local;
+    let activeStore = store.attached.local();
     try {
       this.logger.Debug().Any("cid", cidsString).Msg("loading car");
-      loadedCar = await local.load(cid);
+      loadedCar = await store.attached.local().load(cid);
       this.logger.Debug().Bool("loadedCar", loadedCar).Msg("loaded");
     } catch (e) {
-      if (remote) {
+      if (!isNotFoundError(e)) {
+        throw this.logger.Error().Str("cid", cidsString).Err(e).Msg("loading car");
+      }
+      for (const remote of store.attached.remotes()) {
         const remoteCar = await remote.load(cid);
         if (remoteCar) {
           this.logger.Debug().Ref("cid", remoteCar.cid).Msg("saving remote car locally");
-          await local.save(remoteCar);
+          await store.attached.local().save(remoteCar);
           loadedCar = remoteCar;
           activeStore = remote;
+          break;
+        } else {
+          this.logger.Error().Str("cid", cidsString).Err(e).Msg("loading car");
         }
-      } else {
-        this.logger.Error().Str("cid", cidsString).Err(e).Msg("loading car");
       }
     }
     if (!loadedCar) {
-      throw this.logger.Error().Url(local.url()).Str("cid", cidsString).Msg("missing car files").AsError();
+      throw this.logger.Error().Url(store.attached.local().url()).Str("cid", cidsString).Msg("missing car files").AsError();
     }
     const bytes = await decode({ bytes: loadedCar.bytes, hasher: hasher4, codec: (await activeStore.keyedCrypto()).codec() });
     const rawReader = await CarReader.fromBytes(bytes.value);
@@ -2977,19 +3236,19 @@ var Loader = class {
     return readerP;
   }
   //What if instead it returns an Array of CarHeader
-  async storesLoadCar(cid, local, remote) {
+  async storesLoadCar(cid, store) {
     const cidsString = cid.toString();
     let dacr = this.carReaders.get(cidsString);
     if (!dacr) {
-      dacr = this.makeDecoderAndCarReader(cid, local, remote);
+      dacr = this.makeDecoderAndCarReader(cid, store);
       this.carReaders.set(cidsString, dacr);
     }
     return dacr;
   }
-  async getMoreReaders(cids) {
+  async getMoreReaders(cids, store) {
     const limit = pLimit(5);
     const missing = cids.filter((cid) => !this.carReaders.has(cid.toString()));
-    await Promise.all(missing.map((cid) => limit(() => this.loadCar(cid))));
+    await Promise.all(missing.map((cid) => limit(() => this.loadCar(cid, store))));
   }
 };
 
@@ -3360,7 +3619,7 @@ var BaseStoreImpl = class {
   async keyedCrypto() {
     return keyedCryptoFactory(this._url, await this.loader.keyBag(), this.sthis);
   }
-  async start() {
+  async start(dam) {
     this.logger.Debug().Str("storeType", this.storeType).Msg("starting-gateway-pre");
     this._url = this._url.build().setParam(PARAM.STORE, this.storeType).URI();
     const res = await this.gateway.start({ loader: this.loader }, this._url);
@@ -3397,7 +3656,7 @@ var BaseStoreImpl = class {
         return ready;
       }
     }
-    this._onStarted.forEach((fn) => fn());
+    this._onStarted.forEach((fn) => fn(dam));
     this.logger.Debug().Msg("started");
     return version;
   }
@@ -3426,12 +3685,19 @@ var MetaStoreImpl = class extends BaseStoreImpl {
       /*this.remote && */
       opts.gateway.subscribe
     ) {
-      this.onStarted(async () => {
+      this.onStarted(async (dam) => {
         this.logger.Debug().Str("url", this.url().toString()).Msg("Subscribing to the gateway");
         opts.gateway.subscribe({ loader: this.loader }, this.url(), async ({ payload: dbMetas }) => {
           this.logger.Debug().Msg("Received message from gateway");
           await Promise.all(
-            dbMetas.map((dbMeta) => this.loader.taskManager?.handleEvent(dbMeta.eventCid, dbMeta.parents, dbMeta.dbMeta))
+            dbMetas.map(
+              (dbMetaEv) => this.loader.taskManager?.handleEvent(
+                dbMetaEv.eventCid,
+                dbMetaEv.parents,
+                dbMetaEv.dbMeta,
+                this.loader.attachedStores.activate(dam)
+              )
+            )
           );
           this.updateParentsFromDbMetas(dbMetas);
         });
@@ -3466,10 +3732,11 @@ var MetaStoreImpl = class extends BaseStoreImpl {
       }
       throw this.logger.Error().Url(url.Ok()).Err(rfpEnv).Msg("gateway get").AsError();
     }
-    const dbMetas = rfpEnv.Ok().payload;
-    await this.loader.handleDbMetasFromStore(dbMetas.map((m) => m.dbMeta));
-    this.updateParentsFromDbMetas(dbMetas);
-    return dbMetas.map((m) => m.dbMeta);
+    const fpMeta = rfpEnv.Ok().payload;
+    const dbMetas = fpMeta.map((m) => m.dbMeta);
+    await this.loader.handleDbMetasFromStore(dbMetas, this.loader.attachedStores.local());
+    this.updateParentsFromDbMetas(fpMeta);
+    return dbMetas;
   }
   async save(meta, branch) {
     branch = branch || "main";
@@ -3615,7 +3882,6 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
   async process() {
     await this.ready();
-    if (!this.loader.remoteCarStore) return;
     await this.processQueue.enqueue(async () => {
       try {
         await this._doProcess();
@@ -3629,7 +3895,6 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
   async _doProcess() {
     if (!this.loader) return;
-    if (!this.loader.remoteCarStore) return;
     const operations = [...this.walState.operations];
     const noLoaderOps = [...this.walState.noLoaderOps];
     const fileOperations = [...this.walState.fileOperations];
@@ -3650,13 +3915,13 @@ var WALStoreImpl = class extends BaseStoreImpl {
               return;
             }
             for (const cid of dbMeta.cars) {
-              const car = await (await this.loader.carStore()).load(cid);
+              const car = await this.loader.attachedStores.local().active.car.load(cid);
               if (!car) {
                 if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars)) {
                   throw this.logger.Error().Ref("cid", cid).Msg("missing local car").AsError();
                 }
               } else {
-                await throwFalsy(this.loader.remoteCarStore).save(car);
+                await this.loader.attachedStores.forRemotes((x) => x.active.car.save(car));
               }
             }
             inplaceFilter(this.walState.noLoaderOps, (op) => op !== dbMeta);
@@ -3672,13 +3937,13 @@ var WALStoreImpl = class extends BaseStoreImpl {
               return;
             }
             for (const cid of dbMeta.cars) {
-              const car = await (await this.loader.carStore()).load(cid);
+              const car = await this.loader.attachedStores.local().active.car.load(cid);
               if (!car) {
                 if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars)) {
                   throw this.logger.Error().Ref("cid", cid).Msg(`missing local car`).AsError();
                 }
               } else {
-                await throwFalsy(this.loader.remoteCarStore).save(car);
+                await this.loader.attachedStores.forRemotes((x) => x.active.car.save(car));
               }
             }
             inplaceFilter(this.walState.operations, (op) => op !== dbMeta);
@@ -3693,11 +3958,11 @@ var WALStoreImpl = class extends BaseStoreImpl {
             if (!this.loader) {
               return;
             }
-            const fileBlock = await (await this.loader.fileStore()).load(fileCid);
+            const fileBlock = await this.loader.attachedStores.local().active.file.load(fileCid);
             if (!fileBlock) {
               throw this.logger.Error().Ref("cid", fileCid).Msg("missing file block").AsError();
             }
-            await this.loader.remoteFileStore?.save(fileBlock, { public: publicFile });
+            await this.loader.attachedStores.forRemotes((x) => x.active.file.save(fileBlock, { public: publicFile }));
             inplaceFilter(this.walState.fileOperations, (op) => op.cid !== fileCid);
           }, `fileOperation with cid=${fileCid.toString()}`);
         },
@@ -3709,7 +3974,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
           if (!this.loader) {
             return;
           }
-          await this.loader.remoteMetaStore?.save(lastOp);
+          await this.loader.attachedStores.forRemotes((x) => x.active.meta.save(lastOp));
         }, `remoteMetaStore save with dbMeta.cars=${lastOp.cars.toString()}`);
       }
     } catch (error) {
@@ -3762,8 +4027,8 @@ var WALStoreImpl = class extends BaseStoreImpl {
 };
 
 // src/blockstore/store-factory.ts
-var onceGateway = new KeyedResolvOnce3();
-var gatewayInstances = new KeyedResolvOnce3();
+var onceGateway = new KeyedResolvOnce4();
+var gatewayInstances = new KeyedResolvOnce4();
 async function getStartedGateway(ctx, url) {
   return onceGateway.get(url.toString()).once(async () => {
     const item = getGatewayFactoryItem(url.protocol);
@@ -3783,50 +4048,50 @@ async function getStartedGateway(ctx, url) {
     return Result10.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
   });
 }
-async function dataStoreFactory(sfi) {
-  const storeUrl = sfi.url.build().setParam(PARAM.STORE, "data").URI();
-  const rgateway = await getStartedGateway(sfi, storeUrl);
+async function dataStoreFactory(ctx, uai) {
+  const storeUrl = uai.url.build().setParam(PARAM.STORE, "data").URI();
+  const rgateway = await getStartedGateway(ctx, storeUrl);
   if (rgateway.isErr()) {
-    throw sfi.loader.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+    throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new DataStoreImpl(sfi.loader.sthis, gateway.url, {
+  const store = new DataStoreImpl(ctx.loader.sthis, gateway.url, {
     gateway: gateway.gateway,
-    gatewayInterceptor: sfi.gatewayInterceptor,
-    loader: sfi.loader
+    gatewayInterceptor: uai.gatewayInterceptor,
+    loader: ctx.loader
   });
   return store;
 }
-async function metaStoreFactory(sfi) {
-  const storeUrl = sfi.url.build().setParam(PARAM.STORE, "meta").URI();
-  const rgateway = await getStartedGateway(sfi, storeUrl);
+async function metaStoreFactory(ctx, uai) {
+  const storeUrl = uai.url.build().setParam(PARAM.STORE, "meta").URI();
+  const rgateway = await getStartedGateway(ctx, storeUrl);
   if (rgateway.isErr()) {
-    throw sfi.loader.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+    throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new MetaStoreImpl(sfi.loader.sthis, gateway.url, {
+  const store = new MetaStoreImpl(ctx.loader.sthis, gateway.url, {
     gateway: gateway.gateway,
-    gatewayInterceptor: sfi.gatewayInterceptor,
-    loader: sfi.loader
+    gatewayInterceptor: uai.gatewayInterceptor,
+    loader: ctx.loader
   });
   return store;
 }
-async function WALStoreFactory(sfi) {
-  const storeUrl = sfi.url.build().setParam(PARAM.STORE, "wal").URI();
-  const rgateway = await getStartedGateway(sfi, storeUrl);
+async function WALStoreFactory(ctx, uai) {
+  const storeUrl = uai.url.build().setParam(PARAM.STORE, "wal").URI();
+  const rgateway = await getStartedGateway(ctx, storeUrl);
   if (rgateway.isErr()) {
-    throw sfi.loader.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+    throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new WALStoreImpl(sfi.loader.sthis, gateway.url, {
+  const store = new WALStoreImpl(ctx.loader.sthis, gateway.url, {
     gateway: gateway.gateway,
-    gatewayInterceptor: sfi.gatewayInterceptor,
-    loader: sfi.loader
+    gatewayInterceptor: uai.gatewayInterceptor,
+    loader: ctx.loader
   });
   return store;
 }
-async function ensureStart(store) {
-  const ret = await store.start();
+async function ensureStart(store, damaw) {
+  const ret = await store.start(damaw);
   if (ret.isErr()) {
     throw store.logger.Error().Result("start", ret).Msg("start failed").AsError();
   }
@@ -3842,191 +4107,32 @@ function ensureStoreEnDeFile(ende) {
 }
 function toStoreRuntime(sthis, endeOpts = {}) {
   return {
-    makeMetaStore: async (sfi) => ensureStart(await metaStoreFactory(sfi)),
-    // async (loader: Loadable) => {
-    //   logger
-    //     .Debug()
-    //     .Str("fromOpts", "" + !!endeOpts.func?.makeMetaStore)
-    //     .Msg("makeMetaStore");
-    //   return ensureStart(await (endeOpts.func?.makeMetaStore || metaStoreFactory)(loader), logger);
-    // },
-    makeDataStore: async (sfi) => ensureStart(await dataStoreFactory(sfi)),
-    // async (loader: Loadable) => {
-    //   logger
-    //     .Debug()
-    //     .Str("fromOpts", "" + !!endeOpts.func?.makeDataStore)
-    //     .Msg("makeDataStore");
-    //   return ensureStart(await (endeOpts.func?.makeDataStore || dataStoreFactory)(loader), logger);
-    // },
-    makeWALStore: async (sfi) => ensureStart(await WALStoreFactory(sfi)),
-    // async (loader: Loadable) => {
-    //   logger
-    //     .Debug()
-    //     .Str("fromOpts", "" + !!endeOpts.func?.makeWALStore)
-    //     .Msg("makeRemoteWAL");
-    //   return ensureStart(await (endeOpts.func?.makeWALStore || remoteWalFactory)(loader), logger);
-    // },
+    makeStores: async (sfi) => {
+      const ctx = {
+        loader: sfi.loader
+      };
+      const storeSet = {};
+      storeSet.meta = await metaStoreFactory(ctx, sfi.byStore.meta);
+      storeSet.car = await dataStoreFactory(ctx, sfi.byStore.car);
+      storeSet.file = await dataStoreFactory(ctx, sfi.byStore.file);
+      if (sfi.byStore.wal) {
+        storeSet.wal = await WALStoreFactory(ctx, sfi.byStore.wal);
+      }
+      await ensureStart(storeSet.meta, storeSet);
+      await ensureStart(storeSet.car, storeSet);
+      await ensureStart(storeSet.file, storeSet);
+      if (storeSet.wal) {
+        await ensureStart(storeSet.wal, storeSet);
+      }
+      return storeSet;
+    },
+    // makeMetaStore: async (sfi: StoreFactoryItem) => ensureStart(await metaStoreFactory(sfi)),
+    // makeDataStore: async (sfi: StoreFactoryItem) => ensureStart(await dataStoreFactory(sfi)),
+    // makeWALStore: async (sfi: StoreFactoryItem) => ensureStart(await WALStoreFactory(sfi)),
     ...ensureStoreEnDeFile(endeOpts)
   };
 }
 
-// src/blockstore/connection-base.ts
-import { exception2Result as exception2Result4, Future as Future3 } from "@adviser/cement";
-
-// src/blockstore/store-remote.ts
-async function RemoteDataStore(sthis, url, opts) {
-  const ds = new DataStoreImpl(sthis, url, opts);
-  await ds.start();
-  return ds;
-}
-async function RemoteMetaStore(sthis, url, opts) {
-  const ms = new MetaStoreImpl(sthis, url, opts);
-  await ms.start();
-  return ms;
-}
-
-// src/context.ts
-var Context = class {
-  constructor() {
-    this.ctx = /* @__PURE__ */ new Map();
-  }
-  set(key, value) {
-    this.ctx.set(key, value);
-  }
-  get(key) {
-    return this.ctx.get(key);
-  }
-  delete(key) {
-    this.ctx.delete(key);
-  }
-};
-
-// src/blockstore/connection-base.ts
-function coerceLoader(ref) {
-  const refl = ref;
-  if (refl.loader) {
-    return refl.loader;
-  }
-  const refb = ref;
-  if (refb.blockstore) {
-    return coerceLoader(refb.blockstore);
-  }
-  return void 0;
-}
-var ConnectionBase = class {
-  constructor(url, logger) {
-    // loaded: Promise<void> = Promise.resolve();
-    this.context = new Context();
-    this._loaded = /* @__PURE__ */ new Set();
-    this._metaIsLoading = false;
-    this.logger = logger;
-    this.url = url;
-  }
-  loaded() {
-    const f = new Future3();
-    if (!this._metaIsLoading) {
-      f.resolve();
-    } else {
-      this._loaded.add(f);
-    }
-    return f;
-  }
-  async refresh() {
-    await throwFalsy(throwFalsy(this.loader).remoteMetaStore).load();
-    await (await throwFalsy(this.loader).WALStore()).process();
-  }
-  async connect(refl) {
-    await this.connectMeta(refl);
-    await this.connectStorage(refl);
-  }
-  async connectMeta(refl) {
-    const loader = coerceLoader(refl);
-    if (!loader) throw this.logger.Error().Msg("connectMeta: loader is required").AsError();
-    this.loader = loader;
-    await this.onConnect();
-    const metaUrl = this.url.build().defParam(PARAM.STORE, "meta").URI();
-    const rgateway = await getStartedGateway({ loader }, metaUrl);
-    if (rgateway.isErr())
-      throw this.logger.Error().Result("err", rgateway).Url(metaUrl).Msg("connectMeta: gateway is required").AsError();
-    const dbName = metaUrl.getParam(PARAM.NAME);
-    if (!dbName) {
-      throw this.logger.Error().Url(metaUrl).Msg("connectMeta: dbName is required").AsError();
-    }
-    const gateway = rgateway.Ok();
-    const remote = await RemoteMetaStore(loader.sthis, metaUrl, {
-      gateway: gateway.gateway,
-      loader
-    });
-    this.loader.remoteMetaStore = remote;
-    this._metaIsLoading = true;
-    this.loader.ready().then(async () => {
-      return remote.load().then(async () => {
-        const res = await exception2Result4(async () => {
-          return await (await throwFalsy(this.loader).WALStore()).process();
-        });
-        this._metaIsLoading = false;
-        for (const f of this._loaded) {
-          if (res.isErr()) {
-            f.reject(res.Err());
-          } else {
-            f.resolve();
-          }
-        }
-        this._loaded.clear();
-      });
-    });
-  }
-  async connectStorage(refl) {
-    const loader = coerceLoader(refl);
-    if (!loader) throw this.logger.Error().Msg("connectStorage: loader is required").AsError();
-    this.loader = loader;
-    const dataUrl = this.url.build().defParam(PARAM.STORE, "data").URI();
-    const rgateway = await getStartedGateway({ loader }, dataUrl);
-    if (rgateway.isErr())
-      throw this.logger.Error().Result("err", rgateway).Url(dataUrl).Msg("connectStorage: gateway is required").AsError();
-    const name = dataUrl.getParam(PARAM.NAME);
-    if (!name) throw this.logger.Error().Url(dataUrl).Msg("connectStorage: name is required").AsError;
-    loader.remoteCarStore = await RemoteDataStore(loader.sthis, this.url, {
-      gateway: rgateway.Ok().gateway,
-      loader
-    });
-    loader.remoteFileStore = loader.remoteCarStore;
-  }
-  // move this stuff to connect
-  // async getDashboardURL(compact = true) {
-  //   const baseUrl = 'https://dashboard.fireproof.storage/'
-  //   if (!this.loader?.remoteCarStore) return new URL('/howto', baseUrl)
-  //   // if (compact) {
-  //   //   await this.compact()
-  //   // }
-  //   const currents = await this.loader?.metaStore?.load()
-  //   if (!currents) throw new Error("Can't sync empty ledger: save data first")
-  //   if (currents.length > 1)
-  //     throw new Error("Can't sync ledger with split heads: make an update first")
-  //   const current = currents[0]
-  //   const params = {
-  //     car: current.car.toString()
-  //   }
-  //   if (current.key) {
-  //     // @ts-ignore
-  //     params.key = current.key.toString()
-  //   }
-  //   // @ts-ignore
-  //   if (this.name) {
-  //     // @ts-ignore
-  //     params.name = this.name
-  //   }
-  //   const url = new URL('/import#' + new URLSearchParams(params).toString(), baseUrl)
-  //   console.log('Import to dashboard: ' + url.toString())
-  //   return url
-  // }
-  // openDashboard() {
-  //   void this.getDashboardURL().then(url => {
-  //     if (url) window.open(url.toString(), '_blank')
-  //   })
-  // }
-};
-
 // src/crdt-helpers.ts
 import { parse as parse2 } from "multiformats/link";
 import { sha256 as hasher6 } from "multiformats/hashes/sha2";
@@ -4601,8 +4707,24 @@ var CRDTImpl = class {
   }
 };
 
+// src/context.ts
+var Context = class {
+  constructor() {
+    this.ctx = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.ctx.set(key, value);
+  }
+  get(key) {
+    return this.ctx.get(key);
+  }
+  delete(key) {
+    this.ctx.delete(key);
+  }
+};
+
 // src/ledger.ts
-var ledgers = new KeyedResolvOnce4();
+var ledgers = new KeyedResolvOnce5();
 function keyConfigOpts(sthis, name, opts) {
   return JSON.stringify(
     toSortedArray({
@@ -4645,6 +4767,9 @@ var LedgerShell = class {
     this.name = ref.name;
     ref.addShell(this);
   }
+  attach(a) {
+    return this.ref.attach(a);
+  }
   get opts() {
     return this.ref.opts;
   }
@@ -4743,6 +4868,9 @@ var LedgerImpl = class {
     });
     return ret;
   }
+  attach(a) {
+    return this.crdt.blockstore.loader.attach(a);
+  }
   // readonly _asDb = new ResolveOnce<Database>();
   // asDB(): Database {
   //   return this._asDb.once(() => new DatabaseImpl(this));
@@ -4791,7 +4919,7 @@ var LedgerImpl = class {
 };
 function defaultURI2(sthis, name, curi, uri, store, ctx) {
   ctx = ctx || {};
-  const ret = (curi ? URI13.from(curi) : uri).build().setParam(PARAM.STORE, store).defParam(PARAM.NAME, name);
+  const ret = (curi ? URI12.from(curi) : uri).build().setParam(PARAM.STORE, store).defParam(PARAM.NAME, name);
   if (!ret.hasParam(PARAM.NAME)) {
     throw sthis.logger.Error().Url(ret).Any("ctx", ctx).Msg("Ledger name is required").AsError();
   }
@@ -4814,21 +4942,21 @@ function toStoreURIRuntime(sthis, name, sopts) {
   if (!sopts.base) {
     const fp_env = sthis.env.get("FP_STORAGE_URL");
     if (fp_env) {
-      sopts = { ...sopts, base: BuildURI2.from(fp_env).setParam(PARAM.URL_GEN, "fromEnv") };
+      sopts = { ...sopts, base: BuildURI3.from(fp_env).setParam(PARAM.URL_GEN, "fromEnv") };
     } else {
       sopts = { ...sopts, base: getDefaultURI(sthis).build().setParam(PARAM.URL_GEN, "default") };
     }
   }
-  const base = URI13.from(sopts.base);
+  const base = URI12.from(sopts.base);
   return {
     idx: {
-      data: defaultURI2(sthis, name, sopts.idx?.data, base, "data", { idx: true }),
+      car: defaultURI2(sthis, name, sopts.idx?.data, base, "data", { idx: true }),
       file: defaultURI2(sthis, name, sopts.idx?.data, base, "data", { file: true, idx: true }),
       meta: defaultURI2(sthis, name, sopts.idx?.meta, base, "meta", { idx: true }),
       wal: defaultURI2(sthis, name, sopts.idx?.wal, base, "wal", { idx: true })
     },
     data: {
-      data: defaultURI2(sthis, name, sopts.data?.data, base, "data"),
+      car: defaultURI2(sthis, name, sopts.data?.data, base, "data"),
       file: defaultURI2(sthis, name, sopts.data?.data, base, "data", { file: true }),
       meta: defaultURI2(sthis, name, sopts.data?.meta, base, "meta"),
       wal: defaultURI2(sthis, name, sopts.data?.wal, base, "wal")
@@ -4895,10 +5023,11 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-39": "xxxx"
+  "0.20.0-dev-preview-41": "xxxx"
 })[0];
 export {
   CRDTImpl,
+  DataAndMetaAndWalAndBaseStore,
   DatabaseImpl,
   Index,
   LedgerFactory,