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

package/index.cjs

@@ -64,6 +64,8 @@ __export(index_exports, {
   keyConfigOpts: () => keyConfigOpts,
   makeName: () => makeName,
   onSuperThis: () => onSuperThis,
+  protocols: () => protocols_exports,
+  ps: () => protocols_exports,
   rt: () => runtime_exports,
   runtime: () => runtime_exports,
   storeType2DataMetaWal: () => storeType2DataMetaWal,
@@ -5259,11 +5261,18 @@ function fireproof(name, opts) {
 // src/runtime/index.ts
 var runtime_exports = {};
 __export(runtime_exports, {
+  AddKeyToDbMetaGateway: () => AddKeyToDbMetaGateway,
   FILESTORE_VERSION: () => FILESTORE_VERSION,
   INDEXEDDB_VERSION: () => INDEXEDDB_VERSION,
   KeyBag: () => KeyBag,
+  V2SerializedMetaKeyExtractKey: () => V2SerializedMetaKeyExtractKey,
+  addKeyToDbMetaDecoder: () => addKeyToDbMetaDecoder,
+  addKeyToDbMetaEncoder: () => addKeyToDbMetaEncoder,
+  decodeAsToSerializedMeta: () => decodeAsToSerializedMeta,
   defaultKeyBagOpts: () => defaultKeyBagOpts,
   defaultKeyBagUrl: () => defaultKeyBagUrl,
+  encodeAsV1SerializedMetaKey: () => encodeAsV1SerializedMetaKey,
+  encodeAsV2SerializedMetaKey: () => encodeAsV2SerializedMetaKey,
   files: () => files_exports,
   getFileName: () => getFileName,
   getKeyBag: () => getKeyBag,
@@ -5274,7 +5283,8 @@ __export(runtime_exports, {
   keysByFingerprint: () => keysByFingerprint,
   mf: () => wait_pr_multiformats_exports,
   registerKeyBagProviderFactory: () => registerKeyBagProviderFactory,
-  runtimeFn: () => import_cement22.runtimeFn,
+  runtimeFn: () => import_cement29.runtimeFn,
+  sts: () => sts_service_exports,
   toKeyWithFingerPrint: () => toKeyWithFingerPrint
 });
 
@@ -5288,13 +5298,109 @@ __export(wait_pr_multiformats_exports, {
 // src/runtime/wait-pr-multiformats/codec-interface.ts
 var codec_interface_exports = {};
 
-// src/runtime/index.ts
+// src/runtime/sts-service/index.ts
+var sts_service_exports = {};
+__export(sts_service_exports, {
+  SessionTokenService: () => SessionTokenService,
+  env2jwk: () => env2jwk,
+  envKeyDefaults: () => envKeyDefaults,
+  jwk2env: () => jwk2env
+});
 var import_cement22 = require("@adviser/cement");
+var import_jose = require("jose");
+var import_keypair = require("jose/key/generate/keypair");
+var import_base584 = require("multiformats/bases/base58");
+var envKeyDefaults = {
+  SECRET: "CLOUD_SESSION_TOKEN_SECRET",
+  PUBLIC: "CLOUD_SESSION_TOKEN_PUBLIC"
+};
+async function jwk2env(jwk, sthis = ensureSuperThis()) {
+  const inPubKey = await (0, import_jose.exportJWK)(jwk);
+  return import_base584.base58btc.encode(sthis.txt.encode(JSON.stringify(inPubKey)));
+}
+async function env2jwk(env, alg, sthis = ensureSuperThis()) {
+  const inJWT = JSON.parse(sthis.txt.decode(import_base584.base58btc.decode(env)));
+  return (0, import_jose.importJWK)(inJWT, alg, { extractable: true });
+}
+var SessionTokenService = class _SessionTokenService {
+  #key;
+  #param;
+  static async generateKeyPair(alg = "ES256", options = { extractable: true }, generateKeyPairFN = (alg2, options2) => (0, import_keypair.generateKeyPair)(alg2, options2)) {
+    const material = await generateKeyPairFN(alg, options);
+    return {
+      material,
+      strings: {
+        publicKey: await jwk2env(material.publicKey),
+        privateKey: await jwk2env(material.privateKey)
+      }
+    };
+  }
+  static async createFromEnv(sp = {}, sthis = ensureSuperThis()) {
+    let envToken = sthis.env.get(sp.privateEnvKey ?? envKeyDefaults.SECRET);
+    if (!envToken) {
+      envToken = sthis.env.get(sp.publicEnvKey ?? envKeyDefaults.PUBLIC);
+    }
+    if (!envToken) {
+      throw new Error(
+        `env not found for: ${sp.privateEnvKey ?? envKeyDefaults.SECRET} or ${sp.publicEnvKey ?? envKeyDefaults.PUBLIC}`
+      );
+    }
+    return _SessionTokenService.create({ token: envToken }, sthis);
+  }
+  static async create(stsparam, sthis = ensureSuperThis()) {
+    const key = await env2jwk(stsparam.token, stsparam.alg ?? "ES256", sthis);
+    return new _SessionTokenService(key, stsparam);
+  }
+  constructor(key, stsparam) {
+    this.#key = key;
+    this.#param = stsparam;
+  }
+  get validFor() {
+    let validFor = this.#param.validFor ?? 3600;
+    if (!(0 <= validFor && validFor <= 36e5)) {
+      validFor = 36e5;
+    }
+    return validFor;
+  }
+  get alg() {
+    return this.#param.alg ?? "ES256";
+  }
+  get isssuer() {
+    return this.#param.issuer ?? "fireproof";
+  }
+  get audience() {
+    return this.#param.audience ?? "fireproof";
+  }
+  async validate(token) {
+    return (0, import_cement22.exception2Result)(async () => {
+      const ret = await (0, import_jose.jwtVerify)(token, this.#key);
+      return ret;
+    });
+  }
+  // async getEnvKey(): Promise<string> {
+  //   return jwk2env(ensureSuperThis(), this.#key);
+  // }
+  async tokenFor(p) {
+    if (this.#key.type !== "private") {
+      throw new Error("key must be private");
+    }
+    const token = await new import_jose.SignJWT({
+      userId: p.userId,
+      tenants: p.tenants,
+      ledgers: p.ledgers
+    }).setProtectedHeader({ alg: this.alg }).setIssuedAt().setIssuer(p.issuer ?? this.isssuer).setAudience(p.audience ?? this.audience).setExpirationTime(Date.now() + (p.validFor ?? this.validFor)).sign(this.#key);
+    return token;
+  }
+};
+
+// src/runtime/index.ts
+var import_cement29 = require("@adviser/cement");
 
 // src/runtime/gateways/index.ts
 var gateways_exports = {};
 __export(gateways_exports, {
   DefSerdeGateway: () => DefSerdeGateway,
+  cloud: () => gateway_exports2,
   dbMetaEvent2Serialized: () => dbMetaEvent2Serialized,
   decode2DbMetaEvents: () => decode2DbMetaEvents,
   file: () => file_exports,
@@ -5310,8 +5416,1829 @@ __export(file_exports, {
   sysFileSystemFactory: () => sysFileSystemFactory
 });
 
+// src/runtime/gateways/cloud/gateway.ts
+var gateway_exports2 = {};
+__export(gateway_exports2, {
+  FireproofCloudGateway: () => FireproofCloudGateway,
+  registerFireproofCloudStoreProtocol: () => registerFireproofCloudStoreProtocol,
+  toCloud: () => toCloud
+});
+var import_cement28 = require("@adviser/cement");
+
+// src/protocols/cloud/msg-types.ts
+var VERSION = "FP-MSG-1.0";
+function isAuthTypeFPCloudJWK(a) {
+  return a.type === "fp-cloud-jwk";
+}
+function isAuthTypeFPCloud(a) {
+  return a.type === "fp-cloud";
+}
+function keyTenantLedger(t) {
+  return `${t.tenant}:${t.ledger}`;
+}
+function qsidEqual(a, b) {
+  return a.reqId === b.reqId && a.resId === b.resId;
+}
+function qsidKey(qsid) {
+  return `${qsid.reqId}:${qsid.resId}`;
+}
+function MsgIsTid(msg, tid) {
+  return msg.tid === tid;
+}
+function MsgIsError(rq) {
+  return rq.type === "error";
+}
+function MsgIsQSError(rq) {
+  return rq.res.type === "error" || rq.req.type === "error";
+}
+function coerceFPStoreTypes(s) {
+  const x = s?.trim();
+  if (x === "meta" || x === "car" || x === "wal" || x === "file") {
+    return x;
+  }
+  throw new Error(`Invalid FPStoreTypes: ${s}`);
+}
+function isProtocolCapabilities(s) {
+  const x = s.trim();
+  return x === "reqRes" || x === "stream";
+}
+function defaultGestalt(msgP, gestalt) {
+  return {
+    storeTypes: ["meta", "file", "car", "wal"],
+    httpEndpoints: ["/fp"],
+    wsEndpoints: ["/ws"],
+    encodings: ["JSON"],
+    protocolCapabilities: msgP.protocolCapabilities || ["reqRes", "stream"],
+    auth: [],
+    requiresAuth: false,
+    data: msgP.hasPersistent ? {
+      inband: true,
+      outband: true
+    } : void 0,
+    meta: msgP.hasPersistent ? {
+      inband: true,
+      outband: true
+    } : void 0,
+    wal: msgP.hasPersistent ? {
+      inband: true,
+      outband: true
+    } : void 0,
+    reqTypes: [
+      "reqOpen",
+      "reqGestalt",
+      // "reqSignedUrl",
+      "reqSubscribeMeta",
+      "reqPutMeta",
+      "reqBindMeta",
+      "reqDelMeta",
+      "reqPutData",
+      "reqGetData",
+      "reqDelData",
+      "reqPutWAL",
+      "reqGetWAL",
+      "reqDelWAL",
+      "reqUpdateMeta"
+    ],
+    resTypes: [
+      "resOpen",
+      "resGestalt",
+      // "resSignedUrl",
+      "resSubscribeMeta",
+      "resPutMeta",
+      "resGetMeta",
+      "resDelMeta",
+      "resPutData",
+      "resGetData",
+      "resDelData",
+      "resPutWAL",
+      "resGetWAL",
+      "resDelWAL",
+      "updateMeta"
+    ],
+    eventTypes: ["updateMeta"],
+    ...gestalt
+  };
+}
+function buildReqChat(sthis, auth, conn, message, targets) {
+  return {
+    tid: sthis.nextId().str,
+    type: "reqChat",
+    version: VERSION,
+    auth,
+    conn,
+    message,
+    targets: targets ?? []
+  };
+}
+function buildResChat(req, conn, message, targets, auth) {
+  return {
+    ...req,
+    auth: auth || req.auth,
+    conn: conn || req.conn,
+    message: message || req.message,
+    targets: targets || req.targets,
+    type: "resChat",
+    version: VERSION
+  };
+}
+function MsgIsReqChat(msg) {
+  return msg.type === "reqChat";
+}
+function MsgIsResChat(msg) {
+  return msg.type === "resChat";
+}
+function MsgIsReqGestalt(msg) {
+  return msg.type === "reqGestalt";
+}
+function buildReqGestalt(sthis, auth, gestalt, publish) {
+  return {
+    tid: sthis.nextId().str,
+    auth,
+    type: "reqGestalt",
+    version: VERSION,
+    gestalt,
+    publish
+  };
+}
+function buildResGestalt(req, gestalt, auth) {
+  return {
+    tid: req.tid,
+    auth: auth || req.auth,
+    type: "resGestalt",
+    version: VERSION,
+    gestalt
+  };
+}
+function MsgIsResGestalt(msg) {
+  return msg.type === "resGestalt";
+}
+function buildReqOpen(sthis, auth, conn) {
+  return {
+    tid: sthis.nextId().str,
+    auth,
+    type: "reqOpen",
+    version: VERSION,
+    conn: {
+      ...conn,
+      reqId: conn.reqId || sthis.nextId().str
+    }
+  };
+}
+function MsgIsReqOpen(imsg) {
+  const msg = imsg;
+  return msg.type === "reqOpen" && !!msg.conn && !!msg.conn.reqId;
+}
+function MsgIsWithConn(msg) {
+  const mwc = msg.conn;
+  return mwc && !!mwc.reqId && !!mwc.resId;
+}
+function MsgIsWithConnAuth(msg) {
+  return MsgIsWithConn(msg) && !!msg.auth && typeof msg.auth.type === "string";
+}
+function MsgIsConnected(msg, qsid) {
+  return MsgIsWithConn(msg) && msg.conn.reqId === qsid.reqId && msg.conn.resId === qsid.resId;
+}
+function buildResOpen(sthis, req, resStreamId) {
+  if (!(req.conn && req.conn.reqId)) {
+    throw new Error("req.conn.reqId is required");
+  }
+  return {
+    ...req,
+    type: "resOpen",
+    conn: {
+      ...req.conn,
+      resId: req.conn.resId || resStreamId || sthis.nextId().str
+    }
+  };
+}
+function MsgIsResOpen(msg) {
+  return msg.type === "resOpen";
+}
+function MsgIsReqClose(msg) {
+  return msg.type === "reqClose" && MsgIsWithConn(msg);
+}
+function MsgIsResClose(msg) {
+  return msg.type === "resClose" && MsgIsWithConn(msg);
+}
+function buildResClose(req, conn) {
+  return {
+    ...req,
+    type: "resClose",
+    conn
+  };
+}
+function buildReqClose(sthis, auth, conn) {
+  return {
+    tid: sthis.nextId().str,
+    auth,
+    type: "reqClose",
+    version: VERSION,
+    conn
+  };
+}
+function buildErrorMsg(msgCtx, base, error, body, stack) {
+  if (!stack && msgCtx.sthis.env.get("FP_STACK")) {
+    stack = error.stack?.split("\n");
+  }
+  const msg = {
+    auth: base.auth || { type: "error" },
+    src: base,
+    type: "error",
+    tid: base.tid || "internal",
+    message: error.message,
+    version: VERSION,
+    body,
+    stack
+  };
+  msgCtx.logger.Any("ErrorMsg", msg);
+  return msg;
+}
+function MsgIsTenantLedger(msg) {
+  if (MsgIsWithConnAuth(msg)) {
+    const t = msg.tenant;
+    return !!t && !!t.tenant && !!t.ledger;
+  }
+  return false;
+}
+function buildReqSignedUrl(sthis, type, rparam, gwCtx) {
+  return {
+    tid: sthis.nextId().str,
+    type,
+    auth: rparam.auth,
+    methodParams: rparam.methodParam,
+    version: VERSION,
+    ...gwCtx,
+    params: rparam.params
+  };
+}
+function resAuth(msg) {
+  return msg.auth ? Promise.resolve(msg.auth) : Promise.reject(new Error("No Auth"));
+}
+async function buildRes(methodParams, type, msgCtx, req, ctx) {
+  const psm = {
+    type: "reqSignedUrl",
+    auth: await resAuth(req),
+    version: req.version,
+    methodParams,
+    params: {
+      ...req.params
+    },
+    conn: req.conn,
+    tenant: req.tenant,
+    tid: req.tid
+  };
+  const rSignedUrl = await ctx.calculatePreSignedUrl(msgCtx, psm);
+  if (rSignedUrl.isErr()) {
+    return buildErrorMsg(msgCtx, req, rSignedUrl.Err());
+  }
+  return {
+    ...req,
+    params: psm.params,
+    methodParams,
+    type,
+    signedUrl: rSignedUrl.Ok().toString()
+  };
+}
+
+// src/protocols/cloud/msger.ts
+var import_cement25 = require("@adviser/cement");
+
+// src/protocols/cloud/http-connection.ts
+var import_cement23 = require("@adviser/cement");
+
+// src/protocols/cloud/msg-raw-connection-base.ts
+var MsgRawConnectionBase = class {
+  constructor(sthis, exGestalt) {
+    this.onErrorFns = /* @__PURE__ */ new Map();
+    this.sthis = sthis;
+    this.exchangedGestalt = exGestalt;
+  }
+  onError(fn) {
+    const key = this.sthis.nextId().str;
+    this.onErrorFns.set(key, fn);
+    return () => this.onErrorFns.delete(key);
+  }
+  buildErrorMsg(msgCtx, msg, err) {
+    const rmsg = Array.from(this.onErrorFns.values()).reduce((msg2, fn) => {
+      return fn(msg2, err);
+    }, msg);
+    const emsg = buildErrorMsg(msgCtx, rmsg, err);
+    msgCtx.logger.Error().Err(err).Any("msg", rmsg).Msg("connection error");
+    return emsg;
+  }
+};
+
+// src/protocols/cloud/http-connection.ts
+function toHttpProtocol(uri) {
+  const protocol = (uri.getParam("protocol") ?? uri.protocol).replace(/:$/, "");
+  const toFix = uri.build();
+  switch (protocol) {
+    case "ws":
+    case "http":
+      toFix.protocol("http");
+      break;
+    case "https":
+    case "wss":
+    default:
+      toFix.protocol("https");
+      break;
+  }
+  return toFix.URI();
+}
+var HttpConnection = class extends MsgRawConnectionBase {
+  constructor(sthis, uris, msgP, exGestalt) {
+    super(sthis, exGestalt);
+    this.#onMsg = /* @__PURE__ */ new Map();
+    this.activeBinds = /* @__PURE__ */ new Map();
+    this.logger = ensureLogger(sthis, "HttpConnection");
+    this.baseURIs = uris.map((uri) => ({
+      in: uri,
+      cleaned: toHttpProtocol(uri)
+    }));
+    this.msgP = msgP;
+  }
+  #onMsg;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  send(_msg) {
+    throw new Error("Method not implemented.");
+  }
+  async start() {
+    return import_cement23.Result.Ok(void 0);
+  }
+  async close() {
+    await Promise.all(Array.from(this.activeBinds.values()).map((state) => state.controller?.close()));
+    this.#onMsg.clear();
+    return import_cement23.Result.Ok(void 0);
+  }
+  toMsg(msg) {
+    this.#onMsg.forEach((fn) => fn(msg));
+    return msg;
+  }
+  onMsg(fn) {
+    const key = this.sthis.nextId().str;
+    this.#onMsg.set(key, fn);
+    return () => this.#onMsg.delete(key);
+  }
+  #poll(state) {
+    this.request(state.bind.msg, state.bind.opts).then((msg) => {
+      try {
+        state.controller?.enqueue(msg);
+        if (MsgIsError(msg)) {
+          state.controller?.close();
+        } else {
+          state.timeout = setTimeout(() => this.#poll(state), state.bind.opts.pollInterval ?? 1e3);
+        }
+      } catch (err) {
+        state.controller?.error(err);
+        state.controller?.close();
+      }
+    }).catch((err) => {
+      state.controller?.error(err);
+    });
+  }
+  bind(req, opts) {
+    const state = {
+      id: this.sthis.nextId().str,
+      bind: {
+        msg: req,
+        opts
+      }
+    };
+    this.activeBinds.set(state.id, state);
+    return new ReadableStream({
+      cancel: () => {
+        clearTimeout(state.timeout);
+        this.activeBinds.delete(state.id);
+      },
+      start: (controller) => {
+        state.controller = controller;
+        this.#poll(state);
+      }
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async request(req, _opts) {
+    const headers = import_cement23.HttpHeader.from();
+    headers.Set("Content-Type", this.msgP.mime);
+    headers.Set("Accept", this.msgP.mime);
+    const rReqBody = (0, import_cement23.exception2Result)(() => this.msgP.ende.encode(req));
+    if (rReqBody.isErr()) {
+      return this.toMsg(
+        buildErrorMsg(this, req, this.logger.Error().Err(rReqBody.Err()).Any("req", req).Msg("encode error").AsError())
+      );
+    }
+    headers.Set("Content-Length", rReqBody.Ok().byteLength.toString());
+    const url = selectRandom(this.baseURIs);
+    this.logger.Debug().Any(url).Any("body", req).Msg("request");
+    const rRes = await (0, import_cement23.exception2Result)(
+      () => timeout(
+        this.msgP.timeout,
+        fetch(url.cleaned.toString(), {
+          method: "PUT",
+          headers: headers.AsHeaderInit(),
+          body: rReqBody.Ok()
+        })
+      )
+    );
+    this.logger.Debug().Any(url).Any("body", rRes).Msg("response");
+    if (rRes.isErr()) {
+      return this.toMsg(buildErrorMsg(this, req, this.logger.Error().Err(rRes).Any(url).Msg("fetch error").AsError()));
+    }
+    const res = rRes.Ok();
+    if (!res.ok) {
+      const data2 = new Uint8Array(await res.arrayBuffer());
+      const ret2 = await (0, import_cement23.exception2Result)(async () => this.msgP.ende.decode(data2));
+      if (ret2.isErr() || !MsgIsError(ret2.Ok())) {
+        return this.toMsg(
+          buildErrorMsg(
+            this,
+            req,
+            this.logger.Error().Any(url).Str("status", res.status.toString()).Str("statusText", res.statusText).Msg("HTTP Error").AsError(),
+            await res.text()
+          )
+        );
+      }
+      return this.toMsg(ret2.Ok());
+    }
+    const data = new Uint8Array(await res.arrayBuffer());
+    const ret = await (0, import_cement23.exception2Result)(async () => this.msgP.ende.decode(data));
+    if (ret.isErr()) {
+      return this.toMsg(
+        buildErrorMsg(this, req, this.logger.Error().Err(ret.Err()).Msg("decode error").AsError(), this.sthis.txt.decode(data))
+      );
+    }
+    return this.toMsg(ret.Ok());
+  }
+  // toOnMessage<T extends MsgBase>(msg: WithErrorMsg<T>): Result<WithErrorMsg<T>> {
+  //   this.mec.msgFn?.(msg as unknown as MessageEvent<MsgBase>);
+  //   return Result.Ok(msg);
+  // }
+};
+
+// src/protocols/cloud/ws-connection.ts
+var import_cement24 = require("@adviser/cement");
+var WSConnection = class extends MsgRawConnectionBase {
+  constructor(sthis, ws, msgP, exGestalt) {
+    super(sthis, exGestalt);
+    // readonly baseURI: URI;
+    this.#onMsg = /* @__PURE__ */ new Map();
+    this.#onClose = /* @__PURE__ */ new Map();
+    this.waitForTid = /* @__PURE__ */ new Map();
+    this.opened = false;
+    this.#wsOnMessage = async (event) => {
+      const rMsg = await (0, import_cement24.exception2Result)(() => this.msgP.ende.decode(event.data));
+      if (rMsg.isErr()) {
+        this.logger.Error().Err(rMsg).Any(event.data).Msg("Invalid message");
+        return;
+      }
+      const msg = rMsg.Ok();
+      const waitFor = this.waitForTid.get(msg.tid);
+      Array.from(this.#onMsg.values()).forEach((cb) => {
+        cb(msg);
+      });
+      if (waitFor) {
+        if (MsgIsError(msg)) {
+          this.waitForTid.delete(msg.tid);
+          waitFor.future.resolve(msg);
+        } else if (waitFor.waitFor(msg)) {
+          this.waitForTid.delete(msg.tid);
+          waitFor.future.resolve(msg);
+        } else {
+          this.waitForTid.delete(msg.tid);
+          waitFor.future.resolve(msg);
+        }
+      }
+    };
+    this.activeBinds = /* @__PURE__ */ new Map();
+    this.id = sthis.nextId().str;
+    this.logger = ensureLogger(sthis, "WSConnection");
+    this.msgP = msgP;
+    this.ws = ws;
+  }
+  #onMsg;
+  #onClose;
+  async start() {
+    const onOpenFuture = new import_cement24.Future();
+    const timer = setTimeout(() => {
+      const err = this.logger.Error().Dur("timeout", this.msgP.timeout).Msg("Timeout").AsError();
+      this.toMsg(buildErrorMsg(this, {}, err));
+      onOpenFuture.resolve(import_cement24.Result.Err(err));
+    }, this.msgP.timeout);
+    this.ws.onopen = () => {
+      onOpenFuture.resolve(import_cement24.Result.Ok(void 0));
+      this.opened = true;
+    };
+    this.ws.onerror = (ierr) => {
+      const err = this.logger.Error().Err(ierr).Msg("WS Error").AsError();
+      onOpenFuture.resolve(import_cement24.Result.Err(err));
+      const res = this.buildErrorMsg(this, {}, err);
+      this.toMsg(res);
+    };
+    this.ws.onmessage = (evt) => {
+      if (!this.opened) {
+        this.toMsg(buildErrorMsg(this, {}, this.logger.Error().Msg("Received message before onOpen").AsError()));
+      }
+      this.#wsOnMessage(evt);
+    };
+    this.ws.onclose = () => {
+      this.opened = false;
+      this.close().catch((ierr) => {
+        const err = this.logger.Error().Err(ierr).Msg("close error").AsError();
+        onOpenFuture.resolve(import_cement24.Result.Err(err));
+        this.toMsg(buildErrorMsg(this, { tid: "internal" }, err));
+      });
+    };
+    const rOpen = await onOpenFuture.asPromise().finally(() => {
+      clearTimeout(timer);
+    });
+    if (rOpen.isErr()) {
+      return rOpen;
+    }
+    return import_cement24.Result.Ok(void 0);
+  }
+  #wsOnMessage;
+  async close() {
+    this.#onClose.forEach((fn) => fn());
+    this.#onClose.clear();
+    this.#onMsg.clear();
+    this.ws.close();
+    return import_cement24.Result.Ok(void 0);
+  }
+  toMsg(msg) {
+    this.#onMsg.forEach((fn) => fn(msg));
+    return msg;
+  }
+  send(msg) {
+    this.ws.send(this.msgP.ende.encode(msg));
+    return Promise.resolve(msg);
+  }
+  onMsg(fn) {
+    const key = this.sthis.nextId().str;
+    this.#onMsg.set(key, fn);
+    return () => this.#onMsg.delete(key);
+  }
+  onClose(fn) {
+    const key = this.sthis.nextId().str;
+    this.#onClose.set(key, fn);
+    return () => this.#onClose.delete(key);
+  }
+  bind(req, opts) {
+    const state = {
+      id: this.sthis.nextId().str,
+      bind: {
+        msg: req,
+        opts
+      }
+      // timeout: undefined,
+      // controller: undefined,
+    };
+    this.activeBinds.set(state.id, state);
+    return new ReadableStream({
+      cancel: () => {
+        this.activeBinds.delete(state.id);
+      },
+      start: (controller) => {
+        this.onMsg((msg) => {
+          if (MsgIsError(msg)) {
+            controller.enqueue(msg);
+            return;
+          }
+          if (!MsgIsTid(msg, req.tid)) {
+            return;
+          }
+          if (opts.waitFor && opts.waitFor(msg)) {
+            controller.enqueue(msg);
+          }
+        });
+        this.send(req);
+        const future = new import_cement24.Future();
+        this.waitForTid.set(req.tid, { tid: req.tid, future, waitFor: opts.waitFor, timeout: opts.timeout });
+        future.asPromise().then((msg) => {
+          if (MsgIsError(msg)) {
+            controller.enqueue(msg);
+            controller.close();
+          }
+        });
+      }
+    });
+  }
+  async request(req, opts) {
+    if (!this.opened) {
+      return buildErrorMsg(this, req, this.logger.Error().Msg("Connection not open").AsError());
+    }
+    const future = new import_cement24.Future();
+    this.waitForTid.set(req.tid, { tid: req.tid, future, waitFor: opts.waitFor, timeout: opts.timeout });
+    await this.send(req);
+    return future.asPromise();
+  }
+  // toOnMessage<T extends MsgBase>(msg: WithErrorMsg<T>): Result<WithErrorMsg<T>> {
+  //   this.mec.msgFn?.(msg as unknown as MessageEvent<MsgBase>);
+  //   return Result.Ok(msg);
+  // }
+};
+
+// src/protocols/cloud/msger.ts
+function selectRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function timeout(ms, promise) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`TIMEOUT after ${ms}ms`));
+    }, ms);
+    promise.then(resolve).catch(reject).finally(() => clearTimeout(timer));
+  });
+}
+function jsonEnDe(sthis) {
+  return {
+    encode: (node) => sthis.txt.encode(JSON.stringify(node)),
+    decode: (data) => JSON.parse(sthis.txt.decode(data))
+  };
+}
+function defaultMsgParams(sthis, igs) {
+  return {
+    mime: "application/json",
+    ende: jsonEnDe(sthis),
+    timeout: 3e3,
+    protocolCapabilities: ["reqRes", "stream"],
+    ...igs
+  };
+}
+async function applyStart(prC) {
+  const rC = await prC;
+  if (rC.isErr()) {
+    return rC;
+  }
+  const c = rC.Ok();
+  const r = await c.start();
+  if (r.isErr()) {
+    return import_cement25.Result.Err(r.Err());
+  }
+  return rC;
+}
+async function authTypeFromUri(logger, curi) {
+  const uri = import_cement25.URI.from(curi);
+  const authJWK = uri.getParam("authJWK");
+  if (!authJWK) {
+    return logger.Error().Url(uri).Msg("authJWK is required").ResultError();
+  }
+  return import_cement25.Result.Ok({
+    type: "fp-cloud-jwk",
+    params: {
+      // claim: fpc.Ok().payload,
+      jwk: authJWK
+    }
+  });
+}
+var MsgConnected = class _MsgConnected {
+  static async connect(auth, mrc, conn = {}) {
+    if (import_cement25.Result.Is(mrc)) {
+      if (mrc.isErr()) {
+        return import_cement25.Result.Err(mrc.Err());
+      }
+      mrc = mrc.Ok();
+    }
+    const res = await mrc.request(buildReqOpen(mrc.sthis, auth, conn), { waitFor: MsgIsResOpen });
+    if (MsgIsError(res) || !MsgIsResOpen(res)) {
+      return mrc.sthis.logger.Error().Err(res).Msg("unexpected response").ResultError();
+    }
+    return import_cement25.Result.Ok(new _MsgConnected(mrc, res.conn));
+  }
+  constructor(raw2, conn) {
+    this.sthis = raw2.sthis;
+    this.raw = raw2;
+    this.exchangedGestalt = raw2.exchangedGestalt;
+    this.conn = conn;
+    this.activeBinds = raw2.activeBinds;
+    this.id = this.sthis.nextId().str;
+  }
+  attachAuth(auth) {
+    return new MsgConnectedAuth(this, auth);
+  }
+};
+var MsgConnectedAuth = class {
+  constructor(conn, authFactory) {
+    this.id = conn.id;
+    this.raw = conn.raw;
+    this.conn = conn.conn;
+    this.sthis = conn.sthis;
+    this.authFactory = authFactory;
+    this.exchangedGestalt = conn.exchangedGestalt;
+    this.activeBinds = conn.activeBinds;
+  }
+  bind(req, opts) {
+    const stream = this.raw.bind({ ...req, conn: req.conn || this.conn }, opts);
+    const ts = new TransformStream({
+      transform: (chunk, controller) => {
+        if (!MsgIsTid(chunk, req.tid)) {
+          return;
+        }
+        if (MsgIsConnected(chunk, this.conn)) {
+          if (opts.waitFor?.(chunk) || MsgIsError(chunk)) {
+            controller.enqueue(chunk);
+          }
+        }
+      }
+    });
+    stream.pipeThrough(ts);
+    return ts.readable;
+  }
+  authType() {
+    return this.authFactory();
+  }
+  msgConnAuth() {
+    return this.authType().then((r) => {
+      if (r.isErr()) {
+        return import_cement25.Result.Err(r);
+      }
+      return import_cement25.Result.Ok({ conn: this.conn, auth: r.Ok() });
+    });
+  }
+  request(req, opts) {
+    return this.raw.request({ ...req, conn: req.conn || this.conn }, opts);
+  }
+  send(msg) {
+    return this.raw.send({ ...msg, conn: msg.conn || this.conn });
+  }
+  start() {
+    return this.raw.start();
+  }
+  async close(t) {
+    await this.request(buildReqClose(this.sthis, t.auth, this.conn), { waitFor: MsgIsResClose });
+    return await this.raw.close(t);
+  }
+  onMsg(msgFn) {
+    return this.raw.onMsg((msg) => {
+      if (MsgIsConnected(msg, this.conn)) {
+        msgFn(msg);
+      }
+    });
+  }
+};
+function initialFPUri(curl) {
+  let gestaltUrl = import_cement25.URI.from(curl);
+  if (["", "/"].includes(gestaltUrl.pathname)) {
+    gestaltUrl = gestaltUrl.build().appendRelative("/fp").URI();
+  }
+  return gestaltUrl;
+}
+var Msger = class _Msger {
+  static async openHttp(sthis, urls, msgP, exGestalt) {
+    return import_cement25.Result.Ok(new HttpConnection(sthis, urls, msgP, exGestalt));
+  }
+  static async openWS(sthis, url, msgP, exGestalt) {
+    let ws;
+    url = url.build().setParam("random", sthis.nextId().str).URI();
+    if ((0, import_cement25.runtimeFn)().isNodeIsh) {
+      const { WebSocket: WebSocket2 } = await import("ws");
+      ws = new WebSocket2(url.toString());
+    } else {
+      ws = new WebSocket(url.toString());
+    }
+    return import_cement25.Result.Ok(new WSConnection(sthis, ws, msgP, exGestalt));
+  }
+  static async open(sthis, auth, curl, imsgP = {}) {
+    const jsMsgP = defaultMsgParams(sthis, { ...imsgP, mime: "application/json", ende: jsonEnDe(sthis) });
+    const gestaltUrl = initialFPUri(curl);
+    const gs = defaultGestalt(defaultMsgParams(sthis, imsgP), { id: "FP-Universal-Client" });
+    const rHC = await _Msger.openHttp(sthis, [gestaltUrl], jsMsgP, { my: gs, remote: gs });
+    if (rHC.isErr()) {
+      return rHC;
+    }
+    const hc = rHC.Ok();
+    const resGestalt = await hc.request(buildReqGestalt(sthis, auth, gs), {
+      waitFor: MsgIsResGestalt
+    });
+    if (!MsgIsResGestalt(resGestalt)) {
+      return sthis.logger.Error().Any({ resGestalt }).Msg("should be ResGestalt").ResultError();
+    }
+    await hc.close(
+      resGestalt
+      /* as MsgWithConnAuth */
+    );
+    const exGt = { my: gs, remote: resGestalt.gestalt };
+    const msgP = defaultMsgParams(sthis, imsgP);
+    if (exGt.remote.protocolCapabilities.includes("reqRes") && !exGt.remote.protocolCapabilities.includes("stream")) {
+      return applyStart(
+        _Msger.openHttp(
+          sthis,
+          exGt.remote.httpEndpoints.map((i) => import_cement25.BuildURI.from(curl).resolve(i).URI()),
+          msgP,
+          exGt
+        )
+      );
+    }
+    const wsUrl = import_cement25.BuildURI.from(gestaltUrl).resolve(selectRandom(exGt.remote.wsEndpoints)).URI();
+    return applyStart(_Msger.openWS(sthis, wsUrl, msgP, exGt));
+  }
+  static connect(sthis, auth, curl, imsgP = {}, conn = {}) {
+    return _Msger.open(sthis, auth, curl, imsgP).then((srv) => MsgConnected.connect(auth, srv, conn));
+  }
+  constructor() {
+  }
+};
+
+// src/protocols/cloud/msg-types-data.ts
+function buildReqGetData(sthis, sup, ctx) {
+  return buildReqSignedUrl(sthis, "reqGetData", sup, ctx);
+}
+function MsgIsReqGetData(msg) {
+  return msg.type === "reqGetData";
+}
+function MsgIsResGetData(msg) {
+  return msg.type === "resGetData" && MsgIsTenantLedger(msg);
+}
+function buildResGetData(msgCtx, req, ctx) {
+  return buildRes(
+    { method: "GET", store: req.methodParams.store },
+    "resGetData",
+    msgCtx,
+    req,
+    ctx
+  );
+}
+function MsgIsReqPutData(msg) {
+  return msg.type === "reqPutData";
+}
+function buildReqPutData(sthis, sup, ctx) {
+  return buildReqSignedUrl(sthis, "reqPutData", sup, ctx);
+}
+function MsgIsResPutData(msg) {
+  return msg.type === "resPutData";
+}
+function buildResPutData(msgCtx, req, ctx) {
+  return buildRes(
+    { method: "PUT", store: req.methodParams.store },
+    "resPutData",
+    msgCtx,
+    req,
+    ctx
+  );
+}
+function MsgIsReqDelData(msg) {
+  return msg.type === "reqDelData";
+}
+function buildReqDelData(sthis, sup, ctx) {
+  return buildReqSignedUrl(sthis, "reqDelData", sup, ctx);
+}
+function MsgIsResDelData(msg) {
+  return msg.type === "resDelData";
+}
+function buildResDelData(msgCtx, req, ctx) {
+  return buildRes(
+    { method: "DELETE", store: req.methodParams.store },
+    "resDelData",
+    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,
+    methodParams: {
+      method: "PUT",
+      store: "meta"
+    },
+    params: signedUrlParams,
+    meta
+  };
+}
+function MsgIsReqPutMeta(msg) {
+  return msg.type === "reqPutMeta";
+}
+function buildResPutMeta(_msgCtx, req, meta, signedUrl) {
+  return {
+    meta,
+    tid: req.tid,
+    conn: req.conn,
+    auth: req.auth,
+    methodParams: req.methodParams,
+    params: req.params,
+    tenant: req.tenant,
+    type: "resPutMeta",
+    signedUrl,
+    version: import_cement26.VERSION
+  };
+}
+function MsgIsResPutMeta(qs) {
+  return qs.type === "resPutMeta";
+}
+function MsgIsBindGetMeta(msg) {
+  return msg.type === "bindGetMeta";
+}
+function buildBindGetMeta(sthis, auth, params, gwCtx) {
+  return {
+    auth,
+    tid: sthis.nextId().str,
+    ...gwCtx,
+    type: "bindGetMeta",
+    version: import_cement26.VERSION,
+    params
+  };
+}
+function buildEventGetMeta(_msgCtx, req, meta, gwCtx, signedUrl) {
+  return {
+    conn: gwCtx.conn,
+    tenant: req.tenant,
+    auth: req.auth,
+    tid: req.tid,
+    meta,
+    signedUrl,
+    type: "eventGetMeta",
+    params: req.params,
+    methodParams: { method: "GET", store: "meta" },
+    version: import_cement26.VERSION
+  };
+}
+function MsgIsEventGetMeta(qs) {
+  return qs.type === "eventGetMeta";
+}
+function buildReqDelMeta(sthis, auth, params, gwCtx, meta) {
+  return {
+    auth,
+    tid: sthis.nextId().str,
+    tenant: gwCtx.tenant,
+    conn: gwCtx.conn,
+    params,
+    meta,
+    type: "reqDelMeta",
+    version: import_cement26.VERSION
+    // params: signedUrlParams,
+  };
+}
+function MsgIsReqDelMeta(msg) {
+  return msg.type === "reqDelMeta";
+}
+function buildResDelMeta(req, params, signedUrl) {
+  return {
+    auth: req.auth,
+    methodParams: { method: "DELETE", store: "meta" },
+    params,
+    signedUrl,
+    tid: req.tid,
+    conn: req.conn,
+    tenant: req.tenant,
+    type: "resDelMeta",
+    // key: req.key,
+    version: import_cement26.VERSION
+  };
+}
+function MsgIsResDelMeta(qs) {
+  return qs.type === "resDelMeta";
+}
+
+// src/runtime/meta-key-hack.ts
+var import_cement27 = require("@adviser/cement");
+function fromV1toV2SerializedMetaKey(v1s, keys = []) {
+  const res = v1s.reduce(
+    (acc, v1) => {
+      const keys2 = [];
+      if (v1.key) {
+        if (typeof v1.key === "string") {
+          acc.keys.add(v1.key);
+        } else {
+          keys2.push(...v1.key);
+        }
+      }
+      if (v1.keys) {
+        keys2.push(...v1.keys);
+      }
+      for (const key of keys2) {
+        acc.keys.add(key);
+      }
+      if (typeof v1.cid === "string" && (!v1.data || typeof v1.data === "string") && (!v1.parents || Array.isArray(v1.parents))) {
+        acc.metas.set(v1.cid, {
+          data: v1.data ?? "",
+          parents: v1.parents ?? [],
+          cid: v1.cid
+        });
+      }
+      return acc;
+    },
+    {
+      metas: /* @__PURE__ */ new Map(),
+      keys: new Set(keys)
+    }
+  );
+  return {
+    metas: Array.from(res.metas.values()),
+    keys: Array.from(res.keys)
+  };
+}
+function isV2SerializedMetaKey(or) {
+  const my = or;
+  return my !== null && (!my.keys || Array.isArray(my.keys)) && (!my.metas || Array.isArray(my.metas));
+}
+function toV2SerializedMetaKey(or) {
+  if (Array.isArray(or)) {
+    return fromV1toV2SerializedMetaKey(or);
+  }
+  if (isV2SerializedMetaKey(or)) {
+    return fromV1toV2SerializedMetaKey(or.metas ?? [], or.keys ?? []);
+  }
+  throw new Error("not a valid serialized meta key");
+}
+async function V2SerializedMetaKeyExtractKey(ctx, v2) {
+  const kb = await ctx.loader.keyBag();
+  if (!kb) {
+    return Promise.resolve(import_cement27.Result.Err(new Error("missing keybag")));
+  }
+  const dataUrl = await ctx.loader.attachedStores.local().active.car.url();
+  const keyName = dataUrl.getParam(PARAM.STORE_KEY);
+  if (!keyName) {
+    ctx.loader.sthis.logger.Warn().Url(dataUrl).Msg("missing store key");
+  } else {
+    const rKey = await kb.getNamedKey(keyName);
+    if (rKey.isErr()) {
+      ctx.loader.sthis.logger.Warn().Str("keyName", keyName).Msg("did not found a extractable key");
+    } else {
+      for (const keyStr of v2.keys) {
+        const res = await rKey.Ok().upsert(keyStr, false);
+        if (res.isErr()) {
+          ctx.loader.sthis.logger.Warn().Str("keyStr", keyStr).Msg("failed to upsert key");
+        }
+      }
+    }
+  }
+  return Promise.resolve(import_cement27.Result.Ok(v2.metas));
+}
+async function decodeAsToSerializedMeta(ctx, raw2) {
+  const rJsObj = (0, import_cement27.exception2Result)(() => JSON.parse(ctx.loader.sthis.txt.decode(raw2)));
+  if (rJsObj.isErr()) {
+    return import_cement27.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_cement27.Result.Ok({
+    metas: metas.Ok(),
+    keys: v2.keys
+  });
+}
+function addKeyToDbMetaDecoder(ctx) {
+  const lastDecodedMetas = ctx.lastDecodedMetas ?? [];
+  return {
+    ...ctx,
+    lastDecodedMetas,
+    decoder: {
+      meta: async (sthis, raw2) => {
+        const r = await decodeAsToSerializedMeta(ctx, raw2);
+        if (r.isErr()) {
+          return Promise.resolve(import_cement27.Result.Err(r));
+        }
+        if (lastDecodedMetas.length > 2) {
+          lastDecodedMetas.shift();
+        }
+        lastDecodedMetas.push(r.Ok());
+        return Promise.resolve(import_cement27.Result.Ok(r.Ok().metas));
+      }
+    }
+  };
+}
+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")));
+  }
+  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()));
+  }
+  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)));
+}
+function encodeAsV1SerializedMetaKey(ctx, payload) {
+  return wrapEncode(ctx, payload, (payload2, keyM) => payload2.map((p) => ({ ...p, key: keyM })));
+}
+function encodeAsV2SerializedMetaKey(ctx, payload) {
+  return wrapEncode(
+    ctx,
+    payload,
+    (payload2, keyM) => ({
+      metas: payload2,
+      keys: keyM
+    })
+  );
+}
+function addKeyToDbMetaEncoder(ctx, version) {
+  return {
+    ...ctx,
+    encoder: {
+      meta: async (sthis, payload) => {
+        let obj;
+        switch (version) {
+          case "v1":
+            obj = await encodeAsV1SerializedMetaKey(ctx, payload);
+            break;
+          case "v2":
+            obj = await encodeAsV2SerializedMetaKey(ctx, payload);
+            break;
+          default:
+            return Promise.resolve(import_cement27.Result.Err(`unknown version:[${version}]`));
+        }
+        if (obj.isErr()) {
+          return Promise.resolve(import_cement27.Result.Err(obj));
+        }
+        try {
+          return Promise.resolve(import_cement27.Result.Ok(sthis.txt.encode(JSON.stringify(obj.Ok()))));
+        } catch (e) {
+          return Promise.resolve(import_cement27.Result.Err(e));
+        }
+      }
+    }
+  };
+}
+var AddKeyToDbMetaGateway = class {
+  constructor(gw, version) {
+    // only for tests
+    this.lastDecodedMetas = [];
+    this.sdGw = new DefSerdeGateway(gw);
+    this.version = version;
+  }
+  buildUrl(ctx, baseUrl, key) {
+    return this.sdGw.buildUrl(ctx, baseUrl, key);
+  }
+  start(ctx, baseUrl) {
+    return this.sdGw.start(ctx, baseUrl);
+  }
+  close(ctx, baseUrl) {
+    return this.sdGw.close(ctx, baseUrl);
+  }
+  async put(ctx, url, body) {
+    return this.sdGw.put(addKeyToDbMetaEncoder(ctx, this.version), url, body);
+  }
+  async get(ctx, url) {
+    return this.sdGw.get(addKeyToDbMetaDecoder({ ...ctx, lastDecodedMetas: this.lastDecodedMetas }), url);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  delete(ctx, url, loader) {
+    return this.sdGw.delete(ctx, url);
+  }
+  subscribe(ctx, url, callback) {
+    return this.sdGw.subscribe(addKeyToDbMetaDecoder({ ...ctx, lastDecodedMetas: this.lastDecodedMetas }), url, callback);
+  }
+  getPlain(ctx, url, key) {
+    return this.sdGw.getPlain(ctx, url, key);
+  }
+  destroy(ctx, baseUrl) {
+    return this.sdGw.destroy(ctx, baseUrl);
+  }
+};
+
+// src/runtime/gateways/cloud/gateway.ts
+var VERSION3 = "v0.1-fp-cloud";
+var BaseGateway = class {
+  constructor(sthis, module2) {
+    this.sthis = sthis;
+    this.logger = ensureLogger(sthis, module2);
+  }
+  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
+    });
+    if (rParams.isErr()) {
+      return buildErrorMsg(this, {}, rParams.Err());
+    }
+    const params = rParams.Ok();
+    if (store !== params.store) {
+      return buildErrorMsg(this, {}, new Error("store mismatch"));
+    }
+    const rAuth = await authTypeFromUri(this.logger, uri);
+    if (rAuth.isErr()) {
+      return buildErrorMsg(this, {}, rAuth.Err());
+    }
+    return {
+      tid: this.sthis.nextId().str,
+      auth: rAuth.Ok(),
+      type,
+      conn: conn.conn.Ok().conn,
+      tenant: {
+        tenant: params.tenant,
+        ledger: params.name
+      },
+      // tenant: conn.tenant,
+      methodParams: {
+        method,
+        store
+      },
+      params: {
+        ...params,
+        key: params.key
+      },
+      version: VERSION3
+    };
+  }
+  async getReqSignedUrl(type, method, store, waitForFn, uri, conn) {
+    const rsu = await this.buildReqSignedUrl(type, method, store, uri, conn);
+    if (MsgIsError(rsu)) {
+      return rsu;
+    }
+    return conn.conn.Ok().request(rsu, { waitFor: waitForFn });
+  }
+  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 }));
+    if (rUpload.isErr()) {
+      return this.logger.Error().Url(uploadUrl, "uploadUrl").Err(rUpload).Msg("Error in put fetch").ResultError();
+    }
+    if (!rUpload.Ok().ok) {
+      return this.logger.Error().Url(uploadUrl, "uploadUrl").Http(rUpload.Ok()).Msg("Error in put fetch").ResultError();
+    }
+    if (uri.getParam("testMode")) {
+      conn.citem.trackPuts.add(uri.toString());
+    }
+    return import_cement28.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" }));
+    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 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()));
+  }
+  // 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" }));
+    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 this.logger.Error().Url(deleteUrl, "deleteUrl").Err(rDelete).Msg("Error in del fetch").ResultError();
+    }
+    return import_cement28.Result.Ok(void 0);
+  }
+};
+var DataGateway = class extends BaseGateway {
+  constructor(sthis) {
+    super(sthis, "DataGateway");
+  }
+  async get(ctx, uri) {
+    const store = coerceFPStoreTypes(uri.getParam("store"));
+    const rResSignedUrl = await this.getReqSignedUrl("reqGetData", "GET", store, MsgIsResGetData, uri, ctx.conn);
+    if (MsgIsError(rResSignedUrl)) {
+      return this.logger.Error().Err(rResSignedUrl).Msg("Error in buildResSignedUrl").ResultError();
+    }
+    const { signedUrl: downloadUrl } = rResSignedUrl;
+    const r = await fpDeserialize(this.sthis, uri, this.getObject(uri, downloadUrl, ctx.conn));
+    return r;
+  }
+  async put(ctx, uri, data) {
+    const store = coerceFPStoreTypes(uri.getParam("store"));
+    const rResSignedUrl = await this.getReqSignedUrl("reqPutData", "PUT", store, MsgIsResPutData, uri, ctx.conn);
+    if (MsgIsError(rResSignedUrl)) {
+      return this.logger.Error().Err(rResSignedUrl).Msg("Error in buildResSignedUrl").ResultError();
+    }
+    const { signedUrl: uploadUrl } = rResSignedUrl;
+    const rBlob = await fpSerialize(ctx.loader.sthis, data);
+    if (rBlob.isErr()) {
+      return rBlob;
+    }
+    const r = await this.putObject(uri, uploadUrl, rBlob.Ok(), ctx.conn);
+    return r;
+  }
+  async delete(ctx, uri) {
+    const store = coerceFPStoreTypes(uri.getParam("store"));
+    const rResSignedUrl = await this.getReqSignedUrl("reqDelData", "DELETE", store, MsgIsResDelData, uri, ctx.conn);
+    if (MsgIsError(rResSignedUrl)) {
+      return this.logger.Error().Err(rResSignedUrl).Msg("Error in buildResSignedUrl").ResultError();
+    }
+    const { signedUrl: deleteUrl } = rResSignedUrl;
+    return this.delObject(uri, deleteUrl, ctx.conn);
+  }
+};
+function getGwCtx(conn, uri) {
+  const rParams = uri.getParamsResult({
+    tid: import_cement28.param.OPTIONAL,
+    tenant: import_cement28.param.REQUIRED,
+    ledger: import_cement28.param.REQUIRED
+  });
+  if (rParams.isErr()) {
+    return import_cement28.Result.Err(rParams);
+  }
+  const r = rParams.Ok();
+  return import_cement28.Result.Ok({
+    tid: r.tid,
+    conn,
+    tenant: {
+      tenant: r.tenant,
+      ledger: r.ledger
+    }
+  });
+}
+var MetaGateway = class extends BaseGateway {
+  constructor(sthis) {
+    super(sthis, "MetaGateway");
+  }
+  async get(ctx, uri) {
+    const reqSignedUrl = await this.buildReqSignedUrl("bindGetMeta", "GET", "meta", uri, ctx.conn);
+    if (MsgIsError(reqSignedUrl)) {
+      return this.logger.Error().Err(reqSignedUrl).Msg("Error in buildReqSignedUrl").ResultError();
+    }
+    const rGwCtx = getGwCtx(ctx.conn.conn.Ok().conn, uri);
+    if (rGwCtx.isErr()) {
+      return import_cement28.Result.Err(rGwCtx);
+    }
+    const rAuthType = await ctx.conn.conn.Ok().authType();
+    if (rAuthType.isErr()) {
+      return import_cement28.Result.Err(rAuthType);
+    }
+    const res = await ctx.conn.conn.Ok().request(buildBindGetMeta(ctx.loader.sthis, rAuthType.Ok(), reqSignedUrl.params, rGwCtx.Ok()), {
+      waitFor: MsgIsEventGetMeta
+    });
+    if (MsgIsError(res)) {
+      return this.logger.Error().Err(res).Msg("Error in buildBindGetMeta").ResultError();
+    }
+    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_cement28.Result.Ok({
+      type: "meta",
+      payload: rMeta.Ok()
+    });
+  }
+  async put(ctx, uri, imeta) {
+    const meta = imeta;
+    const reqSignedUrl = await this.buildReqSignedUrl("reqPutMeta", "PUT", "meta", uri, ctx.conn);
+    if (MsgIsError(reqSignedUrl)) {
+      return this.logger.Error().Err(reqSignedUrl).Msg("Error in buildReqSignedUrl").ResultError();
+    }
+    const rGwCtx = getGwCtx(ctx.conn.conn.Ok().conn, uri);
+    if (rGwCtx.isErr()) {
+      return import_cement28.Result.Err(rGwCtx);
+    }
+    const rAuthType = await ctx.conn.conn.Ok().authType();
+    if (rAuthType.isErr()) {
+      return import_cement28.Result.Err(rAuthType);
+    }
+    const serializedMeta = await dbMetaEvent2Serialized(ctx.loader.sthis, meta.payload);
+    const rKeyedMeta = await encodeAsV2SerializedMetaKey(ctx, serializedMeta);
+    if (rKeyedMeta.isErr()) {
+      return rKeyedMeta;
+    }
+    const reqPutMeta = buildReqPutMeta(ctx.loader.sthis, rAuthType.Ok(), reqSignedUrl.params, rKeyedMeta.Ok(), rGwCtx.Ok());
+    const resMsg = await ctx.conn.conn.Ok().request(reqPutMeta, {
+      waitFor: MsgIsResPutMeta
+    });
+    if (MsgIsError(resMsg)) {
+      return this.logger.Error().Err(resMsg).Msg("Error in buildResSignedUrl").ResultError();
+    }
+    return import_cement28.Result.Ok(void 0);
+  }
+  async delete(ctx, uri) {
+    const reqSignedUrl = await this.getReqSignedUrl("reqDelMeta", "DELETE", "meta", MsgIsResDelData, uri, ctx.conn);
+    if (MsgIsError(reqSignedUrl)) {
+      return this.logger.Error().Err(reqSignedUrl).Msg("Error in buildReqSignedUrl").ResultError();
+    }
+    const rGwCtx = getGwCtx(ctx.conn.conn.Ok().conn, uri);
+    if (rGwCtx.isErr()) {
+      return import_cement28.Result.Err(rGwCtx);
+    }
+    const rAuthType = await ctx.conn.conn.Ok().authType();
+    if (rAuthType.isErr()) {
+      return import_cement28.Result.Err(rAuthType);
+    }
+    const reqDelMeta = buildReqDelMeta(ctx.loader.sthis, rAuthType.Ok(), reqSignedUrl.params, rGwCtx.Ok());
+    const resMsg = await ctx.conn.conn.Ok().request(reqDelMeta, {
+      waitFor: MsgIsResDelData
+    });
+    if (MsgIsError(resMsg)) {
+      return this.logger.Error().Err(resMsg).Msg("Error in buildResSignedUrl").ResultError();
+    }
+    return import_cement28.Result.Ok(void 0);
+  }
+};
+var WALGateway = class extends BaseGateway {
+  constructor(sthis) {
+    super(sthis, "WALGateway");
+    // WAL will not pollute to the cloud
+    this.wals = /* @__PURE__ */ new Map();
+  }
+  getWalKeyFromUri(uri) {
+    const rKey = uri.getParamsResult({
+      key: 0,
+      name: 0
+    });
+    if (rKey.isErr()) {
+      return import_cement28.Result.Err(rKey.Err());
+    }
+    const { name, key } = rKey.Ok();
+    return import_cement28.Result.Ok(`${name}:${key}`);
+  }
+  async get(ctx, uri) {
+    const rKey = this.getWalKeyFromUri(uri);
+    if (rKey.isErr()) {
+      return import_cement28.Result.Err(rKey.Err());
+    }
+    const wal = this.wals.get(rKey.Ok());
+    if (!wal) {
+      return import_cement28.Result.Err(new NotFoundError("Not found"));
+    }
+    return import_cement28.Result.Ok(wal);
+  }
+  async put(ctx, uri, body) {
+    const rKey = this.getWalKeyFromUri(uri);
+    if (rKey.isErr()) {
+      return import_cement28.Result.Err(rKey.Err());
+    }
+    this.wals.set(rKey.Ok(), body);
+    return import_cement28.Result.Ok(void 0);
+  }
+  async delete(ctx, uri) {
+    const rKey = this.getWalKeyFromUri(uri);
+    if (rKey.isErr()) {
+      return import_cement28.Result.Err(rKey.Err());
+    }
+    this.wals.delete(rKey.Ok());
+    return import_cement28.Result.Ok(void 0);
+  }
+};
+var storeTypedGateways = new import_cement28.KeyedResolvOnce();
+function getStoreTypeGateway(sthis, uri) {
+  const store = uri.getParam("store");
+  switch (store) {
+    case "file":
+    case "car":
+      return storeTypedGateways.get(store).once(() => new DataGateway(sthis));
+    case "meta":
+      return storeTypedGateways.get(store).once(() => new MetaGateway(sthis));
+    case "wal":
+      return storeTypedGateways.get(store).once(() => new WALGateway(sthis));
+    default:
+      throw ensureLogger(sthis, "getStoreTypeGateway").Error().Str("store", store).Msg("Invalid store type").ResultError();
+  }
+}
+function connectionURI(uri) {
+  return uri.build().delParam("authJWK").delParam("key").delParam("store").delParam("suffix").delParam("storekey").URI();
+}
+var subscriptions = /* @__PURE__ */ new Map();
+var FireproofCloudGateway = class {
+  #connectionURIs = /* @__PURE__ */ new Map();
+  constructor(sthis) {
+    this.sthis = sthis;
+    this.logger = ensureLogger(sthis, "FireproofCloudGateway", {
+      this: true
+    });
+  }
+  async buildUrl(ctx, baseUrl, key) {
+    return import_cement28.Result.Ok(baseUrl.build().setParam("key", key).URI());
+  }
+  async start(ctx, uri) {
+    await this.sthis.start();
+    const rName = uri.getParamResult("name");
+    if (rName.isErr()) {
+      return this.logger.Error().Err(rName).Msg("name not found").ResultError();
+    }
+    const ret = uri.build().defParam("version", VERSION3);
+    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(),
+      trackPuts: /* @__PURE__ */ new Set()
+    });
+    return import_cement28.Result.Ok(retURI);
+  }
+  async get(ctx, uri) {
+    const conn = await this.getCloudConnectionItem(uri);
+    if (conn.conn.isErr()) {
+      return import_cement28.Result.Err(conn.conn);
+    }
+    const ret = await getStoreTypeGateway(ctx.loader.sthis, uri).get({ ...ctx, conn }, uri);
+    return ret;
+  }
+  async put(ctx, uri, body) {
+    const conn = await this.getCloudConnectionItem(uri);
+    if (conn.conn.isErr()) {
+      return conn.conn;
+    }
+    const ret = await getStoreTypeGateway(ctx.loader.sthis, uri).put({ ...ctx, conn }, uri, body);
+    if (ret.isOk()) {
+      if (uri.getParam("testMode")) {
+        conn.citem.trackPuts.add(uri.toString());
+      }
+    }
+    return ret;
+  }
+  async delete(ctx, uri) {
+    const conn = await this.getCloudConnectionItem(uri);
+    if (conn.conn.isErr()) {
+      return conn.conn;
+    }
+    conn.citem.trackPuts.delete(uri.toString());
+    return getStoreTypeGateway(ctx.loader.sthis, uri).delete({ ...ctx, conn }, uri);
+  }
+  async close(ctx, uri) {
+    const uriStr = uri.toString();
+    for (const sub of Array.from(subscriptions.values())) {
+      for (const s of sub) {
+        if (s.uri.toString() === uriStr) {
+          s.unsub();
+        }
+      }
+    }
+    const rConn = await this.getCloudConnectionItem(uri);
+    if (rConn.conn.isErr()) {
+      return this.logger.Error().Err(rConn).Msg("Error in getCloudConnection").ResultError();
+    }
+    const conn = rConn.conn.Ok();
+    const rAuth = await conn.msgConnAuth();
+    await conn.close(rAuth.Ok());
+    this.#connectionURIs.delete(rConn.citem.uri.toString());
+    return import_cement28.Result.Ok(void 0);
+  }
+  // fireproof://localhost:1999/?name=test-public-api&protocol=ws&store=meta
+  async getCloudConnection(uri) {
+    return this.getCloudConnectionItem(uri).then((r) => {
+      return r.conn;
+    });
+  }
+  async getCloudConnectionItem(uri) {
+    const matchURI = connectionURI(uri);
+    let bestMatch;
+    for (const ci of this.#connectionURIs.values()) {
+      const mci = ci.uri.match(matchURI);
+      if (mci.score >= ci.matchRes.score) {
+        bestMatch = ci;
+        break;
+      }
+    }
+    if (!bestMatch) {
+      return {
+        conn: this.logger.Error().Url(matchURI).Any("conns", Object.fromEntries(this.#connectionURIs.entries())).Msg("No connection found").ResultError(),
+        citem: {}
+      };
+    }
+    const conn = await bestMatch.connection.once(async () => {
+      const rParams = uri.getParamsResult({
+        name: import_cement28.param.REQUIRED,
+        protocol: "https",
+        store: import_cement28.param.REQUIRED,
+        storekey: import_cement28.param.OPTIONAL,
+        tenant: import_cement28.param.REQUIRED
+      });
+      if (rParams.isErr()) {
+        return this.logger.Error().Url(uri).Err(rParams).Msg("getCloudConnection:err").ResultError();
+      }
+      const params = rParams.Ok();
+      const rAuth = await authTypeFromUri(this.logger, uri);
+      if (rAuth.isErr()) {
+        return import_cement28.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_cement28.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) {
+  //     try {
+  //       cb(data);
+  //     } catch (error) {
+  //       this.logger.Error().Err(error).Msg("Error in subscriber callback execution");
+  //     }
+  //   }
+  // }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async subscribe(ctx, url, callback) {
+    return import_cement28.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);
+  }
+  async getPlain() {
+    return import_cement28.Result.Err(new Error("Not implemented"));
+  }
+};
+var onceRegisterFireproofCloudStoreProtocol = new import_cement28.KeyedResolvOnce();
+function registerFireproofCloudStoreProtocol(protocol = "fpcloud:") {
+  return onceRegisterFireproofCloudStoreProtocol.get(protocol).once(() => {
+    import_cement28.URI.protocolHasHostpart(protocol);
+    return registerStoreProtocol({
+      protocol,
+      defaultURI() {
+        return import_cement28.URI.from("fpcloud://fireproof.cloud/");
+      },
+      serdegateway: async (sthis) => {
+        return new FireproofCloudGateway(sthis);
+      }
+    });
+  });
+}
+registerFireproofCloudStoreProtocol();
+function toCloud(url) {
+  const urlObj = import_cement28.URI.from(url);
+  if (urlObj.protocol !== "fpcloud:") {
+    throw new Error("url must have fireproof protocol");
+  }
+  return {
+    name: urlObj.protocol,
+    prepare() {
+      return Promise.resolve({
+        car: { url: urlObj },
+        file: { url: urlObj },
+        meta: { url: urlObj }
+      });
+    }
+  };
+}
+
+// src/protocols/index.ts
+var protocols_exports = {};
+__export(protocols_exports, {
+  cloud: () => cloud_exports
+});
+
+// src/protocols/cloud/index.ts
+var cloud_exports = {};
+__export(cloud_exports, {
+  HttpConnection: () => HttpConnection,
+  MsgConnected: () => MsgConnected,
+  MsgConnectedAuth: () => MsgConnectedAuth,
+  MsgIsBindGetMeta: () => MsgIsBindGetMeta,
+  MsgIsConnected: () => MsgIsConnected,
+  MsgIsError: () => MsgIsError,
+  MsgIsEventGetMeta: () => MsgIsEventGetMeta,
+  MsgIsQSError: () => MsgIsQSError,
+  MsgIsReqChat: () => MsgIsReqChat,
+  MsgIsReqClose: () => MsgIsReqClose,
+  MsgIsReqDelData: () => MsgIsReqDelData,
+  MsgIsReqDelMeta: () => MsgIsReqDelMeta,
+  MsgIsReqDelWAL: () => MsgIsReqDelWAL,
+  MsgIsReqGestalt: () => MsgIsReqGestalt,
+  MsgIsReqGetData: () => MsgIsReqGetData,
+  MsgIsReqGetWAL: () => MsgIsReqGetWAL,
+  MsgIsReqOpen: () => MsgIsReqOpen,
+  MsgIsReqPutData: () => MsgIsReqPutData,
+  MsgIsReqPutMeta: () => MsgIsReqPutMeta,
+  MsgIsReqPutWAL: () => MsgIsReqPutWAL,
+  MsgIsResChat: () => MsgIsResChat,
+  MsgIsResClose: () => MsgIsResClose,
+  MsgIsResDelData: () => MsgIsResDelData,
+  MsgIsResDelMeta: () => MsgIsResDelMeta,
+  MsgIsResDelWAL: () => MsgIsResDelWAL,
+  MsgIsResGestalt: () => MsgIsResGestalt,
+  MsgIsResGetData: () => MsgIsResGetData,
+  MsgIsResGetWAL: () => MsgIsResGetWAL,
+  MsgIsResOpen: () => MsgIsResOpen,
+  MsgIsResPutData: () => MsgIsResPutData,
+  MsgIsResPutMeta: () => MsgIsResPutMeta,
+  MsgIsResPutWAL: () => MsgIsResPutWAL,
+  MsgIsTenantLedger: () => MsgIsTenantLedger,
+  MsgIsTid: () => MsgIsTid,
+  MsgIsWithConn: () => MsgIsWithConn,
+  MsgIsWithConnAuth: () => MsgIsWithConnAuth,
+  MsgRawConnectionBase: () => MsgRawConnectionBase,
+  Msger: () => Msger,
+  VERSION: () => VERSION,
+  WSConnection: () => WSConnection,
+  applyStart: () => applyStart,
+  authTypeFromUri: () => authTypeFromUri,
+  buildBindGetMeta: () => buildBindGetMeta,
+  buildErrorMsg: () => buildErrorMsg,
+  buildEventGetMeta: () => buildEventGetMeta,
+  buildReqChat: () => buildReqChat,
+  buildReqClose: () => buildReqClose,
+  buildReqDelData: () => buildReqDelData,
+  buildReqDelMeta: () => buildReqDelMeta,
+  buildReqDelWAL: () => buildReqDelWAL,
+  buildReqGestalt: () => buildReqGestalt,
+  buildReqGetData: () => buildReqGetData,
+  buildReqGetWAL: () => buildReqGetWAL,
+  buildReqOpen: () => buildReqOpen,
+  buildReqPutData: () => buildReqPutData,
+  buildReqPutMeta: () => buildReqPutMeta,
+  buildReqPutWAL: () => buildReqPutWAL,
+  buildReqSignedUrl: () => buildReqSignedUrl,
+  buildRes: () => buildRes,
+  buildResChat: () => buildResChat,
+  buildResClose: () => buildResClose,
+  buildResDelData: () => buildResDelData,
+  buildResDelMeta: () => buildResDelMeta,
+  buildResDelWAL: () => buildResDelWAL,
+  buildResGestalt: () => buildResGestalt,
+  buildResGetData: () => buildResGetData,
+  buildResGetWAL: () => buildResGetWAL,
+  buildResOpen: () => buildResOpen,
+  buildResPutData: () => buildResPutData,
+  buildResPutMeta: () => buildResPutMeta,
+  buildResPutWAL: () => buildResPutWAL,
+  coerceFPStoreTypes: () => coerceFPStoreTypes,
+  defaultGestalt: () => defaultGestalt,
+  defaultMsgParams: () => defaultMsgParams,
+  isAuthTypeFPCloud: () => isAuthTypeFPCloud,
+  isAuthTypeFPCloudJWK: () => isAuthTypeFPCloudJWK,
+  isProtocolCapabilities: () => isProtocolCapabilities,
+  jsonEnDe: () => jsonEnDe,
+  keyTenantLedger: () => keyTenantLedger,
+  qsidEqual: () => qsidEqual,
+  qsidKey: () => qsidKey,
+  resAuth: () => resAuth,
+  selectRandom: () => selectRandom,
+  timeout: () => timeout
+});
+
+// src/protocols/cloud/msg-types-wal.ts
+function MsgIsReqGetWAL(msg) {
+  return msg.type === "reqGetWAL";
+}
+function buildReqGetWAL(sthis, sup, ctx) {
+  return buildReqSignedUrl(sthis, "reqGetWAL", sup, ctx);
+}
+function MsgIsResGetWAL(msg) {
+  return msg.type === "resGetWAL";
+}
+function buildResGetWAL(msgCtx, req, ctx) {
+  return buildRes(
+    { method: "GET", store: "wal" },
+    "resGetWAL",
+    msgCtx,
+    req,
+    ctx
+  );
+}
+function MsgIsReqPutWAL(msg) {
+  return msg.type === "reqPutWAL";
+}
+function buildReqPutWAL(sthis, sup, ctx) {
+  return buildReqSignedUrl(sthis, "reqPutWAL", sup, ctx);
+}
+function MsgIsResPutWAL(msg) {
+  return msg.type === "resPutWAL";
+}
+function buildResPutWAL(msgCtx, req, ctx) {
+  return buildRes(
+    { method: "PUT", store: "wal" },
+    "resPutWAL",
+    msgCtx,
+    req,
+    ctx
+  );
+}
+function MsgIsReqDelWAL(msg) {
+  return msg.type === "reqDelWAL";
+}
+function buildReqDelWAL(sthis, sup, ctx) {
+  return buildReqSignedUrl(sthis, "reqDelWAL", sup, ctx);
+}
+function MsgIsResDelWAL(msg) {
+  return msg.type === "resDelWAL" && MsgIsTenantLedger(msg);
+}
+function buildResDelWAL(msgCtx, req, ctx) {
+  return buildRes(
+    { method: "DELETE", store: "wal" },
+    "resDelWAL",
+    msgCtx,
+    req,
+    ctx
+  );
+}
+
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-55": "xxxx"
+  "0.20.0-dev-preview-57": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map