@fireproof/core 0.20.0-dev-preview-18 → 0.20.0-dev-preview-20

package/index.cjs

@@ -784,9 +784,9 @@ var keyBagProviderFactories = new Map(
       }
     },
     {
-      protocol: "indexdb:",
+      protocol: "indexeddb:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderImpl } = await import("@fireproof/core/indexdb");
+        const { KeyBagProviderImpl } = await import("@fireproof/core/indexeddb");
         return new KeyBagProviderImpl(url, sthis);
       }
     },
@@ -809,7 +809,7 @@ function defaultKeyBagUrl(sthis) {
   let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
   let url;
   if ((0, import_cement4.runtimeFn)().isBrowser) {
-    url = import_cement4.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
+    url = import_cement4.URI.from(bagFnameOrUrl || "indexeddb://fp-keybag");
   } else {
     if (!bagFnameOrUrl) {
       const home = sthis.env.get("HOME");
@@ -836,7 +836,7 @@ function defaultKeyBagOpts(sthis, kbo) {
   } else {
     let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
     if ((0, import_cement4.runtimeFn)().isBrowser) {
-      url = import_cement4.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
+      url = import_cement4.URI.from(bagFnameOrUrl || "indexeddb://fp-keybag");
     } else {
       if (!bagFnameOrUrl) {
         const home = sthis.env.get("HOME");
@@ -880,8 +880,8 @@ var import_cement10 = require("@adviser/cement");
 // src/runtime/gateways/file/version.ts
 var FILESTORE_VERSION = "v0.19-file";
 
-// src/runtime/gateways/indexdb-version.ts
-var INDEXDB_VERSION = "v0.19-indexdb";
+// src/runtime/gateways/indexeddb-version.ts
+var INDEXEDDB_VERSION = "v0.19-indexeddb";
 
 // src/runtime/gateways/file/gateway-impl.ts
 var import_cement5 = require("@adviser/cement");
@@ -1255,65 +1255,57 @@ var DefSerdeGateway = class {
     this.subscribeFn = /* @__PURE__ */ new Map();
     this.gw = gw;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  start(sthis, baseURL, loader) {
+  start({ loader: { sthis } }, baseURL) {
     return this.gw.start(baseURL, sthis);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async buildUrl(sthis, baseUrl, key, loader) {
+  async buildUrl({ loader: { sthis } }, baseUrl, key) {
     return this.gw.buildUrl(baseUrl, key, sthis);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async close(sthis, uri, loader) {
+  async close({ loader: { sthis } }, uri) {
     return this.gw.close(uri, sthis);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async put(sthis, url, env, loader) {
-    const rUint8 = await fpSerialize(sthis, env);
+  async put({ loader: { sthis }, encoder }, url, env) {
+    const rUint8 = await fpSerialize(sthis, env, encoder);
     if (rUint8.isErr()) return rUint8;
     const ret = this.gw.put(url, rUint8.Ok(), sthis);
     if (env.type === "meta" /* META */) {
       if (this.subscribeFn.has(url.toString())) {
-        this.subscribeFn.get(url.toString())(env);
+        this.subscribeFn.get(url.toString())(rUint8.Ok());
       }
     }
     return ret;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async get(sthis, url, loader) {
+  async get({ loader: { sthis }, decoder }, url) {
     const res = await this.gw.get(url, sthis);
     if (res.isErr()) return import_cement9.Result.Err(res.Err());
-    return fpDeserialize(sthis, url, res);
-  }
-  async subscribe(sthis, url, callback, loader) {
+    return fpDeserialize(sthis, url, res, decoder);
+  }
+  async subscribe({ loader: { sthis }, decoder }, url, callback) {
+    function rawCallback(raw2) {
+      return fpDeserialize(sthis, url, import_cement9.Result.Ok(raw2), decoder).then((res) => {
+        if (res.isErr()) {
+          sthis.logger.Error().Err(res).Msg("Failed to deserialize");
+          return;
+        }
+        callback(res.Ok());
+      });
+    }
     if (!this.gw.subscribe) {
-      this.subscribeFn.set(url.toString(), callback);
+      this.subscribeFn.set(url.toString(), rawCallback);
       return import_cement9.Result.Ok(() => {
         this.subscribeFn.delete(url.toString());
       });
     }
-    const unreg = await this.gw.subscribe(
-      url,
-      (raw2) => {
-        fpDeserialize(sthis, url, import_cement9.Result.Ok(raw2)).then((res) => {
-          if (res.isErr()) return;
-          callback(res.Ok());
-        });
-      },
-      sthis
-    );
+    const unreg = await this.gw.subscribe(url, rawCallback, sthis);
     return unreg;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async delete(sthis, url, loader) {
+  async delete({ loader: { sthis } }, url) {
     return this.gw.delete(url, sthis);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async destroy(sthis, baseURL, loader) {
+  async destroy({ loader: { sthis } }, baseURL) {
     return this.gw.destroy(baseURL, sthis);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async getPlain(sthis, iurl, key, loader) {
+  async getPlain({ loader: { sthis } }, iurl, key) {
     return this.gw.getPlain(iurl, key, sthis);
   }
 };
@@ -1392,13 +1384,13 @@ if ((0, import_cement10.runtimeFn)().isNodeIsh || (0, import_cement10.runtimeFn)
 }
 if ((0, import_cement10.runtimeFn)().isBrowser) {
   registerStoreProtocol({
-    protocol: "indexdb:",
+    protocol: "indexeddb:",
     isDefault: true,
     defaultURI: () => {
-      return import_cement10.BuildURI.from("indexdb://").pathname("fp").setParam("version" /* VERSION */, INDEXDB_VERSION).setParam("runtime" /* RUNTIME */, "browser").URI();
+      return import_cement10.BuildURI.from("indexeddb://").pathname("fp").setParam("version" /* VERSION */, INDEXEDDB_VERSION).setParam("runtime" /* RUNTIME */, "browser").URI();
     },
     gateway: async () => {
-      const { GatewayImpl } = await import("@fireproof/core/indexdb");
+      const { GatewayImpl } = await import("@fireproof/core/indexeddb");
       return new GatewayImpl();
     }
   });
@@ -2487,7 +2479,7 @@ var Loader = class {
   async carStore() {
     return this._carStore.once(
       async () => this.ebOpts.storeRuntime.makeDataStore({
-        sthis: this.sthis,
+        // sthis: this.sthis,
         gatewayInterceptor: this.ebOpts.gatewayInterceptor,
         url: this.ebOpts.storeUrls.data,
         // keybag: await this.keyBag(),
@@ -2498,7 +2490,7 @@ var Loader = class {
   async fileStore() {
     return this._fileStore.once(
       async () => this.ebOpts.storeRuntime.makeDataStore({
-        sthis: this.sthis,
+        // sthis: this.sthis,
         gatewayInterceptor: this.ebOpts.gatewayInterceptor,
         url: this.ebOpts.storeUrls.file,
         // keybag: await this.keyBag(),
@@ -2509,7 +2501,7 @@ var Loader = class {
   async WALStore() {
     return this._WALStore.once(
       async () => this.ebOpts.storeRuntime.makeWALStore({
-        sthis: this.sthis,
+        // sthis: this.sthis,
         gatewayInterceptor: this.ebOpts.gatewayInterceptor,
         url: this.ebOpts.storeUrls.wal,
         // keybag: await this.keyBag(),
@@ -2520,7 +2512,7 @@ var Loader = class {
   async metaStore() {
     return this._metaStore.once(
       async () => this.ebOpts.storeRuntime.makeMetaStore({
-        sthis: this.sthis,
+        // sthis: this.sthis,
         gatewayInterceptor: this.ebOpts.gatewayInterceptor,
         url: this.ebOpts.storeUrls.meta,
         // keybag: await this.keyBag(),
@@ -3000,35 +2992,35 @@ var import_p_map = __toESM(require("p-map"), 1);
 // src/blockstore/interceptor-gateway.ts
 var import_cement14 = require("@adviser/cement");
 var PassThroughGateway = class {
-  async buildUrl(sthis, url, key) {
+  async buildUrl(ctx, url, key) {
     const op = { url, key };
     return import_cement14.Result.Ok({ op });
   }
-  async start(sthis, url) {
+  async start(ctx, url) {
     const op = { url };
     return import_cement14.Result.Ok({ op });
   }
-  async close(sthis, url) {
+  async close(ctx, url) {
     const op = { url };
     return import_cement14.Result.Ok({ op });
   }
-  async delete(sthis, url) {
+  async delete(ctx, url) {
     const op = { url };
     return import_cement14.Result.Ok({ op });
   }
-  async destroy(sthis, url) {
+  async destroy(ctx, url) {
     const op = { url };
     return import_cement14.Result.Ok({ op });
   }
-  async put(sthis, url, body) {
+  async put(ctx, url, body) {
     const op = { url, body };
     return import_cement14.Result.Ok({ op });
   }
-  async get(sthis, url) {
+  async get(ctx, url) {
     const op = { url };
     return import_cement14.Result.Ok({ op });
   }
-  async subscribe(sthis, url, callback) {
+  async subscribe(ctx, url, callback) {
     const op = { url, callback };
     return import_cement14.Result.Ok({ op });
   }
@@ -3039,8 +3031,8 @@ var InterceptorGateway = class {
     this.innerGW = innerGW;
     this.interceptor = interceptor || passThrougthGateway;
   }
-  async buildUrl(sthis, baseUrl, key, loader) {
-    const rret = await this.interceptor.buildUrl(sthis, baseUrl, key, loader);
+  async buildUrl(ctx, baseUrl, key) {
+    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3048,10 +3040,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return this.innerGW.buildUrl(sthis, ret.op.url, ret.op.key, loader);
+    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
   }
-  async destroy(sthis, iurl, loader) {
-    const rret = await this.interceptor.destroy(sthis, iurl, loader);
+  async destroy(ctx, iurl) {
+    const rret = await this.interceptor.destroy(ctx, iurl);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3059,10 +3051,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return this.innerGW.destroy(sthis, ret.op.url, loader);
+    return this.innerGW.destroy(ctx, ret.op.url);
   }
-  async start(sthis, url, loader) {
-    const rret = await this.interceptor.start(sthis, url, loader);
+  async start(ctx, url) {
+    const rret = await this.interceptor.start(ctx, url);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3070,10 +3062,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return await this.innerGW.start(sthis, ret.op.url, loader);
+    return await this.innerGW.start(ctx, ret.op.url);
   }
-  async close(sthis, url, loader) {
-    const rret = await this.interceptor.close(sthis, url, loader);
+  async close(ctx, url) {
+    const rret = await this.interceptor.close(ctx, url);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3081,10 +3073,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return await this.innerGW.close(sthis, ret.op.url, loader);
+    return await this.innerGW.close(ctx, ret.op.url);
   }
-  async put(sthis, url, fpEnv, loader) {
-    const rret = await this.interceptor.put(sthis, url, fpEnv, loader);
+  async put(ctx, url, fpEnv) {
+    const rret = await this.interceptor.put(ctx, url, fpEnv);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3092,10 +3084,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return this.innerGW.put(sthis, ret.op.url, ret.op.body, loader);
+    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
   }
-  async get(sthis, url, loader) {
-    const rret = await this.interceptor.get(sthis, url, loader);
+  async get(ctx, url) {
+    const rret = await this.interceptor.get(ctx, url);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3103,13 +3095,13 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return this.innerGW.get(sthis, ret.op.url, loader);
+    return this.innerGW.get(ctx, ret.op.url);
   }
-  async subscribe(sthis, url, callback, loader) {
+  async subscribe(ctx, url, callback) {
     if (!this.innerGW.subscribe) {
-      return import_cement14.Result.Err(sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+      return import_cement14.Result.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
     }
-    const rret = await this.interceptor.subscribe(sthis, url, callback, loader);
+    const rret = await this.interceptor.subscribe(ctx, url, callback);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3117,10 +3109,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return this.innerGW.subscribe(sthis, ret.op.url, ret.op.callback, loader);
+    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
   }
-  async delete(sthis, url, loader) {
-    const rret = await this.interceptor.delete(sthis, url, loader);
+  async delete(ctx, url) {
+    const rret = await this.interceptor.delete(ctx, url);
     if (rret.isErr()) {
       return import_cement14.Result.Err(rret.Err());
     }
@@ -3128,10 +3120,10 @@ var InterceptorGateway = class {
     if (ret.stop && ret.value) {
       return ret.value;
     }
-    return this.innerGW.delete(sthis, url, loader);
+    return this.innerGW.delete(ctx, url);
   }
-  async getPlain(sthis, url, key, loader) {
-    return this.innerGW.getPlain(sthis, url, key, loader);
+  async getPlain(ctx, url, key) {
+    return this.innerGW.getPlain(ctx, url, key);
   }
 };
 
@@ -3177,7 +3169,7 @@ var BaseStoreImpl = class {
   async start() {
     this.logger.Debug().Str("storeType", this.storeType).Msg("starting-gateway-pre");
     this._url = this._url.build().setParam("store" /* STORE */, this.storeType).URI();
-    const res = await this.gateway.start(this.sthis, this._url, this.loader);
+    const res = await this.gateway.start({ loader: this.loader }, this._url);
     if (res.isErr()) {
       this.logger.Error().Result("gw-start", res).Msg("started-gateway");
       return res;
@@ -3242,18 +3234,13 @@ var MetaStoreImpl = class extends BaseStoreImpl {
     ) {
       this.onStarted(async () => {
         this.logger.Debug().Str("url", this.url().toString()).Msg("Subscribing to the gateway");
-        opts.gateway.subscribe?.(
-          this.sthis,
-          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))
-            );
-            this.updateParentsFromDbMetas(dbMetas);
-          },
-          this.loader
-        );
+        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))
+          );
+          this.updateParentsFromDbMetas(dbMetas);
+        });
       });
     }
   }
@@ -3274,11 +3261,11 @@ var MetaStoreImpl = class extends BaseStoreImpl {
   // }
   async load() {
     const branch = "main";
-    const url = await this.gateway.buildUrl(this.sthis, this.url(), branch, this.loader);
+    const url = await this.gateway.buildUrl({ loader: this.loader }, this.url(), branch);
     if (url.isErr()) {
       throw this.logger.Error().Result("buildUrl", url).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
     }
-    const rfpEnv = await this.gateway.get(this.sthis, url.Ok(), this.loader);
+    const rfpEnv = await this.gateway.get({ loader: this.loader }, url.Ok());
     if (rfpEnv.isErr()) {
       if (isNotFoundError(rfpEnv)) {
         return void 0;
@@ -3293,33 +3280,28 @@ var MetaStoreImpl = class extends BaseStoreImpl {
   async save(meta, branch) {
     branch = branch || "main";
     this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
-    const url = await this.gateway.buildUrl(this.sthis, this.url(), branch, this.loader);
+    const url = await this.gateway.buildUrl({ loader: this.loader }, this.url(), branch);
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
     }
     const dbMetaEvent = await createDbMetaEvent(this.sthis, meta, this.parents);
-    const res = await this.gateway.put(
-      this.sthis,
-      url.Ok(),
-      {
-        type: "meta",
-        payload: [dbMetaEvent]
-      },
-      this.loader
-    );
+    const res = await this.gateway.put({ loader: this.loader }, url.Ok(), {
+      type: "meta",
+      payload: [dbMetaEvent]
+    });
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
     return res;
   }
   async close() {
-    await this.gateway.close(this.sthis, this.url(), this.loader);
+    await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
     return import_cement15.Result.Ok(void 0);
   }
   async destroy() {
     this.logger.Debug().Msg("destroy");
-    return this.gateway.destroy(this.sthis, this.url(), this.loader);
+    return this.gateway.destroy({ loader: this.loader }, this.url());
   }
 };
 var DataStoreImpl = class extends BaseStoreImpl {
@@ -3329,11 +3311,11 @@ var DataStoreImpl = class extends BaseStoreImpl {
   }
   async load(cid) {
     this.logger.Debug().Any("cid", cid).Msg("loading");
-    const url = await this.gateway.buildUrl(this.sthis, this.url(), cid.toString(), this.loader);
+    const url = await this.gateway.buildUrl({ loader: this.loader }, this.url(), cid.toString());
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Str("cid", cid.toString()).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.get(this.sthis, url.Ok(), this.loader);
+    const res = await this.gateway.get({ loader: this.loader }, url.Ok());
     if (res.isErr()) {
       throw res.Err();
     }
@@ -3350,7 +3332,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async save(car, opts) {
     this.logger.Debug().Any("cid", car.cid.toString()).Msg("saving");
-    const url = await this.gateway.buildUrl(this.sthis, this.url(), car.cid.toString(), this.loader);
+    const url = await this.gateway.buildUrl({ loader: this.loader }, this.url(), car.cid.toString());
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Ref("cid", car.cid).Msg("got error from gateway.buildUrl").AsError();
     }
@@ -3369,27 +3351,27 @@ var DataStoreImpl = class extends BaseStoreImpl {
     if (fpMsg.isErr()) {
       throw this.logger.Error().Err(fpMsg).Msg("got error from FPMsg2Car").AsError();
     }
-    const res = await this.gateway.put(this.sthis, url.Ok(), fpMsg.Ok(), this.loader);
+    const res = await this.gateway.put({ loader: this.loader }, url.Ok(), fpMsg.Ok());
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
     return res.Ok();
   }
   async remove(cid) {
-    const url = await this.gateway.buildUrl(this.sthis, this.url(), cid.toString(), this.loader);
+    const url = await this.gateway.buildUrl({ loader: this.loader }, this.url(), cid.toString());
     if (url.isErr()) {
       return url;
     }
-    return this.gateway.delete(this.sthis, url.Ok(), this.loader);
+    return this.gateway.delete({ loader: this.loader }, url.Ok());
   }
   async close() {
-    await this.gateway.close(this.sthis, this.url(), this.loader);
+    await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
     return import_cement15.Result.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
-    return this.gateway.destroy(this.sthis, this.url(), this.loader);
+    return this.gateway.destroy({ loader: this.loader }, this.url());
   }
 };
 var WALStoreImpl = class extends BaseStoreImpl {
@@ -3545,11 +3527,11 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
   async load() {
     this.logger.Debug().Msg("loading");
-    const filepath = await this.gateway.buildUrl(this.sthis, this.url(), "main", this.loader);
+    const filepath = await this.gateway.buildUrl({ loader: this.loader }, this.url(), "main");
     if (filepath.isErr()) {
       throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
     }
-    const bytes = await this.gateway.get(this.sthis, filepath.Ok(), this.loader);
+    const bytes = await this.gateway.get({ loader: this.loader }, filepath.Ok());
     if (bytes.isErr()) {
       if (isNotFoundError(bytes)) {
         return void 0;
@@ -3562,64 +3544,59 @@ var WALStoreImpl = class extends BaseStoreImpl {
     return bytes.Ok().payload;
   }
   async save(state) {
-    const filepath = await this.gateway.buildUrl(this.sthis, this.url(), "main", this.loader);
+    const filepath = await this.gateway.buildUrl({ loader: this.loader }, this.url(), "main");
     if (filepath.isErr()) {
       throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
     }
-    const res = await this.gateway.put(
-      this.sthis,
-      filepath.Ok(),
-      {
-        type: "wal",
-        payload: state
-      },
-      this.loader
-    );
+    const res = await this.gateway.put({ loader: this.loader }, filepath.Ok(), {
+      type: "wal",
+      payload: state
+    });
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
     }
   }
   async close() {
-    await this.gateway.close(this.sthis, this.url(), this.loader);
+    await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
     return import_cement15.Result.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
-    return this.gateway.destroy(this.sthis, this.url(), this.loader);
+    return this.gateway.destroy({ loader: this.loader }, this.url());
   }
 };
 
 // src/blockstore/store-factory.ts
 var onceGateway = new import_cement16.KeyedResolvOnce();
 var gatewayInstances = new import_cement16.KeyedResolvOnce();
-async function getStartedGateway(sthis, url) {
+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(sthis)
+        gateway: await item.serdegateway(ctx.loader.sthis)
       };
-      const res = await ret.gateway.start(sthis, url);
+      const res = await ret.gateway.start(ctx, url);
       if (res.isErr()) {
-        return import_cement16.Result.Err(sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
+        return import_cement16.Result.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
       }
       ret.url = res.Ok();
       return import_cement16.Result.Ok(ret);
     }
-    return import_cement16.Result.Err(sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
+    return import_cement16.Result.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
   });
 }
 async function dataStoreFactory(sfi) {
   const storeUrl = sfi.url.build().setParam("store" /* STORE */, "data").URI();
-  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  const rgateway = await getStartedGateway(sfi, storeUrl);
   if (rgateway.isErr()) {
-    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+    throw sfi.loader.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new DataStoreImpl(sfi.sthis, gateway.url, {
+  const store = new DataStoreImpl(sfi.loader.sthis, gateway.url, {
     gateway: gateway.gateway,
     gatewayInterceptor: sfi.gatewayInterceptor,
     loader: sfi.loader
@@ -3628,12 +3605,12 @@ async function dataStoreFactory(sfi) {
 }
 async function metaStoreFactory(sfi) {
   const storeUrl = sfi.url.build().setParam("store" /* STORE */, "meta").URI();
-  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  const rgateway = await getStartedGateway(sfi, storeUrl);
   if (rgateway.isErr()) {
-    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+    throw sfi.loader.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new MetaStoreImpl(sfi.sthis, gateway.url, {
+  const store = new MetaStoreImpl(sfi.loader.sthis, gateway.url, {
     gateway: gateway.gateway,
     gatewayInterceptor: sfi.gatewayInterceptor,
     loader: sfi.loader
@@ -3642,12 +3619,12 @@ async function metaStoreFactory(sfi) {
 }
 async function WALStoreFactory(sfi) {
   const storeUrl = sfi.url.build().setParam("store" /* STORE */, "wal").URI();
-  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  const rgateway = await getStartedGateway(sfi, storeUrl);
   if (rgateway.isErr()) {
-    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+    throw sfi.loader.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new WALStoreImpl(sfi.sthis, gateway.url, {
+  const store = new WALStoreImpl(sfi.loader.sthis, gateway.url, {
     gateway: gateway.gateway,
     gatewayInterceptor: sfi.gatewayInterceptor,
     loader: sfi.loader
@@ -3774,7 +3751,7 @@ var ConnectionBase = class {
     this.loader = loader;
     await this.onConnect();
     const metaUrl = this.url.build().defParam("store" /* STORE */, "meta").URI();
-    const rgateway = await getStartedGateway(loader.sthis, metaUrl);
+    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("name" /* NAME */);
@@ -3810,7 +3787,7 @@ var ConnectionBase = class {
     if (!loader) throw this.logger.Error().Msg("connectStorage: loader is required").AsError();
     this.loader = loader;
     const dataUrl = this.url.build().defParam("store" /* STORE */, "data").URI();
-    const rgateway = await getStartedGateway(loader.sthis, dataUrl);
+    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("name" /* NAME */);
@@ -4680,7 +4657,7 @@ function fireproof(name, opts) {
 var runtime_exports = {};
 __export(runtime_exports, {
   FILESTORE_VERSION: () => FILESTORE_VERSION,
-  INDEXDB_VERSION: () => INDEXDB_VERSION,
+  INDEXEDDB_VERSION: () => INDEXEDDB_VERSION,
   KeyBag: () => KeyBag,
   defaultKeyBagOpts: () => defaultKeyBagOpts,
   defaultKeyBagUrl: () => defaultKeyBagUrl,
@@ -4730,6 +4707,6 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-18": "xxxx"
+  "0.20.0-dev-preview-20": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map