@fireproof/core 0.20.0-dev-preview-58 → 0.20.0-dev-preview-61

package/deno.json

@@ -1,7 +1,7 @@
 {
   "imports": {
     "@fireproof/core": "./index.js",
-    "@adviser/cement": "npm:@adviser/cement@~0.4.4",
+    "@adviser/cement": "npm:@adviser/cement@~0.4.7",
     "@fireproof/vendor": "npm:@fireproof/vendor@~2.0.2",
     "@ipld/car": "npm:@ipld/car@^5.4.0",
     "@ipld/dag-cbor": "npm:@ipld/dag-cbor@^9.2.2",

package/index.cjs

@@ -1904,7 +1904,7 @@ var Index = class {
     this.mapFnString = "";
     this.byKey = new IndexTree();
     this.byId = new IndexTree();
-    this.includeDocsDefault = false;
+    this.includeDocsDefault = true;
     this.logger = ensureLogger(sthis, "Index");
     this.blockstore = crdt.indexBlockstore;
     this.crdt = crdt;
@@ -5298,7 +5298,7 @@ __export(runtime_exports, {
   keysByFingerprint: () => keysByFingerprint,
   mf: () => wait_pr_multiformats_exports,
   registerKeyBagProviderFactory: () => registerKeyBagProviderFactory,
-  runtimeFn: () => import_cement29.runtimeFn,
+  runtimeFn: () => import_cement28.runtimeFn,
   sts: () => sts_service_exports,
   toKeyWithFingerPrint: () => toKeyWithFingerPrint
 });
@@ -5409,7 +5409,7 @@ var SessionTokenService = class _SessionTokenService {
 };
 
 // src/runtime/index.ts
-var import_cement29 = require("@adviser/cement");
+var import_cement28 = require("@adviser/cement");
 
 // src/runtime/gateways/index.ts
 var gateways_exports = {};
@@ -5438,7 +5438,7 @@ __export(gateway_exports2, {
   registerFireproofCloudStoreProtocol: () => registerFireproofCloudStoreProtocol,
   toCloud: () => toCloud
 });
-var import_cement28 = require("@adviser/cement");
+var import_cement27 = require("@adviser/cement");
 
 // src/protocols/cloud/msg-types.ts
 var VERSION = "FP-MSG-1.0";
@@ -5877,7 +5877,7 @@ var HttpConnection = class extends MsgRawConnectionBase {
             this,
             req,
             this.logger.Error().Any(url).Str("status", res.status.toString()).Str("statusText", res.statusText).Msg("HTTP Error").AsError(),
-            await res.text()
+            await res.text().catch(() => "no body")
           )
         );
       }
@@ -6319,14 +6319,13 @@ function buildResDelData(msgCtx, req, ctx) {
 }
 
 // src/protocols/cloud/msg-types-meta.ts
-var import_cement26 = require("@adviser/cement");
 function buildReqPutMeta(sthis, auth, signedUrlParams, meta, gwCtx) {
   return {
     auth,
     tid: sthis.nextId().str,
     type: "reqPutMeta",
     ...gwCtx,
-    version: import_cement26.VERSION,
+    version: VERSION,
     methodParams: {
       method: "PUT",
       store: "meta"
@@ -6349,7 +6348,7 @@ function buildResPutMeta(_msgCtx, req, meta, signedUrl) {
     tenant: req.tenant,
     type: "resPutMeta",
     signedUrl,
-    version: import_cement26.VERSION
+    version: VERSION
   };
 }
 function MsgIsResPutMeta(qs) {
@@ -6364,7 +6363,7 @@ function buildBindGetMeta(sthis, auth, params, gwCtx) {
     tid: sthis.nextId().str,
     ...gwCtx,
     type: "bindGetMeta",
-    version: import_cement26.VERSION,
+    version: VERSION,
     params
   };
 }
@@ -6379,7 +6378,7 @@ function buildEventGetMeta(_msgCtx, req, meta, gwCtx, signedUrl) {
     type: "eventGetMeta",
     params: req.params,
     methodParams: { method: "GET", store: "meta" },
-    version: import_cement26.VERSION
+    version: VERSION
   };
 }
 function MsgIsEventGetMeta(qs) {
@@ -6394,7 +6393,7 @@ function buildReqDelMeta(sthis, auth, params, gwCtx, meta) {
     params,
     meta,
     type: "reqDelMeta",
-    version: import_cement26.VERSION
+    version: VERSION
     // params: signedUrlParams,
   };
 }
@@ -6412,7 +6411,7 @@ function buildResDelMeta(req, params, signedUrl) {
     tenant: req.tenant,
     type: "resDelMeta",
     // key: req.key,
-    version: import_cement26.VERSION
+    version: VERSION
   };
 }
 function MsgIsResDelMeta(qs) {
@@ -6420,7 +6419,7 @@ function MsgIsResDelMeta(qs) {
 }
 
 // src/runtime/meta-key-hack.ts
-var import_cement27 = require("@adviser/cement");
+var import_cement26 = require("@adviser/cement");
 function fromV1toV2SerializedMetaKey(v1s, keys = []) {
   const res = v1s.reduce(
     (acc, v1) => {
@@ -6473,7 +6472,7 @@ function toV2SerializedMetaKey(or) {
 async function V2SerializedMetaKeyExtractKey(ctx, v2) {
   const kb = await ctx.loader.keyBag();
   if (!kb) {
-    return Promise.resolve(import_cement27.Result.Err(new Error("missing keybag")));
+    return Promise.resolve(import_cement26.Result.Err(new Error("missing keybag")));
   }
   const dataUrl = await ctx.loader.attachedStores.local().active.car.url();
   const keyName = dataUrl.getParam(PARAM.STORE_KEY);
@@ -6492,19 +6491,19 @@ async function V2SerializedMetaKeyExtractKey(ctx, v2) {
       }
     }
   }
-  return Promise.resolve(import_cement27.Result.Ok(v2.metas));
+  return Promise.resolve(import_cement26.Result.Ok(v2.metas));
 }
 async function decodeAsToSerializedMeta(ctx, raw2) {
-  const rJsObj = (0, import_cement27.exception2Result)(() => JSON.parse(ctx.loader.sthis.txt.decode(raw2)));
+  const rJsObj = (0, import_cement26.exception2Result)(() => JSON.parse(ctx.loader.sthis.txt.decode(raw2)));
   if (rJsObj.isErr()) {
-    return import_cement27.Result.Err(rJsObj);
+    return import_cement26.Result.Err(rJsObj);
   }
   const v2 = toV2SerializedMetaKey(rJsObj.unwrap());
   const metas = await V2SerializedMetaKeyExtractKey(ctx, v2);
   if (metas.isErr()) {
-    return import_cement27.Result.Err(metas);
+    return import_cement26.Result.Err(metas);
   }
-  return import_cement27.Result.Ok({
+  return import_cement26.Result.Ok({
     metas: metas.Ok(),
     keys: v2.keys
   });
@@ -6518,13 +6517,13 @@ function addKeyToDbMetaDecoder(ctx) {
       meta: async (sthis, raw2) => {
         const r = await decodeAsToSerializedMeta(ctx, raw2);
         if (r.isErr()) {
-          return Promise.resolve(import_cement27.Result.Err(r));
+          return Promise.resolve(import_cement26.Result.Err(r));
         }
         if (lastDecodedMetas.length > 2) {
           lastDecodedMetas.shift();
         }
         lastDecodedMetas.push(r.Ok());
-        return Promise.resolve(import_cement27.Result.Ok(r.Ok().metas));
+        return Promise.resolve(import_cement26.Result.Ok(r.Ok().metas));
       }
     }
   };
@@ -6533,15 +6532,15 @@ async function wrapEncode(ctx, payload, fn) {
   const carStore = ctx.loader.attachedStores.local().active.car;
   const kb = await ctx.loader.keyBag();
   if (!kb) {
-    return Promise.resolve(import_cement27.Result.Err(new Error("missing keybag")));
+    return Promise.resolve(import_cement26.Result.Err(new Error("missing keybag")));
   }
   const keyName = carStore.url().getParam(PARAM.STORE_KEY) ?? "";
   const rKex = await kb.getNamedKey(keyName);
   if (rKex.isErr()) {
-    return Promise.resolve(import_cement27.Result.Err(rKex.Err()));
+    return Promise.resolve(import_cement26.Result.Err(rKex.Err()));
   }
   const keyMaterials = await rKex.Ok().asKeysItem().then((i) => Object.values(i.keys).map((i2) => i2.key));
-  return Promise.resolve(import_cement27.Result.Ok(fn(payload, keyMaterials)));
+  return Promise.resolve(import_cement26.Result.Ok(fn(payload, keyMaterials)));
 }
 function encodeAsV1SerializedMetaKey(ctx, payload) {
   return wrapEncode(ctx, payload, (payload2, keyM) => payload2.map((p) => ({ ...p, key: keyM })));
@@ -6570,15 +6569,15 @@ function addKeyToDbMetaEncoder(ctx, version) {
             obj = await encodeAsV2SerializedMetaKey(ctx, payload);
             break;
           default:
-            return Promise.resolve(import_cement27.Result.Err(`unknown version:[${version}]`));
+            return Promise.resolve(import_cement26.Result.Err(`unknown version:[${version}]`));
         }
         if (obj.isErr()) {
-          return Promise.resolve(import_cement27.Result.Err(obj));
+          return Promise.resolve(import_cement26.Result.Err(obj));
         }
         try {
-          return Promise.resolve(import_cement27.Result.Ok(sthis.txt.encode(JSON.stringify(obj.Ok()))));
+          return Promise.resolve(import_cement26.Result.Ok(sthis.txt.encode(JSON.stringify(obj.Ok()))));
         } catch (e) {
-          return Promise.resolve(import_cement27.Result.Err(e));
+          return Promise.resolve(import_cement26.Result.Err(e));
         }
       }
     }
@@ -6622,7 +6621,7 @@ var AddKeyToDbMetaGateway = class {
 };
 
 // src/runtime/gateways/cloud/gateway.ts
-var VERSION3 = "v0.1-fp-cloud";
+var VERSION2 = "v0.1-fp-cloud";
 var BaseGateway = class {
   constructor(sthis, module2) {
     this.sthis = sthis;
@@ -6630,12 +6629,12 @@ var BaseGateway = class {
   }
   async buildReqSignedUrl(type, method, store, uri, conn) {
     const rParams = uri.getParamsResult({
-      key: import_cement28.param.REQUIRED,
-      store: import_cement28.param.REQUIRED,
-      path: import_cement28.param.OPTIONAL,
-      tenant: import_cement28.param.REQUIRED,
-      name: import_cement28.param.REQUIRED,
-      index: import_cement28.param.OPTIONAL
+      key: import_cement27.param.REQUIRED,
+      store: import_cement27.param.REQUIRED,
+      path: import_cement27.param.OPTIONAL,
+      tenant: import_cement27.param.REQUIRED,
+      name: import_cement27.param.REQUIRED,
+      index: import_cement27.param.OPTIONAL
     });
     if (rParams.isErr()) {
       return buildErrorMsg(this, {}, rParams.Err());
@@ -6666,7 +6665,7 @@ var BaseGateway = class {
         ...params,
         key: params.key
       },
-      version: VERSION3
+      version: VERSION2
     };
   }
   async getReqSignedUrl(type, method, store, waitForFn, uri, conn) {
@@ -6678,7 +6677,7 @@ var BaseGateway = class {
   }
   async putObject(uri, uploadUrl, body, conn) {
     this.logger.Debug().Any("url", { uploadUrl, uri }).Msg("put-fetch-url");
-    const rUpload = await (0, import_cement28.exception2Result)(async () => fetch(uploadUrl, { method: "PUT", body }));
+    const rUpload = await (0, import_cement27.exception2Result)(async () => fetch(uploadUrl, { method: "PUT", body }));
     if (rUpload.isErr()) {
       return this.logger.Error().Url(uploadUrl, "uploadUrl").Err(rUpload).Msg("Error in put fetch").ResultError();
     }
@@ -6688,39 +6687,39 @@ var BaseGateway = class {
     if (uri.getParam("testMode")) {
       conn.citem.trackPuts.add(uri.toString());
     }
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async getObject(uri, downloadUrl, _conn) {
     this.logger.Debug().Any("url", { downloadUrl, uri }).Msg("get-fetch-url");
-    const rDownload = await (0, import_cement28.exception2Result)(async () => fetch(downloadUrl.toString(), { method: "GET" }));
+    const rDownload = await (0, import_cement27.exception2Result)(async () => fetch(downloadUrl.toString(), { method: "GET" }));
     if (rDownload.isErr()) {
       return this.logger.Error().Url(downloadUrl, "uploadUrl").Err(rDownload).Msg("Error in get downloadUrl").ResultError();
     }
     const download = rDownload.Ok();
     if (!download.ok) {
       if (download.status === 404) {
-        return import_cement28.Result.Err(new NotFoundError("Not found"));
+        return import_cement27.Result.Err(new NotFoundError("Not found"));
       }
       return this.logger.Error().Url(downloadUrl, "uploadUrl").Err(rDownload).Msg("Error in get fetch").ResultError();
     }
-    return import_cement28.Result.Ok((0, import_cement28.to_uint8)(await download.arrayBuffer()));
+    return import_cement27.Result.Ok((0, import_cement27.to_uint8)(await download.arrayBuffer()));
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async delObject(uri, deleteUrl, _conn) {
     this.logger.Debug().Any("url", { deleteUrl, uri }).Msg("get-fetch-url");
-    const rDelete = await (0, import_cement28.exception2Result)(async () => fetch(deleteUrl.toString(), { method: "DELETE" }));
+    const rDelete = await (0, import_cement27.exception2Result)(async () => fetch(deleteUrl.toString(), { method: "DELETE" }));
     if (rDelete.isErr()) {
       return this.logger.Error().Url(deleteUrl, "deleteUrl").Err(rDelete).Msg("Error in get deleteURL").ResultError();
     }
     const download = rDelete.Ok();
     if (!download.ok) {
       if (download.status === 404) {
-        return import_cement28.Result.Err(new NotFoundError("Not found"));
+        return import_cement27.Result.Err(new NotFoundError("Not found"));
       }
       return this.logger.Error().Url(deleteUrl, "deleteUrl").Err(rDelete).Msg("Error in del fetch").ResultError();
     }
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
 };
 var DataGateway = class extends BaseGateway {
@@ -6763,15 +6762,15 @@ var DataGateway = class extends BaseGateway {
 };
 function getGwCtx(conn, uri) {
   const rParams = uri.getParamsResult({
-    tid: import_cement28.param.OPTIONAL,
-    tenant: import_cement28.param.REQUIRED,
-    ledger: import_cement28.param.REQUIRED
+    tid: import_cement27.param.OPTIONAL,
+    tenant: import_cement27.param.REQUIRED,
+    ledger: import_cement27.param.REQUIRED
   });
   if (rParams.isErr()) {
-    return import_cement28.Result.Err(rParams);
+    return import_cement27.Result.Err(rParams);
   }
   const r = rParams.Ok();
-  return import_cement28.Result.Ok({
+  return import_cement27.Result.Ok({
     tid: r.tid,
     conn,
     tenant: {
@@ -6791,11 +6790,11 @@ var MetaGateway = class extends BaseGateway {
     }
     const rGwCtx = getGwCtx(ctx.conn.conn.Ok().conn, uri);
     if (rGwCtx.isErr()) {
-      return import_cement28.Result.Err(rGwCtx);
+      return import_cement27.Result.Err(rGwCtx);
     }
     const rAuthType = await ctx.conn.conn.Ok().authType();
     if (rAuthType.isErr()) {
-      return import_cement28.Result.Err(rAuthType);
+      return import_cement27.Result.Err(rAuthType);
     }
     const res = await ctx.conn.conn.Ok().request(buildBindGetMeta(ctx.loader.sthis, rAuthType.Ok(), reqSignedUrl.params, rGwCtx.Ok()), {
       waitFor: MsgIsEventGetMeta
@@ -6806,9 +6805,9 @@ var MetaGateway = class extends BaseGateway {
     const rV2Meta = await V2SerializedMetaKeyExtractKey(ctx, res.meta);
     const rMeta = await decode2DbMetaEvents(ctx.loader.sthis, rV2Meta);
     if (rMeta.isErr()) {
-      return import_cement28.Result.Err(rMeta);
+      return import_cement27.Result.Err(rMeta);
     }
-    return import_cement28.Result.Ok({
+    return import_cement27.Result.Ok({
       type: "meta",
       payload: rMeta.Ok()
     });
@@ -6821,11 +6820,11 @@ var MetaGateway = class extends BaseGateway {
     }
     const rGwCtx = getGwCtx(ctx.conn.conn.Ok().conn, uri);
     if (rGwCtx.isErr()) {
-      return import_cement28.Result.Err(rGwCtx);
+      return import_cement27.Result.Err(rGwCtx);
     }
     const rAuthType = await ctx.conn.conn.Ok().authType();
     if (rAuthType.isErr()) {
-      return import_cement28.Result.Err(rAuthType);
+      return import_cement27.Result.Err(rAuthType);
     }
     const serializedMeta = await dbMetaEvent2Serialized(ctx.loader.sthis, meta.payload);
     const rKeyedMeta = await encodeAsV2SerializedMetaKey(ctx, serializedMeta);
@@ -6839,7 +6838,7 @@ var MetaGateway = class extends BaseGateway {
     if (MsgIsError(resMsg)) {
       return this.logger.Error().Err(resMsg).Msg("Error in buildResSignedUrl").ResultError();
     }
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
   async delete(ctx, uri) {
     const reqSignedUrl = await this.getReqSignedUrl("reqDelMeta", "DELETE", "meta", MsgIsResDelData, uri, ctx.conn);
@@ -6848,11 +6847,11 @@ var MetaGateway = class extends BaseGateway {
     }
     const rGwCtx = getGwCtx(ctx.conn.conn.Ok().conn, uri);
     if (rGwCtx.isErr()) {
-      return import_cement28.Result.Err(rGwCtx);
+      return import_cement27.Result.Err(rGwCtx);
     }
     const rAuthType = await ctx.conn.conn.Ok().authType();
     if (rAuthType.isErr()) {
-      return import_cement28.Result.Err(rAuthType);
+      return import_cement27.Result.Err(rAuthType);
     }
     const reqDelMeta = buildReqDelMeta(ctx.loader.sthis, rAuthType.Ok(), reqSignedUrl.params, rGwCtx.Ok());
     const resMsg = await ctx.conn.conn.Ok().request(reqDelMeta, {
@@ -6861,7 +6860,7 @@ var MetaGateway = class extends BaseGateway {
     if (MsgIsError(resMsg)) {
       return this.logger.Error().Err(resMsg).Msg("Error in buildResSignedUrl").ResultError();
     }
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
 };
 var WALGateway = class extends BaseGateway {
@@ -6876,40 +6875,40 @@ var WALGateway = class extends BaseGateway {
       name: 0
     });
     if (rKey.isErr()) {
-      return import_cement28.Result.Err(rKey.Err());
+      return import_cement27.Result.Err(rKey.Err());
     }
     const { name, key } = rKey.Ok();
-    return import_cement28.Result.Ok(`${name}:${key}`);
+    return import_cement27.Result.Ok(`${name}:${key}`);
   }
   async get(ctx, uri) {
     const rKey = this.getWalKeyFromUri(uri);
     if (rKey.isErr()) {
-      return import_cement28.Result.Err(rKey.Err());
+      return import_cement27.Result.Err(rKey.Err());
     }
     const wal = this.wals.get(rKey.Ok());
     if (!wal) {
-      return import_cement28.Result.Err(new NotFoundError("Not found"));
+      return import_cement27.Result.Err(new NotFoundError("Not found"));
     }
-    return import_cement28.Result.Ok(wal);
+    return import_cement27.Result.Ok(wal);
   }
   async put(ctx, uri, body) {
     const rKey = this.getWalKeyFromUri(uri);
     if (rKey.isErr()) {
-      return import_cement28.Result.Err(rKey.Err());
+      return import_cement27.Result.Err(rKey.Err());
     }
     this.wals.set(rKey.Ok(), body);
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
   async delete(ctx, uri) {
     const rKey = this.getWalKeyFromUri(uri);
     if (rKey.isErr()) {
-      return import_cement28.Result.Err(rKey.Err());
+      return import_cement27.Result.Err(rKey.Err());
     }
     this.wals.delete(rKey.Ok());
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
 };
-var storeTypedGateways = new import_cement28.KeyedResolvOnce();
+var storeTypedGateways = new import_cement27.KeyedResolvOnce();
 function getStoreTypeGateway(sthis, uri) {
   const store = uri.getParam("store");
   switch (store) {
@@ -6937,7 +6936,7 @@ var FireproofCloudGateway = class {
     });
   }
   async buildUrl(ctx, baseUrl, key) {
-    return import_cement28.Result.Ok(baseUrl.build().setParam("key", key).URI());
+    return import_cement27.Result.Ok(baseUrl.build().setParam("key", key).URI());
   }
   async start(ctx, uri) {
     await this.sthis.start();
@@ -6945,22 +6944,22 @@ var FireproofCloudGateway = class {
     if (rName.isErr()) {
       return this.logger.Error().Err(rName).Msg("name not found").ResultError();
     }
-    const ret = uri.build().defParam("version", VERSION3);
+    const ret = uri.build().defParam("version", VERSION2);
     ret.defParam("protocol", "wss");
     const retURI = ret.URI();
     const matchURI = connectionURI(retURI);
     this.#connectionURIs.set(matchURI.toString(), {
       uri: matchURI,
       matchRes: matchURI.match(matchURI),
-      connection: new import_cement28.ResolveOnce(),
+      connection: new import_cement27.ResolveOnce(),
       trackPuts: /* @__PURE__ */ new Set()
     });
-    return import_cement28.Result.Ok(retURI);
+    return import_cement27.Result.Ok(retURI);
   }
   async get(ctx, uri) {
     const conn = await this.getCloudConnectionItem(uri);
     if (conn.conn.isErr()) {
-      return import_cement28.Result.Err(conn.conn);
+      return import_cement27.Result.Err(conn.conn);
     }
     const ret = await getStoreTypeGateway(ctx.loader.sthis, uri).get({ ...ctx, conn }, uri);
     return ret;
@@ -7003,7 +7002,7 @@ var FireproofCloudGateway = class {
     const rAuth = await conn.msgConnAuth();
     await conn.close(rAuth.Ok());
     this.#connectionURIs.delete(rConn.citem.uri.toString());
-    return import_cement28.Result.Ok(void 0);
+    return import_cement27.Result.Ok(void 0);
   }
   // fireproof://localhost:1999/?name=test-public-api&protocol=ws&store=meta
   async getCloudConnection(uri) {
@@ -7029,11 +7028,11 @@ var FireproofCloudGateway = class {
     }
     const conn = await bestMatch.connection.once(async () => {
       const rParams = uri.getParamsResult({
-        name: import_cement28.param.REQUIRED,
+        name: import_cement27.param.REQUIRED,
         protocol: "https",
-        store: import_cement28.param.REQUIRED,
-        storekey: import_cement28.param.OPTIONAL,
-        tenant: import_cement28.param.REQUIRED
+        store: import_cement27.param.REQUIRED,
+        storekey: import_cement27.param.OPTIONAL,
+        tenant: import_cement27.param.REQUIRED
       });
       if (rParams.isErr()) {
         return this.logger.Error().Url(uri).Err(rParams).Msg("getCloudConnection:err").ResultError();
@@ -7041,16 +7040,16 @@ var FireproofCloudGateway = class {
       const params = rParams.Ok();
       const rAuth = await authTypeFromUri(this.logger, uri);
       if (rAuth.isErr()) {
-        return import_cement28.Result.Err(rAuth);
+        return import_cement27.Result.Err(rAuth);
       }
       const qOpen = buildReqOpen(this.sthis, rAuth.Ok(), {});
       const cUrl = uri.build().protocol(params.protocol).cleanParams().URI();
       return Msger.connect(this.sthis, rAuth.Ok(), cUrl, qOpen);
     });
     if (conn.isErr()) {
-      return { conn: import_cement28.Result.Err(conn), citem: bestMatch };
+      return { conn: import_cement27.Result.Err(conn), citem: bestMatch };
     }
-    return { conn: import_cement28.Result.Ok(conn.Ok().attachAuth(() => authTypeFromUri(this.logger, uri))), citem: bestMatch };
+    return { conn: import_cement27.Result.Ok(conn.Ok().attachAuth(() => authTypeFromUri(this.logger, uri))), citem: bestMatch };
   }
   // private notifySubscribers(data: Uint8Array, callbacks: ((msg: Uint8Array) => void)[] = []): void {
   //   for (const cb of callbacks) {
@@ -7063,28 +7062,28 @@ var FireproofCloudGateway = class {
   // }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async subscribe(ctx, url, callback) {
-    return import_cement28.Result.Err(new Error("Not implemented"));
+    return import_cement27.Result.Err(new Error("Not implemented"));
   }
   async destroy(ctx, uri) {
     const item = await this.getCloudConnectionItem(uri);
     if (item.conn.isErr()) {
       return item.conn;
     }
-    await Promise.all(Array.from(item.citem.trackPuts).map(async (k) => this.delete(ctx, import_cement28.URI.from(k))));
-    return import_cement28.Result.Ok(void 0);
+    await Promise.all(Array.from(item.citem.trackPuts).map(async (k) => this.delete(ctx, import_cement27.URI.from(k))));
+    return import_cement27.Result.Ok(void 0);
   }
   async getPlain() {
-    return import_cement28.Result.Err(new Error("Not implemented"));
+    return import_cement27.Result.Err(new Error("Not implemented"));
   }
 };
-var onceRegisterFireproofCloudStoreProtocol = new import_cement28.KeyedResolvOnce();
+var onceRegisterFireproofCloudStoreProtocol = new import_cement27.KeyedResolvOnce();
 function registerFireproofCloudStoreProtocol(protocol = "fpcloud:") {
   return onceRegisterFireproofCloudStoreProtocol.get(protocol).once(() => {
-    import_cement28.URI.protocolHasHostpart(protocol);
+    import_cement27.URI.protocolHasHostpart(protocol);
     return registerStoreProtocol({
       protocol,
       defaultURI() {
-        return import_cement28.URI.from("fpcloud://fireproof.cloud/");
+        return import_cement27.URI.from("fpcloud://fireproof.cloud/");
       },
       serdegateway: async (sthis) => {
         return new FireproofCloudGateway(sthis);
@@ -7094,7 +7093,7 @@ function registerFireproofCloudStoreProtocol(protocol = "fpcloud:") {
 }
 registerFireproofCloudStoreProtocol();
 function toCloud(url) {
-  const urlObj = import_cement28.URI.from(url);
+  const urlObj = import_cement27.URI.from(url);
   if (urlObj.protocol !== "fpcloud:") {
     throw new Error("url must have fireproof protocol");
   }
@@ -7264,6 +7263,6 @@ function buildResDelWAL(msgCtx, req, ctx) {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-58": "xxxx"
+  "0.20.0-dev-preview-61": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map