@camstack/sdk 0.1.23 → 0.1.24

package/dist/index.js

@@ -1,8 +1,1766 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+// node_modules/@trpc/client/dist/objectSpread2-BvkFp-_Y.mjs
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = /* @__PURE__ */ __name((cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+}, "__commonJS");
+var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+    key = keys[i];
+    if (!__hasOwnProp.call(to, key) && key !== except) __defProp2(to, key, {
+      get: ((k) => from[k]).bind(null, key),
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+}, "__copyProps");
+var __toESM = /* @__PURE__ */ __name((mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod)), "__toESM");
+var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  __name(_typeof$2, "_typeof$2");
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof()["default"];
+  function toPrimitive$1(t, r) {
+    if ("object" != _typeof$1(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof$1(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  __name(toPrimitive$1, "toPrimitive$1");
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof()["default"];
+  var toPrimitive = require_toPrimitive();
+  function toPropertyKey$1(t) {
+    var i = toPrimitive(t, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
+  }
+  __name(toPropertyKey$1, "toPropertyKey$1");
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey();
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  __name(_defineProperty, "_defineProperty");
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty();
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  __name(ownKeys, "ownKeys");
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+      });
+    }
+    return e;
+  }
+  __name(_objectSpread2, "_objectSpread2");
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+// node_modules/@trpc/server/dist/observable-UMO3vUa_.mjs
+function observable(subscribe) {
+  const self = {
+    subscribe(observer) {
+      let teardownRef = null;
+      let isDone = false;
+      let unsubscribed = false;
+      let teardownImmediately = false;
+      function unsubscribe() {
+        if (teardownRef === null) {
+          teardownImmediately = true;
+          return;
+        }
+        if (unsubscribed) return;
+        unsubscribed = true;
+        if (typeof teardownRef === "function") teardownRef();
+        else if (teardownRef) teardownRef.unsubscribe();
+      }
+      __name(unsubscribe, "unsubscribe");
+      teardownRef = subscribe({
+        next(value) {
+          var _observer$next;
+          if (isDone) return;
+          (_observer$next = observer.next) === null || _observer$next === void 0 || _observer$next.call(observer, value);
+        },
+        error(err) {
+          var _observer$error;
+          if (isDone) return;
+          isDone = true;
+          (_observer$error = observer.error) === null || _observer$error === void 0 || _observer$error.call(observer, err);
+          unsubscribe();
+        },
+        complete() {
+          var _observer$complete;
+          if (isDone) return;
+          isDone = true;
+          (_observer$complete = observer.complete) === null || _observer$complete === void 0 || _observer$complete.call(observer);
+          unsubscribe();
+        }
+      });
+      if (teardownImmediately) unsubscribe();
+      return { unsubscribe };
+    },
+    pipe(...operations) {
+      return operations.reduce(pipeReducer, self);
+    }
+  };
+  return self;
+}
+__name(observable, "observable");
+function pipeReducer(prev, fn) {
+  return fn(prev);
+}
+__name(pipeReducer, "pipeReducer");
+function observableToPromise(observable$1) {
+  const ac = new AbortController();
+  const promise = new Promise((resolve, reject) => {
+    let isDone = false;
+    function onDone() {
+      if (isDone) return;
+      isDone = true;
+      obs$.unsubscribe();
+    }
+    __name(onDone, "onDone");
+    ac.signal.addEventListener("abort", () => {
+      reject(ac.signal.reason);
+    });
+    const obs$ = observable$1.subscribe({
+      next(data) {
+        isDone = true;
+        resolve(data);
+        onDone();
+      },
+      error(data) {
+        reject(data);
+      },
+      complete() {
+        ac.abort();
+        onDone();
+      }
+    });
+  });
+  return promise;
+}
+__name(observableToPromise, "observableToPromise");
+
+// node_modules/@trpc/server/dist/observable-CUiPknO-.mjs
+function share(_opts) {
+  return (source) => {
+    let refCount = 0;
+    let subscription = null;
+    const observers = [];
+    function startIfNeeded() {
+      if (subscription) return;
+      subscription = source.subscribe({
+        next(value) {
+          for (const observer of observers) {
+            var _observer$next;
+            (_observer$next = observer.next) === null || _observer$next === void 0 || _observer$next.call(observer, value);
+          }
+        },
+        error(error) {
+          for (const observer of observers) {
+            var _observer$error;
+            (_observer$error = observer.error) === null || _observer$error === void 0 || _observer$error.call(observer, error);
+          }
+        },
+        complete() {
+          for (const observer of observers) {
+            var _observer$complete;
+            (_observer$complete = observer.complete) === null || _observer$complete === void 0 || _observer$complete.call(observer);
+          }
+        }
+      });
+    }
+    __name(startIfNeeded, "startIfNeeded");
+    function resetIfNeeded() {
+      if (refCount === 0 && subscription) {
+        const _sub = subscription;
+        subscription = null;
+        _sub.unsubscribe();
+      }
+    }
+    __name(resetIfNeeded, "resetIfNeeded");
+    return observable((subscriber) => {
+      refCount++;
+      observers.push(subscriber);
+      startIfNeeded();
+      return { unsubscribe() {
+        refCount--;
+        resetIfNeeded();
+        const index = observers.findIndex((v) => v === subscriber);
+        if (index > -1) observers.splice(index, 1);
+      } };
+    });
+  };
+}
+__name(share, "share");
+function behaviorSubject(initialValue) {
+  let value = initialValue;
+  const observerList = [];
+  const addObserver = /* @__PURE__ */ __name((observer) => {
+    if (value !== void 0) observer.next(value);
+    observerList.push(observer);
+  }, "addObserver");
+  const removeObserver = /* @__PURE__ */ __name((observer) => {
+    observerList.splice(observerList.indexOf(observer), 1);
+  }, "removeObserver");
+  const obs = observable((observer) => {
+    addObserver(observer);
+    return () => {
+      removeObserver(observer);
+    };
+  });
+  obs.next = (nextValue) => {
+    if (value === nextValue) return;
+    value = nextValue;
+    for (const observer of observerList) observer.next(nextValue);
+  };
+  obs.get = () => value;
+  return obs;
+}
+__name(behaviorSubject, "behaviorSubject");
+
+// node_modules/@trpc/client/dist/splitLink-B7Cuf2c_.mjs
+function createChain(opts) {
+  return observable((observer) => {
+    function execute(index = 0, op = opts.op) {
+      const next = opts.links[index];
+      if (!next) throw new Error("No more links to execute - did you forget to add an ending link?");
+      const subscription = next({
+        op,
+        next(nextOp) {
+          const nextObserver = execute(index + 1, nextOp);
+          return nextObserver;
+        }
+      });
+      return subscription;
+    }
+    __name(execute, "execute");
+    const obs$ = execute();
+    return obs$.subscribe(observer);
+  });
+}
+__name(createChain, "createChain");
+
+// node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+__name(isObject, "isObject");
+function emptyObject() {
+  return /* @__PURE__ */ Object.create(null);
+}
+__name(emptyObject, "emptyObject");
+var run = /* @__PURE__ */ __name((fn) => fn(), "run");
+function sleep(ms = 0) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+__name(sleep, "sleep");
+var TRPC_ERROR_CODES_BY_KEY = {
+  PARSE_ERROR: -32700,
+  BAD_REQUEST: -32600,
+  INTERNAL_SERVER_ERROR: -32603,
+  NOT_IMPLEMENTED: -32603,
+  BAD_GATEWAY: -32603,
+  SERVICE_UNAVAILABLE: -32603,
+  GATEWAY_TIMEOUT: -32603,
+  UNAUTHORIZED: -32001,
+  PAYMENT_REQUIRED: -32002,
+  FORBIDDEN: -32003,
+  NOT_FOUND: -32004,
+  METHOD_NOT_SUPPORTED: -32005,
+  TIMEOUT: -32008,
+  CONFLICT: -32009,
+  PRECONDITION_FAILED: -32012,
+  PAYLOAD_TOO_LARGE: -32013,
+  UNSUPPORTED_MEDIA_TYPE: -32015,
+  UNPROCESSABLE_CONTENT: -32022,
+  PRECONDITION_REQUIRED: -32028,
+  TOO_MANY_REQUESTS: -32029,
+  CLIENT_CLOSED_REQUEST: -32099
+};
+var retryableRpcCodes = [
+  TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
+  TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
+  TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
+  TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR
+];
+
+// node_modules/@trpc/server/dist/getErrorShape-vC8mUXJD.mjs
+var __create2 = Object.create;
+var __defProp3 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS2 = /* @__PURE__ */ __name((cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+}, "__commonJS");
+var __copyProps2 = /* @__PURE__ */ __name((to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key; i < n; i++) {
+    key = keys[i];
+    if (!__hasOwnProp2.call(to, key) && key !== except) __defProp3(to, key, {
+      get: ((k) => from[k]).bind(null, key),
+      enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+}, "__copyProps");
+var __toESM2 = /* @__PURE__ */ __name((mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod)), "__toESM");
+var noop = /* @__PURE__ */ __name(() => {
+}, "noop");
+var freezeIfAvailable = /* @__PURE__ */ __name((obj) => {
+  if (Object.freeze) Object.freeze(obj);
+}, "freezeIfAvailable");
+function createInnerProxy(callback, path, memo) {
+  var _memo$cacheKey;
+  const cacheKey = path.join(".");
+  (_memo$cacheKey = memo[cacheKey]) !== null && _memo$cacheKey !== void 0 || (memo[cacheKey] = new Proxy(noop, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") return void 0;
+      return createInnerProxy(callback, [...path, key], memo);
+    },
+    apply(_1, _2, args) {
+      const lastOfPath = path[path.length - 1];
+      let opts = {
+        args,
+        path
+      };
+      if (lastOfPath === "call") opts = {
+        args: args.length >= 2 ? [args[1]] : [],
+        path: path.slice(0, -1)
+      };
+      else if (lastOfPath === "apply") opts = {
+        args: args.length >= 2 ? args[1] : [],
+        path: path.slice(0, -1)
+      };
+      freezeIfAvailable(opts.args);
+      freezeIfAvailable(opts.path);
+      return callback(opts);
+    }
+  }));
+  return memo[cacheKey];
+}
+__name(createInnerProxy, "createInnerProxy");
+var createRecursiveProxy = /* @__PURE__ */ __name((callback) => createInnerProxy(callback, [], emptyObject()), "createRecursiveProxy");
+var createFlatProxy = /* @__PURE__ */ __name((callback) => {
+  return new Proxy(noop, { get(_obj, name) {
+    if (name === "then") return void 0;
+    return callback(name);
+  } });
+}, "createFlatProxy");
+var require_typeof2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  __name(_typeof$2, "_typeof$2");
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof2()["default"];
+  function toPrimitive$1(t, r) {
+    if ("object" != _typeof$1(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof$1(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  __name(toPrimitive$1, "toPrimitive$1");
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof2()["default"];
+  var toPrimitive = require_toPrimitive2();
+  function toPropertyKey$1(t) {
+    var i = toPrimitive(t, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
+  }
+  __name(toPropertyKey$1, "toPropertyKey$1");
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey2();
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  __name(_defineProperty, "_defineProperty");
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread22 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty2();
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  __name(ownKeys, "ownKeys");
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+      });
+    }
+    return e;
+  }
+  __name(_objectSpread2, "_objectSpread2");
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_objectSpread2 = __toESM2(require_objectSpread22(), 1);
+
+// node_modules/@trpc/server/dist/tracked-DiE3uR1B.mjs
+var import_defineProperty = __toESM2(require_defineProperty2(), 1);
+var import_objectSpread2$1 = __toESM2(require_objectSpread22(), 1);
+function transformResultInner(response, transformer) {
+  if ("error" in response) {
+    const error = transformer.deserialize(response.error);
+    return {
+      ok: false,
+      error: (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, response), {}, { error })
+    };
+  }
+  const result = (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, response.result), (!response.result.type || response.result.type === "data") && {
+    type: "data",
+    data: transformer.deserialize(response.result.data)
+  });
+  return {
+    ok: true,
+    result
+  };
+}
+__name(transformResultInner, "transformResultInner");
+var TransformResultError = class extends Error {
+  static {
+    __name(this, "TransformResultError");
+  }
+  constructor() {
+    super("Unable to transform response from server");
+  }
+};
+function transformResult(response, transformer) {
+  let result;
+  try {
+    result = transformResultInner(response, transformer);
+  } catch (_unused) {
+    throw new TransformResultError();
+  }
+  if (!result.ok && (!isObject(result.error.error) || typeof result.error.error["code"] !== "number")) throw new TransformResultError();
+  if (result.ok && !isObject(result.result)) throw new TransformResultError();
+  return result;
+}
+__name(transformResult, "transformResult");
+var import_objectSpread22 = __toESM2(require_objectSpread22(), 1);
+
+// node_modules/@trpc/client/dist/TRPCClientError-apv8gw59.mjs
+var import_defineProperty2 = __toESM(require_defineProperty(), 1);
+var import_objectSpread23 = __toESM(require_objectSpread2(), 1);
+function isTRPCClientError(cause) {
+  return cause instanceof TRPCClientError;
+}
+__name(isTRPCClientError, "isTRPCClientError");
+function isTRPCErrorResponse(obj) {
+  return isObject(obj) && isObject(obj["error"]) && typeof obj["error"]["code"] === "number" && typeof obj["error"]["message"] === "string";
+}
+__name(isTRPCErrorResponse, "isTRPCErrorResponse");
+function getMessageFromUnknownError(err, fallback) {
+  if (typeof err === "string") return err;
+  if (isObject(err) && typeof err["message"] === "string") return err["message"];
+  return fallback;
+}
+__name(getMessageFromUnknownError, "getMessageFromUnknownError");
+var TRPCClientError = class TRPCClientError2 extends Error {
+  static {
+    __name(this, "TRPCClientError");
+  }
+  constructor(message, opts) {
+    var _opts$result, _opts$result2;
+    const cause = opts === null || opts === void 0 ? void 0 : opts.cause;
+    super(message, { cause });
+    (0, import_defineProperty2.default)(this, "cause", void 0);
+    (0, import_defineProperty2.default)(this, "shape", void 0);
+    (0, import_defineProperty2.default)(this, "data", void 0);
+    (0, import_defineProperty2.default)(this, "meta", void 0);
+    this.meta = opts === null || opts === void 0 ? void 0 : opts.meta;
+    this.cause = cause;
+    this.shape = opts === null || opts === void 0 || (_opts$result = opts.result) === null || _opts$result === void 0 ? void 0 : _opts$result.error;
+    this.data = opts === null || opts === void 0 || (_opts$result2 = opts.result) === null || _opts$result2 === void 0 ? void 0 : _opts$result2.error.data;
+    this.name = "TRPCClientError";
+    Object.setPrototypeOf(this, TRPCClientError2.prototype);
+  }
+  static from(_cause, opts = {}) {
+    const cause = _cause;
+    if (isTRPCClientError(cause)) {
+      if (opts.meta) cause.meta = (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, cause.meta), opts.meta);
+      return cause;
+    }
+    if (isTRPCErrorResponse(cause)) return new TRPCClientError2(cause.error.message, (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, {
+      result: cause,
+      cause: opts.cause
+    }));
+    return new TRPCClientError2(getMessageFromUnknownError(cause, "Unknown error"), (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, { cause }));
+  }
+};
+
+// node_modules/@trpc/client/dist/unstable-internals-Bg7n9BBj.mjs
+function getTransformer(transformer) {
+  const _transformer = transformer;
+  if (!_transformer) return {
+    input: {
+      serialize: /* @__PURE__ */ __name((data) => data, "serialize"),
+      deserialize: /* @__PURE__ */ __name((data) => data, "deserialize")
+    },
+    output: {
+      serialize: /* @__PURE__ */ __name((data) => data, "serialize"),
+      deserialize: /* @__PURE__ */ __name((data) => data, "deserialize")
+    }
+  };
+  if ("input" in _transformer) return _transformer;
+  return {
+    input: _transformer,
+    output: _transformer
+  };
+}
+__name(getTransformer, "getTransformer");
+
+// node_modules/@trpc/client/dist/httpUtils-BNq9QC3d.mjs
+var isFunction2 = /* @__PURE__ */ __name((fn) => typeof fn === "function", "isFunction");
+function getFetch(customFetchImpl) {
+  if (customFetchImpl) return customFetchImpl;
+  if (typeof window !== "undefined" && isFunction2(window.fetch)) return window.fetch;
+  if (typeof globalThis !== "undefined" && isFunction2(globalThis.fetch)) return globalThis.fetch;
+  throw new Error("No fetch implementation found");
+}
+__name(getFetch, "getFetch");
+var import_objectSpread24 = __toESM(require_objectSpread2());
+function resolveHTTPLinkOptions(opts) {
+  return {
+    url: opts.url.toString(),
+    fetch: opts.fetch,
+    transformer: getTransformer(opts.transformer),
+    methodOverride: opts.methodOverride
+  };
+}
+__name(resolveHTTPLinkOptions, "resolveHTTPLinkOptions");
+function arrayToDict(array) {
+  const dict = {};
+  for (let index = 0; index < array.length; index++) {
+    const element = array[index];
+    dict[index] = element;
+  }
+  return dict;
+}
+__name(arrayToDict, "arrayToDict");
+var METHOD = {
+  query: "GET",
+  mutation: "POST",
+  subscription: "PATCH"
+};
+function getInput(opts) {
+  return "input" in opts ? opts.transformer.input.serialize(opts.input) : arrayToDict(opts.inputs.map((_input) => opts.transformer.input.serialize(_input)));
+}
+__name(getInput, "getInput");
+var getUrl = /* @__PURE__ */ __name((opts) => {
+  const parts = opts.url.split("?");
+  const base = parts[0].replace(/\/$/, "");
+  let url = base + "/" + opts.path;
+  const queryParts = [];
+  if (parts[1]) queryParts.push(parts[1]);
+  if ("inputs" in opts) queryParts.push("batch=1");
+  if (opts.type === "query" || opts.type === "subscription") {
+    const input = getInput(opts);
+    if (input !== void 0 && opts.methodOverride !== "POST") queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
+  }
+  if (queryParts.length) url += "?" + queryParts.join("&");
+  return url;
+}, "getUrl");
+var getBody = /* @__PURE__ */ __name((opts) => {
+  if (opts.type === "query" && opts.methodOverride !== "POST") return void 0;
+  const input = getInput(opts);
+  return input !== void 0 ? JSON.stringify(input) : void 0;
+}, "getBody");
+var jsonHttpRequester = /* @__PURE__ */ __name((opts) => {
+  return httpRequest((0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts), {}, {
+    contentTypeHeader: "application/json",
+    getUrl,
+    getBody
+  }));
+}, "jsonHttpRequester");
+var AbortError = class extends Error {
+  static {
+    __name(this, "AbortError");
+  }
+  constructor() {
+    const name = "AbortError";
+    super(name);
+    this.name = name;
+    this.message = name;
+  }
+};
+var throwIfAborted = /* @__PURE__ */ __name((signal) => {
+  var _signal$throwIfAborte;
+  if (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) return;
+  (_signal$throwIfAborte = signal.throwIfAborted) === null || _signal$throwIfAborte === void 0 || _signal$throwIfAborte.call(signal);
+  if (typeof DOMException !== "undefined") throw new DOMException("AbortError", "AbortError");
+  throw new AbortError();
+}, "throwIfAborted");
+async function fetchHTTPResponse(opts) {
+  var _opts$methodOverride, _opts$trpcAcceptHeade;
+  throwIfAborted(opts.signal);
+  const url = opts.getUrl(opts);
+  const body = opts.getBody(opts);
+  const method = (_opts$methodOverride = opts.methodOverride) !== null && _opts$methodOverride !== void 0 ? _opts$methodOverride : METHOD[opts.type];
+  const resolvedHeaders = await (async () => {
+    const heads = await opts.headers();
+    if (Symbol.iterator in heads) return Object.fromEntries(heads);
+    return heads;
+  })();
+  const headers = (0, import_objectSpread24.default)((0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts.contentTypeHeader && method !== "GET" ? { "content-type": opts.contentTypeHeader } : {}), opts.trpcAcceptHeader ? { [(_opts$trpcAcceptHeade = opts.trpcAcceptHeaderKey) !== null && _opts$trpcAcceptHeade !== void 0 ? _opts$trpcAcceptHeade : "trpc-accept"]: opts.trpcAcceptHeader } : void 0), resolvedHeaders);
+  return getFetch(opts.fetch)(url, {
+    method,
+    signal: opts.signal,
+    body,
+    headers
+  });
+}
+__name(fetchHTTPResponse, "fetchHTTPResponse");
+async function httpRequest(opts) {
+  const meta = {};
+  const res = await fetchHTTPResponse(opts);
+  meta.response = res;
+  const json = await res.json();
+  meta.responseJSON = json;
+  return {
+    json,
+    meta
+  };
+}
+__name(httpRequest, "httpRequest");
+
+// node_modules/@trpc/client/dist/httpLink-oiU8eqFi.mjs
+function isOctetType(input) {
+  return input instanceof Uint8Array || input instanceof Blob;
+}
+__name(isOctetType, "isOctetType");
+function isFormData(input) {
+  return input instanceof FormData;
+}
+__name(isFormData, "isFormData");
+var import_objectSpread25 = __toESM(require_objectSpread2(), 1);
+var universalRequester = /* @__PURE__ */ __name((opts) => {
+  if ("input" in opts) {
+    const { input } = opts;
+    if (isFormData(input)) {
+      if (opts.type !== "mutation" && opts.methodOverride !== "POST") throw new Error("FormData is only supported for mutations");
+      return httpRequest((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, opts), {}, {
+        contentTypeHeader: void 0,
+        getUrl,
+        getBody: /* @__PURE__ */ __name(() => input, "getBody")
+      }));
+    }
+    if (isOctetType(input)) {
+      if (opts.type !== "mutation" && opts.methodOverride !== "POST") throw new Error("Octet type input is only supported for mutations");
+      return httpRequest((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, opts), {}, {
+        contentTypeHeader: "application/octet-stream",
+        getUrl,
+        getBody: /* @__PURE__ */ __name(() => input, "getBody")
+      }));
+    }
+  }
+  return jsonHttpRequester(opts);
+}, "universalRequester");
+function httpLink(opts) {
+  const resolvedOpts = resolveHTTPLinkOptions(opts);
+  return () => {
+    return (operationOpts) => {
+      const { op } = operationOpts;
+      return observable((observer) => {
+        const { path, input, type } = op;
+        if (type === "subscription") throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+        const request = universalRequester((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, resolvedOpts), {}, {
+          type,
+          path,
+          input,
+          signal: op.signal,
+          headers() {
+            if (!opts.headers) return {};
+            if (typeof opts.headers === "function") return opts.headers({ op });
+            return opts.headers;
+          }
+        }));
+        let meta = void 0;
+        request.then((res) => {
+          meta = res.meta;
+          const transformed = transformResult(res.json, resolvedOpts.transformer.output);
+          if (!transformed.ok) {
+            observer.error(TRPCClientError.from(transformed.error, { meta }));
+            return;
+          }
+          observer.next({
+            context: res.meta,
+            result: transformed.result
+          });
+          observer.complete();
+        }).catch((cause) => {
+          observer.error(TRPCClientError.from(cause, { meta }));
+        });
+        return () => {
+        };
+      });
+    };
+  };
+}
+__name(httpLink, "httpLink");
+
+// node_modules/@trpc/client/dist/httpBatchLink-CaWjh1oW.mjs
+var import_objectSpread26 = __toESM(require_objectSpread2(), 1);
+
+// node_modules/@trpc/client/dist/loggerLink-ineCN1PO.mjs
+var import_objectSpread27 = __toESM(require_objectSpread2(), 1);
+
+// node_modules/@trpc/client/dist/wsLink-DSf4KOdW.mjs
+var jsonEncoder = {
+  encode: /* @__PURE__ */ __name((data) => JSON.stringify(data), "encode"),
+  decode: /* @__PURE__ */ __name((data) => {
+    if (typeof data !== "string") throw new Error("jsonEncoder received binary data. JSON uses text frames. Use a binary encoder for binary data.");
+    return JSON.parse(data);
+  }, "decode")
+};
+var lazyDefaults = {
+  enabled: false,
+  closeMs: 0
+};
+var keepAliveDefaults = {
+  enabled: false,
+  pongTimeoutMs: 1e3,
+  intervalMs: 5e3
+};
+var exponentialBackoff = /* @__PURE__ */ __name((attemptIndex) => {
+  return attemptIndex === 0 ? 0 : Math.min(1e3 * 2 ** attemptIndex, 3e4);
+}, "exponentialBackoff");
+var resultOf = /* @__PURE__ */ __name((value, ...args) => {
+  return typeof value === "function" ? value(...args) : value;
+}, "resultOf");
+var import_defineProperty$3 = __toESM(require_defineProperty(), 1);
+var TRPCWebSocketClosedError = class TRPCWebSocketClosedError2 extends Error {
+  static {
+    __name(this, "TRPCWebSocketClosedError");
+  }
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "TRPCWebSocketClosedError";
+    Object.setPrototypeOf(this, TRPCWebSocketClosedError2.prototype);
+  }
+};
+var ResettableTimeout = class {
+  static {
+    __name(this, "ResettableTimeout");
+  }
+  constructor(onTimeout, timeoutMs) {
+    this.onTimeout = onTimeout;
+    this.timeoutMs = timeoutMs;
+    (0, import_defineProperty$3.default)(this, "timeout", void 0);
+  }
+  /**
+  * Resets the current timeout, restarting it with the same duration.
+  * Does nothing if no timeout is active.
+  */
+  reset() {
+    if (!this.timeout) return;
+    clearTimeout(this.timeout);
+    this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+  }
+  start() {
+    clearTimeout(this.timeout);
+    this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+  }
+  stop() {
+    clearTimeout(this.timeout);
+    this.timeout = void 0;
+  }
+};
+function withResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+__name(withResolvers, "withResolvers");
+async function prepareUrl(urlOptions) {
+  const url = await resultOf(urlOptions.url);
+  if (!urlOptions.connectionParams) return url;
+  const prefix = url.includes("?") ? "&" : "?";
+  const connectionParams = `${prefix}connectionParams=1`;
+  return url + connectionParams;
+}
+__name(prepareUrl, "prepareUrl");
+async function buildConnectionMessage(connectionParams, encoder) {
+  const message = {
+    method: "connectionParams",
+    data: await resultOf(connectionParams)
+  };
+  return encoder.encode(message);
+}
+__name(buildConnectionMessage, "buildConnectionMessage");
+var import_defineProperty$2 = __toESM(require_defineProperty(), 1);
+var RequestManager = class {
+  static {
+    __name(this, "RequestManager");
+  }
+  constructor() {
+    (0, import_defineProperty$2.default)(this, "outgoingRequests", new Array());
+    (0, import_defineProperty$2.default)(this, "pendingRequests", {});
+  }
+  /**
+  * Registers a new request by adding it to the outgoing queue and setting up
+  * callbacks for lifecycle events such as completion or error.
+  *
+  * @param message - The outgoing message to be sent.
+  * @param callbacks - Callback functions to observe the request's state.
+  * @returns A cleanup function to manually remove the request.
+  */
+  register(message, callbacks) {
+    const { promise: end, resolve } = withResolvers();
+    this.outgoingRequests.push({
+      id: String(message.id),
+      message,
+      end,
+      callbacks: {
+        next: callbacks.next,
+        complete: /* @__PURE__ */ __name(() => {
+          callbacks.complete();
+          resolve();
+        }, "complete"),
+        error: /* @__PURE__ */ __name((e) => {
+          callbacks.error(e);
+          resolve();
+        }, "error")
+      }
+    });
+    return () => {
+      this.delete(message.id);
+      callbacks.complete();
+      resolve();
+    };
+  }
+  /**
+  * Deletes a request from both the outgoing and pending collections, if it exists.
+  */
+  delete(messageId) {
+    if (messageId === null) return;
+    this.outgoingRequests = this.outgoingRequests.filter(({ id }) => id !== String(messageId));
+    delete this.pendingRequests[String(messageId)];
+  }
+  /**
+  * Moves all outgoing requests to the pending state and clears the outgoing queue.
+  *
+  * The caller is expected to handle the actual sending of the requests
+  * (e.g., sending them over the network) after this method is called.
+  *
+  * @returns The list of requests that were transitioned to the pending state.
+  */
+  flush() {
+    const requests = this.outgoingRequests;
+    this.outgoingRequests = [];
+    for (const request of requests) this.pendingRequests[request.id] = request;
+    return requests;
+  }
+  /**
+  * Retrieves all currently pending requests, which are in flight awaiting responses
+  * or handling ongoing subscriptions.
+  */
+  getPendingRequests() {
+    return Object.values(this.pendingRequests);
+  }
+  /**
+  * Retrieves a specific pending request by its message ID.
+  */
+  getPendingRequest(messageId) {
+    if (messageId === null) return null;
+    return this.pendingRequests[String(messageId)];
+  }
+  /**
+  * Retrieves all outgoing requests, which are waiting to be sent.
+  */
+  getOutgoingRequests() {
+    return this.outgoingRequests;
+  }
+  /**
+  * Retrieves all requests, both outgoing and pending, with their respective states.
+  *
+  * @returns An array of all requests with their state ("outgoing" or "pending").
+  */
+  getRequests() {
+    return [...this.getOutgoingRequests().map((request) => ({
+      state: "outgoing",
+      message: request.message,
+      end: request.end,
+      callbacks: request.callbacks
+    })), ...this.getPendingRequests().map((request) => ({
+      state: "pending",
+      message: request.message,
+      end: request.end,
+      callbacks: request.callbacks
+    }))];
+  }
+  /**
+  * Checks if there are any pending requests, including ongoing subscriptions.
+  */
+  hasPendingRequests() {
+    return this.getPendingRequests().length > 0;
+  }
+  /**
+  * Checks if there are any pending subscriptions
+  */
+  hasPendingSubscriptions() {
+    return this.getPendingRequests().some((request) => request.message.method === "subscription");
+  }
+  /**
+  * Checks if there are any outgoing requests waiting to be sent.
+  */
+  hasOutgoingRequests() {
+    return this.outgoingRequests.length > 0;
+  }
+};
+var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
+function asyncWsOpen(ws) {
+  const { promise, resolve, reject } = withResolvers();
+  ws.addEventListener("open", () => {
+    ws.removeEventListener("error", reject);
+    resolve();
+  });
+  ws.addEventListener("error", reject);
+  return promise;
+}
+__name(asyncWsOpen, "asyncWsOpen");
+function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
+  let pingTimeout;
+  let pongTimeout;
+  function start() {
+    pingTimeout = setTimeout(() => {
+      ws.send("PING");
+      pongTimeout = setTimeout(() => {
+        ws.close();
+      }, pongTimeoutMs);
+    }, intervalMs);
+  }
+  __name(start, "start");
+  function reset() {
+    clearTimeout(pingTimeout);
+    start();
+  }
+  __name(reset, "reset");
+  function pong() {
+    clearTimeout(pongTimeout);
+    reset();
+  }
+  __name(pong, "pong");
+  ws.addEventListener("open", start);
+  ws.addEventListener("message", ({ data }) => {
+    clearTimeout(pingTimeout);
+    start();
+    if (data === "PONG") pong();
+  });
+  ws.addEventListener("close", () => {
+    clearTimeout(pingTimeout);
+    clearTimeout(pongTimeout);
+  });
+}
+__name(setupPingInterval, "setupPingInterval");
+var WsConnection = class WsConnection2 {
+  static {
+    __name(this, "WsConnection");
+  }
+  constructor(opts) {
+    var _opts$WebSocketPonyfi;
+    (0, import_defineProperty$1.default)(this, "id", ++WsConnection2.connectCount);
+    (0, import_defineProperty$1.default)(this, "WebSocketPonyfill", void 0);
+    (0, import_defineProperty$1.default)(this, "urlOptions", void 0);
+    (0, import_defineProperty$1.default)(this, "keepAliveOpts", void 0);
+    (0, import_defineProperty$1.default)(this, "encoder", void 0);
+    (0, import_defineProperty$1.default)(this, "wsObservable", behaviorSubject(null));
+    (0, import_defineProperty$1.default)(this, "openPromise", null);
+    this.WebSocketPonyfill = (_opts$WebSocketPonyfi = opts.WebSocketPonyfill) !== null && _opts$WebSocketPonyfi !== void 0 ? _opts$WebSocketPonyfi : WebSocket;
+    if (!this.WebSocketPonyfill) throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+    this.urlOptions = opts.urlOptions;
+    this.keepAliveOpts = opts.keepAlive;
+    this.encoder = opts.encoder;
+  }
+  get ws() {
+    return this.wsObservable.get();
+  }
+  set ws(ws) {
+    this.wsObservable.next(ws);
+  }
+  /**
+  * Checks if the WebSocket connection is open and ready to communicate.
+  */
+  isOpen() {
+    return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
+  }
+  /**
+  * Checks if the WebSocket connection is closed or in the process of closing.
+  */
+  isClosed() {
+    return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
+  }
+  async open() {
+    var _this = this;
+    if (_this.openPromise) return _this.openPromise;
+    _this.id = ++WsConnection2.connectCount;
+    const wsPromise = prepareUrl(_this.urlOptions).then((url) => new _this.WebSocketPonyfill(url));
+    _this.openPromise = wsPromise.then(async (ws) => {
+      _this.ws = ws;
+      ws.binaryType = "arraybuffer";
+      ws.addEventListener("message", function({ data }) {
+        if (data === "PING") this.send("PONG");
+      });
+      if (_this.keepAliveOpts.enabled) setupPingInterval(ws, _this.keepAliveOpts);
+      ws.addEventListener("close", () => {
+        if (_this.ws === ws) _this.ws = null;
+      });
+      await asyncWsOpen(ws);
+      if (_this.urlOptions.connectionParams) ws.send(await buildConnectionMessage(_this.urlOptions.connectionParams, _this.encoder));
+    });
+    try {
+      await _this.openPromise;
+    } finally {
+      _this.openPromise = null;
+    }
+  }
+  /**
+  * Closes the WebSocket connection gracefully.
+  * Waits for any ongoing open operation to complete before closing.
+  */
+  async close() {
+    var _this2 = this;
+    try {
+      await _this2.openPromise;
+    } finally {
+      var _this$ws;
+      (_this$ws = _this2.ws) === null || _this$ws === void 0 || _this$ws.close();
+    }
+  }
+};
+(0, import_defineProperty$1.default)(WsConnection, "connectCount", 0);
+function backwardCompatibility(connection) {
+  if (connection.isOpen()) return {
+    id: connection.id,
+    state: "open",
+    ws: connection.ws
+  };
+  if (connection.isClosed()) return {
+    id: connection.id,
+    state: "closed",
+    ws: connection.ws
+  };
+  if (!connection.ws) return null;
+  return {
+    id: connection.id,
+    state: "connecting",
+    ws: connection.ws
+  };
+}
+__name(backwardCompatibility, "backwardCompatibility");
+var import_defineProperty3 = __toESM(require_defineProperty(), 1);
+var import_objectSpread28 = __toESM(require_objectSpread2(), 1);
+var WsClient = class {
+  static {
+    __name(this, "WsClient");
+  }
+  constructor(opts) {
+    var _opts$experimental_en, _opts$retryDelayMs;
+    (0, import_defineProperty3.default)(this, "connectionState", void 0);
+    (0, import_defineProperty3.default)(this, "allowReconnect", false);
+    (0, import_defineProperty3.default)(this, "requestManager", new RequestManager());
+    (0, import_defineProperty3.default)(this, "activeConnection", void 0);
+    (0, import_defineProperty3.default)(this, "reconnectRetryDelay", void 0);
+    (0, import_defineProperty3.default)(this, "inactivityTimeout", void 0);
+    (0, import_defineProperty3.default)(this, "callbacks", void 0);
+    (0, import_defineProperty3.default)(this, "lazyMode", void 0);
+    (0, import_defineProperty3.default)(this, "encoder", void 0);
+    (0, import_defineProperty3.default)(this, "reconnecting", null);
+    this.encoder = (_opts$experimental_en = opts.experimental_encoder) !== null && _opts$experimental_en !== void 0 ? _opts$experimental_en : jsonEncoder;
+    this.callbacks = {
+      onOpen: opts.onOpen,
+      onClose: opts.onClose,
+      onError: opts.onError
+    };
+    const lazyOptions = (0, import_objectSpread28.default)((0, import_objectSpread28.default)({}, lazyDefaults), opts.lazy);
+    this.inactivityTimeout = new ResettableTimeout(() => {
+      if (this.requestManager.hasOutgoingRequests() || this.requestManager.hasPendingRequests()) {
+        this.inactivityTimeout.reset();
+        return;
+      }
+      this.close().catch(() => null);
+    }, lazyOptions.closeMs);
+    this.activeConnection = new WsConnection({
+      WebSocketPonyfill: opts.WebSocket,
+      urlOptions: opts,
+      keepAlive: (0, import_objectSpread28.default)((0, import_objectSpread28.default)({}, keepAliveDefaults), opts.keepAlive),
+      encoder: this.encoder
+    });
+    this.activeConnection.wsObservable.subscribe({ next: /* @__PURE__ */ __name((ws) => {
+      if (!ws) return;
+      this.setupWebSocketListeners(ws);
+    }, "next") });
+    this.reconnectRetryDelay = (_opts$retryDelayMs = opts.retryDelayMs) !== null && _opts$retryDelayMs !== void 0 ? _opts$retryDelayMs : exponentialBackoff;
+    this.lazyMode = lazyOptions.enabled;
+    this.connectionState = behaviorSubject({
+      type: "state",
+      state: lazyOptions.enabled ? "idle" : "connecting",
+      error: null
+    });
+    if (!this.lazyMode) this.open().catch(() => null);
+  }
+  /**
+  * Opens the WebSocket connection. Handles reconnection attempts and updates
+  * the connection state accordingly.
+  */
+  async open() {
+    var _this = this;
+    _this.allowReconnect = true;
+    if (_this.connectionState.get().state === "idle") _this.connectionState.next({
+      type: "state",
+      state: "connecting",
+      error: null
+    });
+    try {
+      await _this.activeConnection.open();
+    } catch (error) {
+      _this.reconnect(new TRPCWebSocketClosedError({
+        message: "Initialization error",
+        cause: error
+      }));
+      return _this.reconnecting;
+    }
+  }
+  /**
+  * Closes the WebSocket connection and stops managing requests.
+  * Ensures all outgoing and pending requests are properly finalized.
+  */
+  async close() {
+    var _this2 = this;
+    _this2.allowReconnect = false;
+    _this2.inactivityTimeout.stop();
+    const requestsToAwait = [];
+    for (const request of _this2.requestManager.getRequests()) if (request.message.method === "subscription") request.callbacks.complete();
+    else if (request.state === "outgoing") request.callbacks.error(TRPCClientError.from(new TRPCWebSocketClosedError({ message: "Closed before connection was established" })));
+    else requestsToAwait.push(request.end);
+    await Promise.all(requestsToAwait).catch(() => null);
+    await _this2.activeConnection.close().catch(() => null);
+    _this2.connectionState.next({
+      type: "state",
+      state: "idle",
+      error: null
+    });
+  }
+  /**
+  * Method to request the server.
+  * Handles data transformation, batching of requests, and subscription lifecycle.
+  *
+  * @param op - The operation details including id, type, path, input and signal
+  * @param transformer - Data transformer for serializing requests and deserializing responses
+  * @param lastEventId - Optional ID of the last received event for subscriptions
+  *
+  * @returns An observable that emits operation results and handles cleanup
+  */
+  request({ op: { id, type, path, input, signal }, transformer, lastEventId }) {
+    return observable((observer) => {
+      const abort = this.batchSend({
+        id,
+        method: type,
+        params: {
+          input: transformer.input.serialize(input),
+          path,
+          lastEventId
+        }
+      }, (0, import_objectSpread28.default)((0, import_objectSpread28.default)({}, observer), {}, { next(event) {
+        const transformed = transformResult(event, transformer.output);
+        if (!transformed.ok) {
+          observer.error(TRPCClientError.from(transformed.error));
+          return;
+        }
+        observer.next({ result: transformed.result });
+      } }));
+      return () => {
+        abort();
+        if (type === "subscription" && this.activeConnection.isOpen()) this.send({
+          id,
+          method: "subscription.stop"
+        });
+        signal === null || signal === void 0 || signal.removeEventListener("abort", abort);
+      };
+    });
+  }
+  get connection() {
+    return backwardCompatibility(this.activeConnection);
+  }
+  reconnect(closedError) {
+    var _this3 = this;
+    this.connectionState.next({
+      type: "state",
+      state: "connecting",
+      error: TRPCClientError.from(closedError)
+    });
+    if (this.reconnecting) return;
+    const tryReconnect = /* @__PURE__ */ __name(async (attemptIndex) => {
+      try {
+        await sleep(_this3.reconnectRetryDelay(attemptIndex));
+        if (_this3.allowReconnect) {
+          await _this3.activeConnection.close();
+          await _this3.activeConnection.open();
+          if (_this3.requestManager.hasPendingRequests()) _this3.send(_this3.requestManager.getPendingRequests().map(({ message }) => message));
+        }
+        _this3.reconnecting = null;
+      } catch (_unused) {
+        await tryReconnect(attemptIndex + 1);
+      }
+    }, "tryReconnect");
+    this.reconnecting = tryReconnect(0);
+  }
+  setupWebSocketListeners(ws) {
+    var _this4 = this;
+    const handleCloseOrError = /* @__PURE__ */ __name((cause) => {
+      const reqs = this.requestManager.getPendingRequests();
+      for (const { message, callbacks } of reqs) {
+        if (message.method === "subscription") continue;
+        callbacks.error(TRPCClientError.from(cause !== null && cause !== void 0 ? cause : new TRPCWebSocketClosedError({
+          message: "WebSocket closed",
+          cause
+        })));
+        this.requestManager.delete(message.id);
+      }
+    }, "handleCloseOrError");
+    ws.addEventListener("open", () => {
+      run(async () => {
+        var _this$callbacks$onOpe, _this$callbacks;
+        if (_this4.lazyMode) _this4.inactivityTimeout.start();
+        (_this$callbacks$onOpe = (_this$callbacks = _this4.callbacks).onOpen) === null || _this$callbacks$onOpe === void 0 || _this$callbacks$onOpe.call(_this$callbacks);
+        _this4.connectionState.next({
+          type: "state",
+          state: "pending",
+          error: null
+        });
+      }).catch((error) => {
+        ws.close(3e3);
+        handleCloseOrError(error);
+      });
+    });
+    ws.addEventListener("message", ({ data }) => {
+      this.inactivityTimeout.reset();
+      if (["PING", "PONG"].includes(data)) return;
+      const incomingMessage = this.encoder.decode(data);
+      if ("method" in incomingMessage) {
+        this.handleIncomingRequest(incomingMessage);
+        return;
+      }
+      this.handleResponseMessage(incomingMessage);
+    });
+    ws.addEventListener("close", (event) => {
+      var _this$callbacks$onClo, _this$callbacks2;
+      handleCloseOrError(event);
+      (_this$callbacks$onClo = (_this$callbacks2 = this.callbacks).onClose) === null || _this$callbacks$onClo === void 0 || _this$callbacks$onClo.call(_this$callbacks2, event);
+      if (!this.lazyMode || this.requestManager.hasPendingSubscriptions()) this.reconnect(new TRPCWebSocketClosedError({
+        message: "WebSocket closed",
+        cause: event
+      }));
+    });
+    ws.addEventListener("error", (event) => {
+      var _this$callbacks$onErr, _this$callbacks3;
+      handleCloseOrError(event);
+      (_this$callbacks$onErr = (_this$callbacks3 = this.callbacks).onError) === null || _this$callbacks$onErr === void 0 || _this$callbacks$onErr.call(_this$callbacks3, event);
+      this.reconnect(new TRPCWebSocketClosedError({
+        message: "WebSocket closed",
+        cause: event
+      }));
+    });
+  }
+  handleResponseMessage(message) {
+    const request = this.requestManager.getPendingRequest(message.id);
+    if (!request) return;
+    request.callbacks.next(message);
+    let completed = true;
+    if ("result" in message && request.message.method === "subscription") {
+      if (message.result.type === "data") request.message.params.lastEventId = message.result.id;
+      if (message.result.type !== "stopped") completed = false;
+    }
+    if (completed) {
+      request.callbacks.complete();
+      this.requestManager.delete(message.id);
+    }
+  }
+  handleIncomingRequest(message) {
+    if (message.method === "reconnect") this.reconnect(new TRPCWebSocketClosedError({ message: "Server requested reconnect" }));
+  }
+  /**
+  * Sends a message or batch of messages directly to the server.
+  */
+  send(messageOrMessages) {
+    if (!this.activeConnection.isOpen()) throw new Error("Active connection is not open");
+    const messages = messageOrMessages instanceof Array ? messageOrMessages : [messageOrMessages];
+    this.activeConnection.ws.send(this.encoder.encode(messages.length === 1 ? messages[0] : messages));
+  }
+  /**
+  * Groups requests for batch sending.
+  *
+  * @returns A function to abort the batched request.
+  */
+  batchSend(message, callbacks) {
+    var _this5 = this;
+    this.inactivityTimeout.reset();
+    run(async () => {
+      if (!_this5.activeConnection.isOpen()) await _this5.open();
+      await sleep(0);
+      if (!_this5.requestManager.hasOutgoingRequests()) return;
+      _this5.send(_this5.requestManager.flush().map(({ message: message$1 }) => message$1));
+    }).catch((err) => {
+      this.requestManager.delete(message.id);
+      callbacks.error(TRPCClientError.from(err));
+    });
+    return this.requestManager.register(message, callbacks);
+  }
+};
+function createWSClient(opts) {
+  return new WsClient(opts);
+}
+__name(createWSClient, "createWSClient");
+function wsLink(opts) {
+  const { client } = opts;
+  const transformer = getTransformer(opts.transformer);
+  return () => {
+    return ({ op }) => {
+      return observable((observer) => {
+        const connStateSubscription = op.type === "subscription" ? client.connectionState.subscribe({ next(result) {
+          observer.next({
+            result,
+            context: op.context
+          });
+        } }) : null;
+        const requestSubscription = client.request({
+          op,
+          transformer
+        }).subscribe(observer);
+        return () => {
+          requestSubscription.unsubscribe();
+          connStateSubscription === null || connStateSubscription === void 0 || connStateSubscription.unsubscribe();
+        };
+      });
+    };
+  };
+}
+__name(wsLink, "wsLink");
+
+// node_modules/@trpc/client/dist/index.mjs
+var import_defineProperty4 = __toESM(require_defineProperty(), 1);
+var import_objectSpread2$4 = __toESM(require_objectSpread2(), 1);
+var TRPCUntypedClient = class {
+  static {
+    __name(this, "TRPCUntypedClient");
+  }
+  constructor(opts) {
+    (0, import_defineProperty4.default)(this, "links", void 0);
+    (0, import_defineProperty4.default)(this, "runtime", void 0);
+    (0, import_defineProperty4.default)(this, "requestId", void 0);
+    this.requestId = 0;
+    this.runtime = {};
+    this.links = opts.links.map((link) => link(this.runtime));
+  }
+  $request(opts) {
+    var _opts$context;
+    const chain$ = createChain({
+      links: this.links,
+      op: (0, import_objectSpread2$4.default)((0, import_objectSpread2$4.default)({}, opts), {}, {
+        context: (_opts$context = opts.context) !== null && _opts$context !== void 0 ? _opts$context : {},
+        id: ++this.requestId
+      })
+    });
+    return chain$.pipe(share());
+  }
+  async requestAsPromise(opts) {
+    var _this = this;
+    try {
+      const req$ = _this.$request(opts);
+      const envelope = await observableToPromise(req$);
+      const data = envelope.result.data;
+      return data;
+    } catch (err) {
+      throw TRPCClientError.from(err);
+    }
+  }
+  query(path, input, opts) {
+    return this.requestAsPromise({
+      type: "query",
+      path,
+      input,
+      context: opts === null || opts === void 0 ? void 0 : opts.context,
+      signal: opts === null || opts === void 0 ? void 0 : opts.signal
+    });
+  }
+  mutation(path, input, opts) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path,
+      input,
+      context: opts === null || opts === void 0 ? void 0 : opts.context,
+      signal: opts === null || opts === void 0 ? void 0 : opts.signal
+    });
+  }
+  subscription(path, input, opts) {
+    const observable$ = this.$request({
+      type: "subscription",
+      path,
+      input,
+      context: opts.context,
+      signal: opts.signal
+    });
+    return observable$.subscribe({
+      next(envelope) {
+        switch (envelope.result.type) {
+          case "state": {
+            var _opts$onConnectionSta;
+            (_opts$onConnectionSta = opts.onConnectionStateChange) === null || _opts$onConnectionSta === void 0 || _opts$onConnectionSta.call(opts, envelope.result);
+            break;
+          }
+          case "started": {
+            var _opts$onStarted;
+            (_opts$onStarted = opts.onStarted) === null || _opts$onStarted === void 0 || _opts$onStarted.call(opts, { context: envelope.context });
+            break;
+          }
+          case "stopped": {
+            var _opts$onStopped;
+            (_opts$onStopped = opts.onStopped) === null || _opts$onStopped === void 0 || _opts$onStopped.call(opts);
+            break;
+          }
+          case "data":
+          case void 0: {
+            var _opts$onData;
+            (_opts$onData = opts.onData) === null || _opts$onData === void 0 || _opts$onData.call(opts, envelope.result.data);
+            break;
+          }
+        }
+      },
+      error(err) {
+        var _opts$onError;
+        (_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, err);
+      },
+      complete() {
+        var _opts$onComplete;
+        (_opts$onComplete = opts.onComplete) === null || _opts$onComplete === void 0 || _opts$onComplete.call(opts);
+      }
+    });
+  }
+};
+var untypedClientSymbol = /* @__PURE__ */ Symbol.for("trpc_untypedClient");
+var clientCallTypeMap = {
+  query: "query",
+  mutate: "mutation",
+  subscribe: "subscription"
+};
+var clientCallTypeToProcedureType = /* @__PURE__ */ __name((clientCallType) => {
+  return clientCallTypeMap[clientCallType];
+}, "clientCallTypeToProcedureType");
+function createTRPCClientProxy(client) {
+  const proxy = createRecursiveProxy(({ path, args }) => {
+    const pathCopy = [...path];
+    const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
+    const fullPath = pathCopy.join(".");
+    return client[procedureType](fullPath, ...args);
+  });
+  return createFlatProxy((key) => {
+    if (key === untypedClientSymbol) return client;
+    return proxy[key];
+  });
+}
+__name(createTRPCClientProxy, "createTRPCClientProxy");
+function createTRPCClient(opts) {
+  const client = new TRPCUntypedClient(opts);
+  const proxy = createTRPCClientProxy(client);
+  return proxy;
+}
+__name(createTRPCClient, "createTRPCClient");
+var import_objectSpread2$3 = __toESM(require_objectSpread2(), 1);
+var import_objectSpread2$2 = __toESM(require_objectSpread2(), 1);
+var require_asyncIterator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(exports, module) {
+  function _asyncIterator$1(r) {
+    var n, t, o, e = 2;
+    for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--; ) {
+      if (t && null != (n = r[t])) return n.call(r);
+      if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r));
+      t = "@@asyncIterator", o = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  __name(_asyncIterator$1, "_asyncIterator$1");
+  function AsyncFromSyncIterator(r) {
+    function AsyncFromSyncIteratorContinuation(r$1) {
+      if (Object(r$1) !== r$1) return Promise.reject(new TypeError(r$1 + " is not an object."));
+      var n = r$1.done;
+      return Promise.resolve(r$1.value).then(function(r$2) {
+        return {
+          value: r$2,
+          done: n
+        };
+      });
+    }
+    __name(AsyncFromSyncIteratorContinuation, "AsyncFromSyncIteratorContinuation");
+    return AsyncFromSyncIterator = /* @__PURE__ */ __name(function AsyncFromSyncIterator$1(r$1) {
+      this.s = r$1, this.n = r$1.next;
+    }, "AsyncFromSyncIterator$1"), AsyncFromSyncIterator.prototype = {
+      s: null,
+      n: null,
+      next: /* @__PURE__ */ __name(function next() {
+        return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+      }, "next"),
+      "return": /* @__PURE__ */ __name(function _return(r$1) {
+        var n = this.s["return"];
+        return void 0 === n ? Promise.resolve({
+          value: r$1,
+          done: true
+        }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      }, "_return"),
+      "throw": /* @__PURE__ */ __name(function _throw(r$1) {
+        var n = this.s["return"];
+        return void 0 === n ? Promise.reject(r$1) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      }, "_throw")
+    }, new AsyncFromSyncIterator(r);
+  }
+  __name(AsyncFromSyncIterator, "AsyncFromSyncIterator");
+  module.exports = _asyncIterator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_asyncIterator = __toESM(require_asyncIterator(), 1);
+var import_objectSpread2$12 = __toESM(require_objectSpread2(), 1);
+var require_usingCtx = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+  function _usingCtx() {
+    var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
+      var n$1 = Error();
+      return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+    }, e = {}, n = [];
+    function using(r$1, e$1) {
+      if (null != e$1) {
+        if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+        if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+        if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+        t && (o = /* @__PURE__ */ __name(function o$1() {
+          try {
+            t.call(e$1);
+          } catch (r$2) {
+            return Promise.reject(r$2);
+          }
+        }, "o$1")), n.push({
+          v: e$1,
+          d: o,
+          a: r$1
+        });
+      } else r$1 && n.push({
+        d: e$1,
+        a: r$1
+      });
+      return e$1;
+    }
+    __name(using, "using");
+    return {
+      e,
+      u: using.bind(null, false),
+      a: using.bind(null, true),
+      d: /* @__PURE__ */ __name(function d() {
+        var o, t = this.e, s = 0;
+        function next() {
+          for (; o = n.pop(); ) try {
+            if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+            if (o.d) {
+              var r$1 = o.d.call(o.v);
+              if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+            } else s |= 1;
+          } catch (r$2) {
+            return err(r$2);
+          }
+          if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+          if (t !== e) throw t;
+        }
+        __name(next, "next");
+        function err(n$1) {
+          return t = t !== e ? new r(n$1, t) : n$1, next();
+        }
+        __name(err, "err");
+        return next();
+      }, "d")
+    };
+  }
+  __name(_usingCtx, "_usingCtx");
+  module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_OverloadYield = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(exports, module) {
+  function _OverloadYield(e, d) {
+    this.v = e, this.k = d;
+  }
+  __name(_OverloadYield, "_OverloadYield");
+  module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_awaitAsyncGenerator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(exports, module) {
+  var OverloadYield$1 = require_OverloadYield();
+  function _awaitAsyncGenerator$1(e) {
+    return new OverloadYield$1(e, 0);
+  }
+  __name(_awaitAsyncGenerator$1, "_awaitAsyncGenerator$1");
+  module.exports = _awaitAsyncGenerator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_wrapAsyncGenerator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+  var OverloadYield = require_OverloadYield();
+  function _wrapAsyncGenerator$1(e) {
+    return function() {
+      return new AsyncGenerator(e.apply(this, arguments));
+    };
+  }
+  __name(_wrapAsyncGenerator$1, "_wrapAsyncGenerator$1");
+  function AsyncGenerator(e) {
+    var r, t;
+    function resume(r$1, t$1) {
+      try {
+        var n = e[r$1](t$1), o = n.value, u = o instanceof OverloadYield;
+        Promise.resolve(u ? o.v : o).then(function(t$2) {
+          if (u) {
+            var i = "return" === r$1 ? "return" : "next";
+            if (!o.k || t$2.done) return resume(i, t$2);
+            t$2 = e[i](t$2).value;
+          }
+          settle(n.done ? "return" : "normal", t$2);
+        }, function(e$1) {
+          resume("throw", e$1);
+        });
+      } catch (e$1) {
+        settle("throw", e$1);
+      }
+    }
+    __name(resume, "resume");
+    function settle(e$1, n) {
+      switch (e$1) {
+        case "return":
+          r.resolve({
+            value: n,
+            done: true
+          });
+          break;
+        case "throw":
+          r.reject(n);
+          break;
+        default:
+          r.resolve({
+            value: n,
+            done: false
+          });
+      }
+      (r = r.next) ? resume(r.key, r.arg) : t = null;
+    }
+    __name(settle, "settle");
+    this._invoke = function(e$1, n) {
+      return new Promise(function(o, u) {
+        var i = {
+          key: e$1,
+          arg: n,
+          resolve: o,
+          reject: u,
+          next: null
+        };
+        t ? t = t.next = i : (r = t = i, resume(e$1, n));
+      });
+    }, "function" != typeof e["return"] && (this["return"] = void 0);
+  }
+  __name(AsyncGenerator, "AsyncGenerator");
+  AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, AsyncGenerator.prototype.next = function(e) {
+    return this._invoke("next", e);
+  }, AsyncGenerator.prototype["throw"] = function(e) {
+    return this._invoke("throw", e);
+  }, AsyncGenerator.prototype["return"] = function(e) {
+    return this._invoke("return", e);
+  };
+  module.exports = _wrapAsyncGenerator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_usingCtx = __toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator = __toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator = __toESM(require_wrapAsyncGenerator(), 1);
+var import_objectSpread29 = __toESM(require_objectSpread2(), 1);
+
 // src/backend-client.ts
-import { createTRPCClient, createWSClient, wsLink, httpLink } from "@trpc/client";
 import superjson from "superjson";
 var BackendClient = class {
   static {
@@ -1084,4 +2842,9 @@ export {
   sensorLabelClasses,
   vehicleClasses
 };
+/*! Bundled license information:
+
+@trpc/client/dist/httpLink-oiU8eqFi.mjs:
+  (* istanbul ignore if -- @preserve *)
+*/
 //# sourceMappingURL=index.js.map