@fireproof/core 0.20.0-dev-preview-17 → 0.20.0-dev-preview-19

package/index.js

@@ -685,7 +685,7 @@ var KeyBag = class {
       name,
       key
     };
-    const bag = await this.rt.getBag();
+    const bag = await this.rt.getBagProvider();
     this.logger.Debug().Str("name", name).Msg("setNamedKey");
     await bag.set(name, item);
     return await this.toKeyWithFingerPrint(item.key);
@@ -710,7 +710,7 @@ var KeyBag = class {
   async getNamedKey(name, failIfNotFound = false) {
     const id = this.rt.sthis.nextId(4).str;
     return this._seq.add(async () => {
-      const bag = await this.rt.getBag();
+      const bag = await this.rt.getBagProvider();
       const named = await bag.get(name);
       if (named) {
         const fpr = await this.toKeyWithFingerPrint(named.key);
@@ -813,7 +813,7 @@ function defaultKeyBagOpts(sthis, kbo) {
     sthis,
     logger,
     keyLength: kbo.keyLength || 16,
-    getBag: () => kitem.factory(url, sthis),
+    getBagProvider: () => kitem.factory(url, sthis),
     id: () => {
       return url.toString();
     }
@@ -1207,21 +1207,17 @@ 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 */) {
@@ -1231,13 +1227,12 @@ var DefSerdeGateway = class {
     }
     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 Result7.Err(res.Err());
-    return fpDeserialize(sthis, url, res);
+    return fpDeserialize(sthis, url, res, decoder);
   }
-  async subscribe(sthis, url, callback, loader) {
+  async subscribe({ loader: { sthis }, decoder }, url, callback) {
     if (!this.gw.subscribe) {
       this.subscribeFn.set(url.toString(), callback);
       return Result7.Ok(() => {
@@ -1247,7 +1242,7 @@ var DefSerdeGateway = class {
     const unreg = await this.gw.subscribe(
       url,
       (raw2) => {
-        fpDeserialize(sthis, url, Result7.Ok(raw2)).then((res) => {
+        fpDeserialize(sthis, url, Result7.Ok(raw2), decoder).then((res) => {
           if (res.isErr()) return;
           callback(res.Ok());
         });
@@ -1256,16 +1251,13 @@ var DefSerdeGateway = class {
     );
     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);
   }
 };
@@ -2439,7 +2431,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(),
@@ -2450,7 +2442,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(),
@@ -2461,7 +2453,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(),
@@ -2472,7 +2464,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(),
@@ -2952,35 +2944,35 @@ import pMap from "p-map";
 // src/blockstore/interceptor-gateway.ts
 import { Result as Result8 } from "@adviser/cement";
 var PassThroughGateway = class {
-  async buildUrl(sthis, url, key) {
+  async buildUrl(ctx, url, key) {
     const op = { url, key };
     return Result8.Ok({ op });
   }
-  async start(sthis, url) {
+  async start(ctx, url) {
     const op = { url };
     return Result8.Ok({ op });
   }
-  async close(sthis, url) {
+  async close(ctx, url) {
     const op = { url };
     return Result8.Ok({ op });
   }
-  async delete(sthis, url) {
+  async delete(ctx, url) {
     const op = { url };
     return Result8.Ok({ op });
   }
-  async destroy(sthis, url) {
+  async destroy(ctx, url) {
     const op = { url };
     return Result8.Ok({ op });
   }
-  async put(sthis, url, body) {
+  async put(ctx, url, body) {
     const op = { url, body };
     return Result8.Ok({ op });
   }
-  async get(sthis, url) {
+  async get(ctx, url) {
     const op = { url };
     return Result8.Ok({ op });
   }
-  async subscribe(sthis, url, callback) {
+  async subscribe(ctx, url, callback) {
     const op = { url, callback };
     return Result8.Ok({ op });
   }
@@ -2991,8 +2983,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 Result8.Err(rret.Err());
     }
@@ -3000,10 +2992,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 Result8.Err(rret.Err());
     }
@@ -3011,10 +3003,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 Result8.Err(rret.Err());
     }
@@ -3022,10 +3014,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 Result8.Err(rret.Err());
     }
@@ -3033,10 +3025,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 Result8.Err(rret.Err());
     }
@@ -3044,10 +3036,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 Result8.Err(rret.Err());
     }
@@ -3055,13 +3047,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 Result8.Err(sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+      return Result8.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 Result8.Err(rret.Err());
     }
@@ -3069,10 +3061,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 Result8.Err(rret.Err());
     }
@@ -3080,10 +3072,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);
   }
 };
 
@@ -3129,7 +3121,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;
@@ -3194,18 +3186,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);
+        });
       });
     }
   }
@@ -3226,11 +3213,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;
@@ -3245,33 +3232,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 Result9.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 {
@@ -3281,11 +3263,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();
     }
@@ -3302,7 +3284,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();
     }
@@ -3321,27 +3303,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 Result9.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 {
@@ -3497,11 +3479,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;
@@ -3514,64 +3496,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 Result9.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 KeyedResolvOnce3();
 var gatewayInstances = new KeyedResolvOnce3();
-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 Result10.Err(sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
+        return Result10.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
       }
       ret.url = res.Ok();
       return Result10.Ok(ret);
     }
-    return Result10.Err(sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
+    return Result10.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
@@ -3580,12 +3557,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
@@ -3594,12 +3571,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
@@ -3726,7 +3703,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 */);
@@ -3762,7 +3739,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 */);
@@ -4665,6 +4642,8 @@ import { runtimeFn as runtimeFn4 } from "@adviser/cement";
 var gateways_exports = {};
 __export(gateways_exports, {
   DefSerdeGateway: () => DefSerdeGateway,
+  dbMetaEvent2Serialized: () => dbMetaEvent2Serialized,
+  decode2DbMetaEvents: () => decode2DbMetaEvents,
   file: () => file_exports,
   fpDeserialize: () => fpDeserialize,
   fpSerialize: () => fpSerialize,
@@ -4680,7 +4659,7 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-17": "xxxx"
+  "0.20.0-dev-preview-19": "xxxx"
 })[0];
 export {
   CRDTImpl,