@fireproof/core 0.20.0-dev-preview-57 → 0.20.0-dev-preview-60

package/index.cjs

@@ -68,6 +68,7 @@ __export(index_exports, {
   ps: () => protocols_exports,
   rt: () => runtime_exports,
   runtime: () => runtime_exports,
+  setPresetEnv: () => setPresetEnv,
   storeType2DataMetaWal: () => storeType2DataMetaWal,
   throwFalsy: () => throwFalsy,
   toSortedArray: () => toSortedArray,
@@ -186,15 +187,21 @@ var SuperThisImpl = class _SuperThisImpl {
     });
   }
 };
-function presetEnv() {
+function presetEnv(ipreset) {
+  let preset = {};
+  if (ipreset instanceof Map) {
+    preset = Object.fromEntries(ipreset.entries());
+  } else if (typeof ipreset === "object" && ipreset !== null) {
+    preset = ipreset;
+  }
   const penv = new Map([
     // ["FP_DEBUG", "xxx"],
     // ["FP_ENV", "development"],
     ...Array.from(
-      Object.entries(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        globalThis[Symbol.for("FP_PRESET_ENV")] || {}
-      )
+      Object.entries({
+        ...setPresetEnv({}),
+        ...preset
+      })
     )
     // .map(([k, v]) => [k, v as string])
   ]);
@@ -231,7 +238,7 @@ function onSuperThis(fn) {
 function ensureSuperThis(osthis) {
   const env = (0, import_cement.envFactory)({
     symbol: osthis?.env?.symbol || "FP_ENV",
-    presetEnv: osthis?.env?.presetEnv || presetEnv()
+    presetEnv: presetEnv(osthis?.env?.presetEnv)
   });
   const ret = new SuperThisImpl({
     logger: osthis?.logger || globalLogger(),
@@ -497,6 +504,14 @@ function ensureURIDefaults(sthis, name, curi, uri, store, ctx) {
   }
   return ret.URI();
 }
+function setPresetEnv(o, symbol = "FP_PRESET_ENV") {
+  const key = Symbol.for(symbol);
+  const env = globalThis[key] ?? {};
+  for (const [k, v] of Object.entries(o)) {
+    env[k] = v;
+  }
+  return env;
+}
 
 // src/write-queue.ts
 var import_cement2 = require("@adviser/cement");
@@ -1889,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;
@@ -5283,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
 });
@@ -5335,7 +5350,7 @@ var SessionTokenService = class _SessionTokenService {
       }
     };
   }
-  static async createFromEnv(sp = {}, sthis = ensureSuperThis()) {
+  static async createFromEnv(sthis, sp = {}) {
     let envToken = sthis.env.get(sp.privateEnvKey ?? envKeyDefaults.SECRET);
     if (!envToken) {
       envToken = sthis.env.get(sp.publicEnvKey ?? envKeyDefaults.PUBLIC);
@@ -5394,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 = {};
@@ -5423,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";
@@ -5745,6 +5760,14 @@ function toHttpProtocol(uri) {
   }
   return toFix.URI();
 }
+function ensurePath(uri, fp) {
+  const path = uri.pathname.replace(/\/$/, "").replace(/^\//, "");
+  const buri = uri.build();
+  if (path === "") {
+    buri.appendRelative(fp);
+  }
+  return buri.toString();
+}
 var HttpConnection = class extends MsgRawConnectionBase {
   constructor(sthis, uris, msgP, exGestalt) {
     super(sthis, exGestalt);
@@ -5833,7 +5856,7 @@ var HttpConnection = class extends MsgRawConnectionBase {
     const rRes = await (0, import_cement23.exception2Result)(
       () => timeout(
         this.msgP.timeout,
-        fetch(url.cleaned.toString(), {
+        fetch(ensurePath(url.cleaned, "fp"), {
           method: "PUT",
           headers: headers.AsHeaderInit(),
           body: rReqBody.Ok()
@@ -5854,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")
           )
         );
       }
@@ -6189,11 +6212,12 @@ var Msger = class _Msger {
   static async openWS(sthis, url, msgP, exGestalt) {
     let ws;
     url = url.build().setParam("random", sthis.nextId().str).URI();
+    const wsUrl = ensurePath(url, "ws");
     if ((0, import_cement25.runtimeFn)().isNodeIsh) {
       const { WebSocket: WebSocket2 } = await import("ws");
-      ws = new WebSocket2(url.toString());
+      ws = new WebSocket2(wsUrl);
     } else {
-      ws = new WebSocket(url.toString());
+      ws = new WebSocket(wsUrl);
     }
     return import_cement25.Result.Ok(new WSConnection(sthis, ws, msgP, exGestalt));
   }
@@ -6295,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"
@@ -6325,7 +6348,7 @@ function buildResPutMeta(_msgCtx, req, meta, signedUrl) {
     tenant: req.tenant,
     type: "resPutMeta",
     signedUrl,
-    version: import_cement26.VERSION
+    version: VERSION
   };
 }
 function MsgIsResPutMeta(qs) {
@@ -6340,7 +6363,7 @@ function buildBindGetMeta(sthis, auth, params, gwCtx) {
     tid: sthis.nextId().str,
     ...gwCtx,
     type: "bindGetMeta",
-    version: import_cement26.VERSION,
+    version: VERSION,
     params
   };
 }
@@ -6355,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) {
@@ -6370,7 +6393,7 @@ function buildReqDelMeta(sthis, auth, params, gwCtx, meta) {
     params,
     meta,
     type: "reqDelMeta",
-    version: import_cement26.VERSION
+    version: VERSION
     // params: signedUrlParams,
   };
 }
@@ -6388,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) {
@@ -6396,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) => {
@@ -6449,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);
@@ -6468,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
   });
@@ -6494,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));
       }
     }
   };
@@ -6509,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 })));
@@ -6546,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));
         }
       }
     }
@@ -6598,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;
@@ -6606,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());
@@ -6642,7 +6665,7 @@ var BaseGateway = class {
         ...params,
         key: params.key
       },
-      version: VERSION3
+      version: VERSION2
     };
   }
   async getReqSignedUrl(type, method, store, waitForFn, uri, conn) {
@@ -6654,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();
     }
@@ -6664,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 {
@@ -6739,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: {
@@ -6767,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
@@ -6782,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()
     });
@@ -6797,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);
@@ -6815,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);
@@ -6824,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, {
@@ -6837,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 {
@@ -6852,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) {
@@ -6913,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();
@@ -6921,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;
@@ -6979,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) {
@@ -7005,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();
@@ -7017,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) {
@@ -7039,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);
@@ -7070,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");
   }
@@ -7169,6 +7192,7 @@ __export(cloud_exports, {
   coerceFPStoreTypes: () => coerceFPStoreTypes,
   defaultGestalt: () => defaultGestalt,
   defaultMsgParams: () => defaultMsgParams,
+  ensurePath: () => ensurePath,
   isAuthTypeFPCloud: () => isAuthTypeFPCloud,
   isAuthTypeFPCloudJWK: () => isAuthTypeFPCloudJWK,
   isProtocolCapabilities: () => isProtocolCapabilities,
@@ -7239,6 +7263,6 @@ function buildResDelWAL(msgCtx, req, ctx) {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-57": "xxxx"
+  "0.20.0-dev-preview-60": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map