@camstack/addon-pipeline-analytics 0.1.1

package/dist/index-DKqbmJDl.mjs

@@ -0,0 +1,2464 @@
+import { S as Q } from "./index-C3iAUQqS.mjs";
+import { _ as ee, a as rt } from "./__mfe_internal__addon_pipeline_analytics_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.mjs-OesvKBZV.mjs";
+var nt = Object.defineProperty, o = (e, t) => nt(e, "name", { value: t, configurable: !0 }), it = Object.create, ae = Object.defineProperty, ot = Object.getOwnPropertyDescriptor, ce = Object.getOwnPropertyNames, st = Object.getPrototypeOf, at = Object.prototype.hasOwnProperty, _ = /* @__PURE__ */ o((e, t) => function() {
+  return t || (0, e[ce(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, "__commonJS"), ct = /* @__PURE__ */ o((e, t, r, n) => {
+  if (t && typeof t == "object" || typeof t == "function") for (var i = ce(t), s = 0, c = i.length, a; s < c; s++)
+    a = i[s], !at.call(e, a) && a !== r && ae(e, a, {
+      get: ((u) => t[u]).bind(null, a),
+      enumerable: !(n = ot(t, a)) || n.enumerable
+    });
+  return e;
+}, "__copyProps"), m = /* @__PURE__ */ o((e, t, r) => (r = e != null ? it(st(e)) : {}, ct(t || !e || !e.__esModule ? ae(r, "default", {
+  value: e,
+  enumerable: !0
+}) : r, e)), "__toESM"), ue = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(e, t) {
+  function r(n) {
+    "@babel/helpers - typeof";
+    return t.exports = r = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(i) {
+      return typeof i;
+    } : function(i) {
+      return i && typeof Symbol == "function" && i.constructor === Symbol && i !== Symbol.prototype ? "symbol" : typeof i;
+    }, t.exports.__esModule = !0, t.exports.default = t.exports, r(n);
+  }
+  o(r, "_typeof$2"), t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), ut = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(e, t) {
+  var r = ue().default;
+  function n(i, s) {
+    if (r(i) != "object" || !i) return i;
+    var c = i[Symbol.toPrimitive];
+    if (c !== void 0) {
+      var a = c.call(i, s || "default");
+      if (r(a) != "object") return a;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (s === "string" ? String : Number)(i);
+  }
+  o(n, "toPrimitive$1"), t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), lt = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(e, t) {
+  var r = ue().default, n = ut();
+  function i(s) {
+    var c = n(s, "string");
+    return r(c) == "symbol" ? c : c + "";
+  }
+  o(i, "toPropertyKey$1"), t.exports = i, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), S = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(e, t) {
+  var r = lt();
+  function n(i, s, c) {
+    return (s = r(s)) in i ? Object.defineProperty(i, s, {
+      value: c,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : i[s] = c, i;
+  }
+  o(n, "_defineProperty"), t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), v = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(e, t) {
+  var r = S();
+  function n(s, c) {
+    var a = Object.keys(s);
+    if (Object.getOwnPropertySymbols) {
+      var u = Object.getOwnPropertySymbols(s);
+      c && (u = u.filter(function(l) {
+        return Object.getOwnPropertyDescriptor(s, l).enumerable;
+      })), a.push.apply(a, u);
+    }
+    return a;
+  }
+  o(n, "ownKeys");
+  function i(s) {
+    for (var c = 1; c < arguments.length; c++) {
+      var a = arguments[c] != null ? arguments[c] : {};
+      c % 2 ? n(Object(a), !0).forEach(function(u) {
+        r(s, u, a[u]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(s, Object.getOwnPropertyDescriptors(a)) : n(Object(a)).forEach(function(u) {
+        Object.defineProperty(s, u, Object.getOwnPropertyDescriptor(a, u));
+      });
+    }
+    return s;
+  }
+  o(i, "_objectSpread2"), t.exports = i, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+function C(e) {
+  const t = {
+    subscribe(r) {
+      let n = null, i = !1, s = !1, c = !1;
+      function a() {
+        if (n === null) {
+          c = !0;
+          return;
+        }
+        s || (s = !0, typeof n == "function" ? n() : n && n.unsubscribe());
+      }
+      return o(a, "unsubscribe"), n = e({
+        next(u) {
+          var l;
+          i || (l = r.next) === null || l === void 0 || l.call(r, u);
+        },
+        error(u) {
+          var l;
+          i || (i = !0, (l = r.error) === null || l === void 0 || l.call(r, u), a());
+        },
+        complete() {
+          var u;
+          i || (i = !0, (u = r.complete) === null || u === void 0 || u.call(r), a());
+        }
+      }), c && a(), { unsubscribe: a };
+    },
+    pipe(...r) {
+      return r.reduce(le, t);
+    }
+  };
+  return t;
+}
+o(C, "observable");
+function le(e, t) {
+  return t(e);
+}
+o(le, "pipeReducer");
+function de(e) {
+  const t = new AbortController();
+  return new Promise((n, i) => {
+    let s = !1;
+    function c() {
+      s || (s = !0, a.unsubscribe());
+    }
+    o(c, "onDone"), t.signal.addEventListener("abort", () => {
+      i(t.signal.reason);
+    });
+    const a = e.subscribe({
+      next(u) {
+        s = !0, n(u), c();
+      },
+      error(u) {
+        i(u);
+      },
+      complete() {
+        t.abort(), c();
+      }
+    });
+  });
+}
+o(de, "observableToPromise");
+function pe(e) {
+  return (t) => {
+    let r = 0, n = null;
+    const i = [];
+    function s() {
+      n || (n = t.subscribe({
+        next(a) {
+          for (const l of i) {
+            var u;
+            (u = l.next) === null || u === void 0 || u.call(l, a);
+          }
+        },
+        error(a) {
+          for (const l of i) {
+            var u;
+            (u = l.error) === null || u === void 0 || u.call(l, a);
+          }
+        },
+        complete() {
+          for (const u of i) {
+            var a;
+            (a = u.complete) === null || a === void 0 || a.call(u);
+          }
+        }
+      }));
+    }
+    o(s, "startIfNeeded");
+    function c() {
+      if (r === 0 && n) {
+        const a = n;
+        n = null, a.unsubscribe();
+      }
+    }
+    return o(c, "resetIfNeeded"), C((a) => (r++, i.push(a), s(), { unsubscribe() {
+      r--, c();
+      const u = i.findIndex((l) => l === a);
+      u > -1 && i.splice(u, 1);
+    } }));
+  };
+}
+o(pe, "share");
+function U(e) {
+  let t = e;
+  const r = [], n = /* @__PURE__ */ o((c) => {
+    t !== void 0 && c.next(t), r.push(c);
+  }, "addObserver"), i = /* @__PURE__ */ o((c) => {
+    r.splice(r.indexOf(c), 1);
+  }, "removeObserver"), s = C((c) => (n(c), () => {
+    i(c);
+  }));
+  return s.next = (c) => {
+    if (t !== c) {
+      t = c;
+      for (const a of r) a.next(c);
+    }
+  }, s.get = () => t, s;
+}
+o(U, "behaviorSubject");
+function fe(e) {
+  return C((t) => {
+    function r(i = 0, s = e.op) {
+      const c = e.links[i];
+      if (!c) throw new Error("No more links to execute - did you forget to add an ending link?");
+      return c({
+        op: s,
+        next(u) {
+          return r(i + 1, u);
+        }
+      });
+    }
+    return o(r, "execute"), r().subscribe(t);
+  });
+}
+o(fe, "createChain");
+function j(e) {
+  return !!e && !Array.isArray(e) && typeof e == "object";
+}
+o(j, "isObject");
+function he() {
+  return /* @__PURE__ */ Object.create(null);
+}
+o(he, "emptyObject");
+var te = /* @__PURE__ */ o((e) => e(), "run");
+function B(e = 0) {
+  return new Promise((t) => setTimeout(t, e));
+}
+o(B, "sleep");
+var dt = Object.create, me = Object.defineProperty, pt = Object.getOwnPropertyDescriptor, ye = Object.getOwnPropertyNames, ft = Object.getPrototypeOf, ht = Object.prototype.hasOwnProperty, M = /* @__PURE__ */ o((e, t) => function() {
+  return t || (0, e[ye(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, "__commonJS"), mt = /* @__PURE__ */ o((e, t, r, n) => {
+  if (t && typeof t == "object" || typeof t == "function") for (var i = ye(t), s = 0, c = i.length, a; s < c; s++)
+    a = i[s], !ht.call(e, a) && a !== r && me(e, a, {
+      get: ((u) => t[u]).bind(null, a),
+      enumerable: !(n = pt(t, a)) || n.enumerable
+    });
+  return e;
+}, "__copyProps"), L = /* @__PURE__ */ o((e, t, r) => (r = e != null ? dt(ft(e)) : {}, mt(t || !e || !e.__esModule ? me(r, "default", {
+  value: e,
+  enumerable: !0
+}) : r, e)), "__toESM"), ve = /* @__PURE__ */ o(() => {
+}, "noop"), re = /* @__PURE__ */ o((e) => {
+  Object.freeze && Object.freeze(e);
+}, "freezeIfAvailable");
+function H(e, t, r) {
+  var n;
+  const i = t.join(".");
+  return (n = r[i]) !== null && n !== void 0 || (r[i] = new Proxy(ve, {
+    get(s, c) {
+      if (!(typeof c != "string" || c === "then"))
+        return H(e, [...t, c], r);
+    },
+    apply(s, c, a) {
+      const u = t[t.length - 1];
+      if (u === "valueOf" || u === "toString" || u === "toJSON")
+        return `tRPC.proxy(${t.slice(0, -1).join(".")})`;
+      let l = {
+        args: a,
+        path: t
+      };
+      return u === "call" ? l = {
+        args: a.length >= 2 ? [a[1]] : [],
+        path: t.slice(0, -1)
+      } : u === "apply" && (l = {
+        args: a.length >= 2 ? a[1] : [],
+        path: t.slice(0, -1)
+      }), re(l.args), re(l.path), e(l);
+    }
+  })), r[i];
+}
+o(H, "createInnerProxy");
+var yt = /* @__PURE__ */ o((e) => H(e, [], he()), "createRecursiveProxy"), vt = /* @__PURE__ */ o((e) => new Proxy(ve, { get(t, r) {
+  if (r !== "then")
+    return e(r);
+} }), "createFlatProxy"), be = M({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(e, t) {
+  function r(n) {
+    "@babel/helpers - typeof";
+    return t.exports = r = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(i) {
+      return typeof i;
+    } : function(i) {
+      return i && typeof Symbol == "function" && i.constructor === Symbol && i !== Symbol.prototype ? "symbol" : typeof i;
+    }, t.exports.__esModule = !0, t.exports.default = t.exports, r(n);
+  }
+  o(r, "_typeof$2"), t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), bt = M({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(e, t) {
+  var r = be().default;
+  function n(i, s) {
+    if (r(i) != "object" || !i) return i;
+    var c = i[Symbol.toPrimitive];
+    if (c !== void 0) {
+      var a = c.call(i, s || "default");
+      if (r(a) != "object") return a;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (s === "string" ? String : Number)(i);
+  }
+  o(n, "toPrimitive$1"), t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), gt = M({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(e, t) {
+  var r = be().default, n = bt();
+  function i(s) {
+    var c = n(s, "string");
+    return r(c) == "symbol" ? c : c + "";
+  }
+  o(i, "toPropertyKey$1"), t.exports = i, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), ge = M({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(e, t) {
+  var r = gt();
+  function n(i, s, c) {
+    return (s = r(s)) in i ? Object.defineProperty(i, s, {
+      value: c,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : i[s] = c, i;
+  }
+  o(n, "_defineProperty"), t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), V = M({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(e, t) {
+  var r = ge();
+  function n(s, c) {
+    var a = Object.keys(s);
+    if (Object.getOwnPropertySymbols) {
+      var u = Object.getOwnPropertySymbols(s);
+      c && (u = u.filter(function(l) {
+        return Object.getOwnPropertyDescriptor(s, l).enumerable;
+      })), a.push.apply(a, u);
+    }
+    return a;
+  }
+  o(n, "ownKeys");
+  function i(s) {
+    for (var c = 1; c < arguments.length; c++) {
+      var a = arguments[c] != null ? arguments[c] : {};
+      c % 2 ? n(Object(a), !0).forEach(function(u) {
+        r(s, u, a[u]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(s, Object.getOwnPropertyDescriptors(a)) : n(Object(a)).forEach(function(u) {
+        Object.defineProperty(s, u, Object.getOwnPropertyDescriptor(a, u));
+      });
+    }
+    return s;
+  }
+  o(i, "_objectSpread2"), t.exports = i, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+L(V(), 1);
+L(ge(), 1);
+var q = L(V(), 1);
+function _e(e, t) {
+  if ("error" in e) {
+    const n = t.deserialize(e.error);
+    return {
+      ok: !1,
+      error: (0, q.default)((0, q.default)({}, e), {}, { error: n })
+    };
+  }
+  return {
+    ok: !0,
+    result: (0, q.default)((0, q.default)({}, e.result), (!e.result.type || e.result.type === "data") && {
+      type: "data",
+      data: t.deserialize(e.result.data)
+    })
+  };
+}
+o(_e, "transformResultInner");
+var N = class extends Error {
+  static {
+    o(this, "TransformResultError");
+  }
+  constructor() {
+    super("Unable to transform response from server");
+  }
+};
+function K(e, t) {
+  let r;
+  try {
+    r = _e(e, t);
+  } catch {
+    throw new N();
+  }
+  if (!r.ok && (!j(r.error.error) || typeof r.error.error.code != "number")) throw new N();
+  if (r.ok && !j(r.result)) throw new N();
+  return r;
+}
+o(K, "transformResult");
+L(V(), 1);
+var A = m(S(), 1), O = m(v(), 1);
+function Pe(e) {
+  return e instanceof P;
+}
+o(Pe, "isTRPCClientError");
+function we(e) {
+  return j(e) && j(e.error) && typeof e.error.code == "number" && typeof e.error.message == "string";
+}
+o(we, "isTRPCErrorResponse");
+function xe(e, t) {
+  return typeof e == "string" ? e : j(e) && typeof e.message == "string" ? e.message : t;
+}
+o(xe, "getMessageFromUnknownError");
+var P = class I extends Error {
+  static {
+    o(this, "TRPCClientError");
+  }
+  constructor(t, r) {
+    var n, i;
+    const s = r?.cause;
+    super(t, { cause: s }), (0, A.default)(this, "cause", void 0), (0, A.default)(this, "shape", void 0), (0, A.default)(this, "data", void 0), (0, A.default)(this, "meta", void 0), this.meta = r?.meta, this.cause = s, this.shape = r == null || (n = r.result) === null || n === void 0 ? void 0 : n.error, this.data = r == null || (i = r.result) === null || i === void 0 ? void 0 : i.error.data, this.name = "TRPCClientError", Object.setPrototypeOf(this, I.prototype);
+  }
+  static from(t, r = {}) {
+    const n = t;
+    return Pe(n) ? (r.meta && (n.meta = (0, O.default)((0, O.default)({}, n.meta), r.meta)), n) : we(n) ? new I(n.error.message, (0, O.default)((0, O.default)({}, r), {}, {
+      result: n,
+      cause: r.cause
+    })) : new I(xe(n, "Unknown error"), (0, O.default)((0, O.default)({}, r), {}, { cause: n }));
+  }
+};
+function Y(e) {
+  const t = e;
+  return t ? "input" in t ? t : {
+    input: t,
+    output: t
+  } : {
+    input: {
+      serialize: /* @__PURE__ */ o((r) => r, "serialize"),
+      deserialize: /* @__PURE__ */ o((r) => r, "deserialize")
+    },
+    output: {
+      serialize: /* @__PURE__ */ o((r) => r, "serialize"),
+      deserialize: /* @__PURE__ */ o((r) => r, "deserialize")
+    }
+  };
+}
+o(Y, "getTransformer");
+var ne = /* @__PURE__ */ o((e) => typeof e == "function", "isFunction");
+function Se(e) {
+  if (e) return e;
+  if (typeof window < "u" && ne(window.fetch)) return window.fetch;
+  if (typeof globalThis < "u" && ne(globalThis.fetch)) return globalThis.fetch;
+  throw new Error("No fetch implementation found");
+}
+o(Se, "getFetch");
+var R = m(v(), 1);
+function Ce(e) {
+  return {
+    url: e.url.toString(),
+    fetch: e.fetch,
+    transformer: Y(e.transformer),
+    methodOverride: e.methodOverride
+  };
+}
+o(Ce, "resolveHTTPLinkOptions");
+function Oe(e) {
+  const t = {};
+  for (let r = 0; r < e.length; r++) {
+    const n = e[r];
+    t[r] = n;
+  }
+  return t;
+}
+o(Oe, "arrayToDict");
+var _t = {
+  query: "GET",
+  mutation: "POST",
+  subscription: "PATCH"
+};
+function J(e) {
+  return "input" in e ? e.transformer.input.serialize(e.input) : Oe(e.inputs.map((t) => e.transformer.input.serialize(t)));
+}
+o(J, "getInput");
+var F = /* @__PURE__ */ o((e) => {
+  const t = e.url.split("?");
+  let n = t[0].replace(/\/$/, "") + "/" + e.path;
+  const i = [];
+  if (t[1] && i.push(t[1]), "inputs" in e && i.push("batch=1"), e.type === "query" || e.type === "subscription") {
+    const s = J(e);
+    s !== void 0 && e.methodOverride !== "POST" && i.push(`input=${encodeURIComponent(JSON.stringify(s))}`);
+  }
+  return i.length && (n += "?" + i.join("&")), n;
+}, "getUrl"), Pt = /* @__PURE__ */ o((e) => {
+  if (e.type === "query" && e.methodOverride !== "POST") return;
+  const t = J(e);
+  return t !== void 0 ? JSON.stringify(t) : void 0;
+}, "getBody"), wt = /* @__PURE__ */ o((e) => D((0, R.default)((0, R.default)({}, e), {}, {
+  contentTypeHeader: "application/json",
+  getUrl: F,
+  getBody: Pt
+})), "jsonHttpRequester"), xt = class extends Error {
+  static {
+    o(this, "AbortError");
+  }
+  constructor() {
+    const e = "AbortError";
+    super(e), this.name = e, this.message = e;
+  }
+}, St = /* @__PURE__ */ o((e) => {
+  var t;
+  if (e?.aborted)
+    throw (t = e.throwIfAborted) === null || t === void 0 || t.call(e), typeof DOMException < "u" ? new DOMException("AbortError", "AbortError") : new xt();
+}, "throwIfAborted");
+async function Ee(e) {
+  var t, r;
+  St(e.signal);
+  const n = e.getUrl(e), i = e.getBody(e), s = (t = e.methodOverride) !== null && t !== void 0 ? t : _t[e.type], c = await (async () => {
+    const u = await e.headers();
+    return Symbol.iterator in u ? Object.fromEntries(u) : u;
+  })(), a = (0, R.default)((0, R.default)((0, R.default)({}, e.contentTypeHeader && s !== "GET" ? { "content-type": e.contentTypeHeader } : {}), e.trpcAcceptHeader ? { [(r = e.trpcAcceptHeaderKey) !== null && r !== void 0 ? r : "trpc-accept"]: e.trpcAcceptHeader } : void 0), c);
+  return Se(e.fetch)(n, {
+    method: s,
+    signal: e.signal,
+    body: i,
+    headers: a
+  });
+}
+o(Ee, "fetchHTTPResponse");
+async function D(e) {
+  const t = {}, r = await Ee(e);
+  t.response = r;
+  const n = await r.json();
+  return t.responseJSON = n, {
+    json: n,
+    meta: t
+  };
+}
+o(D, "httpRequest");
+function Te(e) {
+  return e instanceof Uint8Array || e instanceof Blob;
+}
+o(Te, "isOctetType");
+function ke(e) {
+  return e instanceof FormData;
+}
+o(ke, "isFormData");
+var k = m(v(), 1), Ct = /* @__PURE__ */ o((e) => {
+  if ("input" in e) {
+    const { input: t } = e;
+    if (ke(t)) {
+      if (e.type !== "mutation" && e.methodOverride !== "POST") throw new Error("FormData is only supported for mutations");
+      return D((0, k.default)((0, k.default)({}, e), {}, {
+        contentTypeHeader: void 0,
+        getUrl: F,
+        getBody: /* @__PURE__ */ o(() => t, "getBody")
+      }));
+    }
+    if (Te(t)) {
+      if (e.type !== "mutation" && e.methodOverride !== "POST") throw new Error("Octet type input is only supported for mutations");
+      return D((0, k.default)((0, k.default)({}, e), {}, {
+        contentTypeHeader: "application/octet-stream",
+        getUrl: F,
+        getBody: /* @__PURE__ */ o(() => t, "getBody")
+      }));
+    }
+  }
+  return wt(e);
+}, "universalRequester");
+function je(e) {
+  const t = Ce(e);
+  return () => (r) => {
+    const { op: n } = r;
+    return C((i) => {
+      const { path: s, input: c, type: a } = n;
+      if (a === "subscription") throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+      const u = Ct((0, k.default)((0, k.default)({}, t), {}, {
+        type: a,
+        path: s,
+        input: c,
+        signal: n.signal,
+        headers() {
+          return e.headers ? typeof e.headers == "function" ? e.headers({ op: n }) : e.headers : {};
+        }
+      }));
+      let l;
+      return u.then((d) => {
+        l = d.meta;
+        const p = K(d.json, t.transformer.output);
+        if (!p.ok) {
+          i.error(P.from(p.error, { meta: l }));
+          return;
+        }
+        i.next({
+          context: d.meta,
+          result: p.result
+        }), i.complete();
+      }).catch((d) => {
+        i.error(P.from(d, { meta: l }));
+      }), () => {
+      };
+    });
+  };
+}
+o(je, "httpLink");
+m(v(), 1);
+m(v(), 1);
+var Ot = {
+  encode: /* @__PURE__ */ o((e) => JSON.stringify(e), "encode"),
+  decode: /* @__PURE__ */ o((e) => {
+    if (typeof e != "string") throw new Error("jsonEncoder received binary data. JSON uses text frames. Use a binary encoder for binary data.");
+    return JSON.parse(e);
+  }, "decode")
+}, Et = {
+  enabled: !1,
+  closeMs: 0
+}, Tt = {
+  enabled: !1,
+  pongTimeoutMs: 1e3,
+  intervalMs: 5e3
+}, kt = /* @__PURE__ */ o((e) => e === 0 ? 0 : Math.min(1e3 * 2 ** e, 3e4), "exponentialBackoff"), Re = /* @__PURE__ */ o((e, ...t) => typeof e == "function" ? e(...t) : e, "resultOf"), jt = m(S(), 1), E = class Me extends Error {
+  static {
+    o(this, "TRPCWebSocketClosedError");
+  }
+  constructor(t) {
+    super(t.message, { cause: t.cause }), this.name = "TRPCWebSocketClosedError", Object.setPrototypeOf(this, Me.prototype);
+  }
+}, Rt = class {
+  static {
+    o(this, "ResettableTimeout");
+  }
+  constructor(e, t) {
+    this.onTimeout = e, this.timeoutMs = t, (0, jt.default)(this, "timeout", void 0);
+  }
+  /**
+  * Resets the current timeout, restarting it with the same duration.
+  * Does nothing if no timeout is active.
+  */
+  reset() {
+    this.timeout && (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 X() {
+  let e, t;
+  return {
+    promise: new Promise((n, i) => {
+      e = n, t = i;
+    }),
+    resolve: e,
+    reject: t
+  };
+}
+o(X, "withResolvers");
+async function qe(e) {
+  const t = await Re(e.url);
+  if (!e.connectionParams) return t;
+  const n = `${t.includes("?") ? "&" : "?"}connectionParams=1`;
+  return t + n;
+}
+o(qe, "prepareUrl");
+async function Ae(e, t) {
+  const r = {
+    method: "connectionParams",
+    data: await Re(e)
+  };
+  return t.encode(r);
+}
+o(Ae, "buildConnectionMessage");
+var ie = m(S(), 1), Mt = class {
+  static {
+    o(this, "RequestManager");
+  }
+  constructor() {
+    (0, ie.default)(this, "outgoingRequests", new Array()), (0, ie.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(e, t) {
+    const { promise: r, resolve: n } = X();
+    return this.outgoingRequests.push({
+      id: String(e.id),
+      message: e,
+      end: r,
+      callbacks: {
+        next: t.next,
+        complete: /* @__PURE__ */ o(() => {
+          t.complete(), n();
+        }, "complete"),
+        error: /* @__PURE__ */ o((i) => {
+          t.error(i), n();
+        }, "error")
+      }
+    }), () => {
+      this.delete(e.id), t.complete(), n();
+    };
+  }
+  /**
+  * Deletes a request from both the outgoing and pending collections, if it exists.
+  */
+  delete(e) {
+    e !== null && (this.outgoingRequests = this.outgoingRequests.filter(({ id: t }) => t !== String(e)), delete this.pendingRequests[String(e)]);
+  }
+  /**
+  * 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 e = this.outgoingRequests;
+    this.outgoingRequests = [];
+    for (const t of e) this.pendingRequests[t.id] = t;
+    return e;
+  }
+  /**
+  * 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(e) {
+    return e === null ? null : this.pendingRequests[String(e)];
+  }
+  /**
+  * 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((e) => ({
+      state: "outgoing",
+      message: e.message,
+      end: e.end,
+      callbacks: e.callbacks
+    })), ...this.getPendingRequests().map((e) => ({
+      state: "pending",
+      message: e.message,
+      end: e.end,
+      callbacks: e.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((e) => e.message.method === "subscription");
+  }
+  /**
+  * Checks if there are any outgoing requests waiting to be sent.
+  */
+  hasOutgoingRequests() {
+    return this.outgoingRequests.length > 0;
+  }
+}, x = m(S(), 1);
+function Ie(e) {
+  const { promise: t, resolve: r, reject: n } = X();
+  return e.addEventListener("open", () => {
+    e.removeEventListener("error", n), r();
+  }), e.addEventListener("error", n), t;
+}
+o(Ie, "asyncWsOpen");
+function De(e, { intervalMs: t, pongTimeoutMs: r }) {
+  let n, i;
+  function s() {
+    n = setTimeout(() => {
+      e.send("PING"), i = setTimeout(() => {
+        e.close();
+      }, r);
+    }, t);
+  }
+  o(s, "start");
+  function c() {
+    clearTimeout(n), s();
+  }
+  o(c, "reset");
+  function a() {
+    clearTimeout(i), c();
+  }
+  o(a, "pong"), e.addEventListener("open", s), e.addEventListener("message", ({ data: u }) => {
+    clearTimeout(n), s(), u === "PONG" && a();
+  }), e.addEventListener("close", () => {
+    clearTimeout(n), clearTimeout(i);
+  });
+}
+o(De, "setupPingInterval");
+var Le = class z {
+  static {
+    o(this, "WsConnection");
+  }
+  constructor(t) {
+    var r;
+    if ((0, x.default)(this, "id", ++z.connectCount), (0, x.default)(this, "WebSocketPonyfill", void 0), (0, x.default)(this, "urlOptions", void 0), (0, x.default)(this, "keepAliveOpts", void 0), (0, x.default)(this, "encoder", void 0), (0, x.default)(this, "wsObservable", U(null)), (0, x.default)(this, "openPromise", null), this.WebSocketPonyfill = (r = t.WebSocketPonyfill) !== null && r !== void 0 ? r : WebSocket, !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 = t.urlOptions, this.keepAliveOpts = t.keepAlive, this.encoder = t.encoder;
+  }
+  get ws() {
+    return this.wsObservable.get();
+  }
+  set ws(t) {
+    this.wsObservable.next(t);
+  }
+  /**
+  * 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 t = this;
+    if (t.openPromise) return t.openPromise;
+    t.id = ++z.connectCount;
+    const r = qe(t.urlOptions).then((n) => new t.WebSocketPonyfill(n));
+    t.openPromise = r.then(async (n) => {
+      t.ws = n, n.binaryType = "arraybuffer", n.addEventListener("message", function({ data: i }) {
+        i === "PING" && this.send("PONG");
+      }), t.keepAliveOpts.enabled && De(n, t.keepAliveOpts), n.addEventListener("close", () => {
+        t.ws === n && (t.ws = null);
+      }), await Ie(n), t.urlOptions.connectionParams && n.send(await Ae(t.urlOptions.connectionParams, t.encoder));
+    });
+    try {
+      await t.openPromise;
+    } finally {
+      t.openPromise = null;
+    }
+  }
+  /**
+  * Closes the WebSocket connection gracefully.
+  * Waits for any ongoing open operation to complete before closing.
+  */
+  async close() {
+    var t = this;
+    try {
+      await t.openPromise;
+    } finally {
+      var r;
+      (r = t.ws) === null || r === void 0 || r.close();
+    }
+  }
+};
+(0, x.default)(Le, "connectCount", 0);
+function Ne(e) {
+  return e.isOpen() ? {
+    id: e.id,
+    state: "open",
+    ws: e.ws
+  } : e.isClosed() ? {
+    id: e.id,
+    state: "closed",
+    ws: e.ws
+  } : e.ws ? {
+    id: e.id,
+    state: "connecting",
+    ws: e.ws
+  } : null;
+}
+o(Ne, "backwardCompatibility");
+var g = m(S(), 1), T = m(v(), 1), qt = class {
+  static {
+    o(this, "WsClient");
+  }
+  constructor(e) {
+    var t, r;
+    (0, g.default)(this, "connectionState", void 0), (0, g.default)(this, "allowReconnect", !1), (0, g.default)(this, "requestManager", new Mt()), (0, g.default)(this, "activeConnection", void 0), (0, g.default)(this, "reconnectRetryDelay", void 0), (0, g.default)(this, "inactivityTimeout", void 0), (0, g.default)(this, "callbacks", void 0), (0, g.default)(this, "lazyMode", void 0), (0, g.default)(this, "encoder", void 0), (0, g.default)(this, "reconnecting", null), this.encoder = (t = e.experimental_encoder) !== null && t !== void 0 ? t : Ot, this.callbacks = {
+      onOpen: e.onOpen,
+      onClose: e.onClose,
+      onError: e.onError
+    };
+    const n = (0, T.default)((0, T.default)({}, Et), e.lazy);
+    this.inactivityTimeout = new Rt(() => {
+      if (this.requestManager.hasOutgoingRequests() || this.requestManager.hasPendingRequests()) {
+        this.inactivityTimeout.reset();
+        return;
+      }
+      this.close().catch(() => null);
+    }, n.closeMs), this.activeConnection = new Le({
+      WebSocketPonyfill: e.WebSocket,
+      urlOptions: e,
+      keepAlive: (0, T.default)((0, T.default)({}, Tt), e.keepAlive),
+      encoder: this.encoder
+    }), this.activeConnection.wsObservable.subscribe({ next: /* @__PURE__ */ o((i) => {
+      i && this.setupWebSocketListeners(i);
+    }, "next") }), this.reconnectRetryDelay = (r = e.retryDelayMs) !== null && r !== void 0 ? r : kt, this.lazyMode = n.enabled, this.connectionState = U({
+      type: "state",
+      state: n.enabled ? "idle" : "connecting",
+      error: null
+    }), this.lazyMode || this.open().catch(() => null);
+  }
+  /**
+  * Opens the WebSocket connection. Handles reconnection attempts and updates
+  * the connection state accordingly.
+  */
+  async open() {
+    var e = this;
+    e.allowReconnect = !0, e.connectionState.get().state === "idle" && e.connectionState.next({
+      type: "state",
+      state: "connecting",
+      error: null
+    });
+    try {
+      await e.activeConnection.open();
+    } catch (t) {
+      return e.reconnect(new E({
+        message: "Initialization error",
+        cause: t
+      })), e.reconnecting;
+    }
+  }
+  /**
+  * Closes the WebSocket connection and stops managing requests.
+  * Ensures all outgoing and pending requests are properly finalized.
+  */
+  async close() {
+    var e = this;
+    e.allowReconnect = !1, e.inactivityTimeout.stop();
+    const t = [];
+    for (const r of e.requestManager.getRequests()) r.message.method === "subscription" ? r.callbacks.complete() : r.state === "outgoing" ? r.callbacks.error(P.from(new E({ message: "Closed before connection was established" }))) : t.push(r.end);
+    await Promise.all(t).catch(() => null), await e.activeConnection.close().catch(() => null), e.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: e, type: t, path: r, input: n, signal: i }, transformer: s, lastEventId: c }) {
+    return C((a) => {
+      const u = this.batchSend({
+        id: e,
+        method: t,
+        params: {
+          input: s.input.serialize(n),
+          path: r,
+          lastEventId: c
+        }
+      }, (0, T.default)((0, T.default)({}, a), {}, { next(l) {
+        const d = K(l, s.output);
+        if (!d.ok) {
+          a.error(P.from(d.error));
+          return;
+        }
+        a.next({ result: d.result });
+      } }));
+      return () => {
+        u(), t === "subscription" && this.activeConnection.isOpen() && this.send({
+          id: e,
+          method: "subscription.stop"
+        }), i?.removeEventListener("abort", u);
+      };
+    });
+  }
+  get connection() {
+    return Ne(this.activeConnection);
+  }
+  reconnect(e) {
+    var t = this;
+    if (this.connectionState.next({
+      type: "state",
+      state: "connecting",
+      error: P.from(e)
+    }), this.reconnecting) return;
+    const r = /* @__PURE__ */ o(async (n) => {
+      try {
+        await B(t.reconnectRetryDelay(n)), t.allowReconnect && (await t.activeConnection.close(), await t.activeConnection.open(), t.requestManager.hasPendingRequests() && t.send(t.requestManager.getPendingRequests().map(({ message: i }) => i))), t.reconnecting = null;
+      } catch {
+        await r(n + 1);
+      }
+    }, "tryReconnect");
+    this.reconnecting = r(0);
+  }
+  setupWebSocketListeners(e) {
+    var t = this;
+    const r = /* @__PURE__ */ o((n) => {
+      const i = this.requestManager.getPendingRequests();
+      for (const { message: s, callbacks: c } of i)
+        s.method !== "subscription" && (c.error(P.from(n ?? new E({
+          message: "WebSocket closed",
+          cause: n
+        }))), this.requestManager.delete(s.id));
+    }, "handleCloseOrError");
+    e.addEventListener("open", () => {
+      te(async () => {
+        var n, i;
+        t.lazyMode && t.inactivityTimeout.start(), (n = (i = t.callbacks).onOpen) === null || n === void 0 || n.call(i), t.connectionState.next({
+          type: "state",
+          state: "pending",
+          error: null
+        });
+      }).catch((n) => {
+        e.close(3e3), r(n);
+      });
+    }), e.addEventListener("message", ({ data: n }) => {
+      if (this.inactivityTimeout.reset(), ["PING", "PONG"].includes(n)) return;
+      const i = this.encoder.decode(n);
+      if ("method" in i) {
+        this.handleIncomingRequest(i);
+        return;
+      }
+      this.handleResponseMessage(i);
+    }), e.addEventListener("close", (n) => {
+      var i, s;
+      r(n), (i = (s = this.callbacks).onClose) === null || i === void 0 || i.call(s, n), (!this.lazyMode || this.requestManager.hasPendingSubscriptions()) && this.reconnect(new E({
+        message: "WebSocket closed",
+        cause: n
+      }));
+    }), e.addEventListener("error", (n) => {
+      var i, s;
+      r(n), (i = (s = this.callbacks).onError) === null || i === void 0 || i.call(s, n), this.reconnect(new E({
+        message: "WebSocket closed",
+        cause: n
+      }));
+    });
+  }
+  handleResponseMessage(e) {
+    const t = this.requestManager.getPendingRequest(e.id);
+    if (!t) return;
+    t.callbacks.next(e);
+    let r = !0;
+    "result" in e && t.message.method === "subscription" && (e.result.type === "data" && (t.message.params.lastEventId = e.result.id), e.result.type !== "stopped" && (r = !1)), r && (t.callbacks.complete(), this.requestManager.delete(e.id));
+  }
+  handleIncomingRequest(e) {
+    e.method === "reconnect" && this.reconnect(new E({ message: "Server requested reconnect" }));
+  }
+  /**
+  * Sends a message or batch of messages directly to the server.
+  */
+  send(e) {
+    if (!this.activeConnection.isOpen()) throw new Error("Active connection is not open");
+    const t = e instanceof Array ? e : [e];
+    this.activeConnection.ws.send(this.encoder.encode(t.length === 1 ? t[0] : t));
+  }
+  /**
+  * Groups requests for batch sending.
+  *
+  * @returns A function to abort the batched request.
+  */
+  batchSend(e, t) {
+    var r = this;
+    return this.inactivityTimeout.reset(), te(async () => {
+      r.activeConnection.isOpen() || await r.open(), await B(0), r.requestManager.hasOutgoingRequests() && r.send(r.requestManager.flush().map(({ message: n }) => n));
+    }).catch((n) => {
+      this.requestManager.delete(e.id), t.error(P.from(n));
+    }), this.requestManager.register(e, t);
+  }
+};
+function We(e) {
+  return new qt(e);
+}
+o(We, "createWSClient");
+function Be(e) {
+  const { client: t } = e, r = Y(e.transformer);
+  return () => ({ op: n }) => C((i) => {
+    const s = n.type === "subscription" ? t.connectionState.subscribe({ next(a) {
+      i.next({
+        result: a,
+        context: n.context
+      });
+    } }) : null, c = t.request({
+      op: n,
+      transformer: r
+    }).subscribe(i);
+    return () => {
+      c.unsubscribe(), s?.unsubscribe();
+    };
+  });
+}
+o(Be, "wsLink");
+var W = m(S(), 1), oe = m(v(), 1), At = class {
+  static {
+    o(this, "TRPCUntypedClient");
+  }
+  constructor(e) {
+    (0, W.default)(this, "links", void 0), (0, W.default)(this, "runtime", void 0), (0, W.default)(this, "requestId", void 0), this.requestId = 0, this.runtime = {}, this.links = e.links.map((t) => t(this.runtime));
+  }
+  $request(e) {
+    var t;
+    return fe({
+      links: this.links,
+      op: (0, oe.default)((0, oe.default)({}, e), {}, {
+        context: (t = e.context) !== null && t !== void 0 ? t : {},
+        id: ++this.requestId
+      })
+    }).pipe(pe());
+  }
+  async requestAsPromise(e) {
+    var t = this;
+    try {
+      const r = t.$request(e);
+      return (await de(r)).result.data;
+    } catch (r) {
+      throw P.from(r);
+    }
+  }
+  query(e, t, r) {
+    return this.requestAsPromise({
+      type: "query",
+      path: e,
+      input: t,
+      context: r?.context,
+      signal: r?.signal
+    });
+  }
+  mutation(e, t, r) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path: e,
+      input: t,
+      context: r?.context,
+      signal: r?.signal
+    });
+  }
+  subscription(e, t, r) {
+    return this.$request({
+      type: "subscription",
+      path: e,
+      input: t,
+      context: r.context,
+      signal: r.signal
+    }).subscribe({
+      next(i) {
+        switch (i.result.type) {
+          case "state": {
+            var s;
+            (s = r.onConnectionStateChange) === null || s === void 0 || s.call(r, i.result);
+            break;
+          }
+          case "started": {
+            var c;
+            (c = r.onStarted) === null || c === void 0 || c.call(r, { context: i.context });
+            break;
+          }
+          case "stopped": {
+            var a;
+            (a = r.onStopped) === null || a === void 0 || a.call(r);
+            break;
+          }
+          case "data":
+          case void 0: {
+            var u;
+            (u = r.onData) === null || u === void 0 || u.call(r, i.result.data);
+            break;
+          }
+        }
+      },
+      error(i) {
+        var s;
+        (s = r.onError) === null || s === void 0 || s.call(r, i);
+      },
+      complete() {
+        var i;
+        (i = r.onComplete) === null || i === void 0 || i.call(r);
+      }
+    });
+  }
+}, It = /* @__PURE__ */ Symbol.for("trpc_untypedClient"), Dt = {
+  query: "query",
+  mutate: "mutation",
+  subscribe: "subscription"
+}, Lt = /* @__PURE__ */ o((e) => Dt[e], "clientCallTypeToProcedureType");
+function Fe(e) {
+  const t = yt(({ path: r, args: n }) => {
+    const i = [...r], s = Lt(i.pop()), c = i.join(".");
+    return e[s](c, ...n);
+  });
+  return vt((r) => r === It ? e : t[r]);
+}
+o(Fe, "createTRPCClientProxy");
+function $(e) {
+  const t = new At(e);
+  return Fe(t);
+}
+o($, "createTRPCClient");
+m(v(), 1);
+m(v(), 1);
+var Nt = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(e, t) {
+  function r(i) {
+    var s, c, a, u = 2;
+    for (typeof Symbol < "u" && (c = Symbol.asyncIterator, a = Symbol.iterator); u--; ) {
+      if (c && (s = i[c]) != null) return s.call(i);
+      if (a && (s = i[a]) != null) return new n(s.call(i));
+      c = "@@asyncIterator", a = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  o(r, "_asyncIterator$1");
+  function n(i) {
+    function s(c) {
+      if (Object(c) !== c) return Promise.reject(new TypeError(c + " is not an object."));
+      var a = c.done;
+      return Promise.resolve(c.value).then(function(u) {
+        return {
+          value: u,
+          done: a
+        };
+      });
+    }
+    return o(s, "AsyncFromSyncIteratorContinuation"), n = /* @__PURE__ */ o(function(a) {
+      this.s = a, this.n = a.next;
+    }, "AsyncFromSyncIterator$1"), n.prototype = {
+      s: null,
+      n: null,
+      next: /* @__PURE__ */ o(function() {
+        return s(this.n.apply(this.s, arguments));
+      }, "next"),
+      return: /* @__PURE__ */ o(function(a) {
+        var u = this.s.return;
+        return u === void 0 ? Promise.resolve({
+          value: a,
+          done: !0
+        }) : s(u.apply(this.s, arguments));
+      }, "_return"),
+      throw: /* @__PURE__ */ o(function(a) {
+        var u = this.s.return;
+        return u === void 0 ? Promise.reject(a) : s(u.apply(this.s, arguments));
+      }, "_throw")
+    }, new n(i);
+  }
+  o(n, "AsyncFromSyncIterator"), t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+m(Nt(), 1);
+m(v(), 1);
+var Wt = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(e, t) {
+  function r() {
+    var n = typeof SuppressedError == "function" ? SuppressedError : function(a, u) {
+      var l = Error();
+      return l.name = "SuppressedError", l.error = a, l.suppressed = u, l;
+    }, i = {}, s = [];
+    function c(a, u) {
+      if (u != null) {
+        if (Object(u) !== u) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (a) var l = u[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
+        if (l === void 0 && (l = u[Symbol.dispose || Symbol.for("Symbol.dispose")], a)) var d = l;
+        if (typeof l != "function") throw new TypeError("Object is not disposable.");
+        d && (l = /* @__PURE__ */ o(function() {
+          try {
+            d.call(u);
+          } catch (f) {
+            return Promise.reject(f);
+          }
+        }, "o$1")), s.push({
+          v: u,
+          d: l,
+          a
+        });
+      } else a && s.push({
+        d: u,
+        a
+      });
+      return u;
+    }
+    return o(c, "using"), {
+      e: i,
+      u: c.bind(null, !1),
+      a: c.bind(null, !0),
+      d: /* @__PURE__ */ o(function() {
+        var u, l = this.e, d = 0;
+        function p() {
+          for (; u = s.pop(); ) try {
+            if (!u.a && d === 1) return d = 0, s.push(u), Promise.resolve().then(p);
+            if (u.d) {
+              var h = u.d.call(u.v);
+              if (u.a) return d |= 2, Promise.resolve(h).then(p, f);
+            } else d |= 1;
+          } catch (y) {
+            return f(y);
+          }
+          if (d === 1) return l !== i ? Promise.reject(l) : Promise.resolve();
+          if (l !== i) throw l;
+        }
+        o(p, "next");
+        function f(h) {
+          return l = l !== i ? new n(h, l) : h, p();
+        }
+        return o(f, "err"), p();
+      }, "d")
+    };
+  }
+  o(r, "_usingCtx"), t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), ze = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(e, t) {
+  function r(n, i) {
+    this.v = n, this.k = i;
+  }
+  o(r, "_OverloadYield"), t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Bt = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(e, t) {
+  var r = ze();
+  function n(i) {
+    return new r(i, 0);
+  }
+  o(n, "_awaitAsyncGenerator$1"), t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Ft = _({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(e, t) {
+  var r = ze();
+  function n(s) {
+    return function() {
+      return new i(s.apply(this, arguments));
+    };
+  }
+  o(n, "_wrapAsyncGenerator$1");
+  function i(s) {
+    var c, a;
+    function u(d, p) {
+      try {
+        var f = s[d](p), h = f.value, y = h instanceof r;
+        Promise.resolve(y ? h.v : h).then(function(b) {
+          if (y) {
+            var w = d === "return" ? "return" : "next";
+            if (!h.k || b.done) return u(w, b);
+            b = s[w](b).value;
+          }
+          l(f.done ? "return" : "normal", b);
+        }, function(b) {
+          u("throw", b);
+        });
+      } catch (b) {
+        l("throw", b);
+      }
+    }
+    o(u, "resume");
+    function l(d, p) {
+      switch (d) {
+        case "return":
+          c.resolve({
+            value: p,
+            done: !0
+          });
+          break;
+        case "throw":
+          c.reject(p);
+          break;
+        default:
+          c.resolve({
+            value: p,
+            done: !1
+          });
+      }
+      (c = c.next) ? u(c.key, c.arg) : a = null;
+    }
+    o(l, "settle"), this._invoke = function(d, p) {
+      return new Promise(function(f, h) {
+        var y = {
+          key: d,
+          arg: p,
+          resolve: f,
+          reject: h,
+          next: null
+        };
+        a ? a = a.next = y : (c = a = y, u(d, p));
+      });
+    }, typeof s.return != "function" && (this.return = void 0);
+  }
+  o(i, "AsyncGenerator"), i.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, i.prototype.next = function(s) {
+    return this._invoke("next", s);
+  }, i.prototype.throw = function(s) {
+    return this._invoke("throw", s);
+  }, i.prototype.return = function(s) {
+    return this._invoke("return", s);
+  }, t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+m(Wt(), 1);
+m(Bt(), 1);
+m(Ft(), 1);
+m(v(), 1);
+var zt = 1e4, $t = 3e3, Gt = 2e3, Ut = 3e4, Ht = class {
+  static {
+    o(this, "System");
+  }
+  serverUrl;
+  useWs;
+  baseRetryMs;
+  maxRetryMs;
+  onConnectionChange;
+  token;
+  _trpcClient;
+  _wsClient = null;
+  // Mirror — owns binding cache + state mirror + lifecycle listeners.
+  // Lazily initialised on `init()`. Subsequent `reconnect()` disposes
+  // the old mirror and rebuilds against the new tRPC client.
+  mirror = null;
+  mirrorInit = null;
+  // Transport-readiness probe state. `connected` flips true the first
+  // time `auth.me` succeeds against the current tRPC client; resets
+  // on every `reconnect()` / `close()` so the next consumer waits for
+  // a fresh handshake before issuing queries.
+  connected = !1;
+  connectedPromise = null;
+  // System-cap namespaces — populated in the constructor from
+  // `createSystemProxy(api)`. Each namespace is a `Pick<InferProvider<typeof cap>, …>`
+  // shape generated by `scripts/generate-system-proxy.ts`.
+  _systemProxy;
+  // Connection-version + listener bookkeeping for the admin UI's
+  // reconnect watchdog.
+  _connectionVersion = 0;
+  connectionListeners = /* @__PURE__ */ new Set();
+  constructor(e) {
+    this.serverUrl = e.serverUrl.replace(/\/+$/, ""), this.token = e.token;
+    const t = typeof window < "u";
+    this.useWs = e.useWebSocket ?? t, this.onConnectionChange = e.onConnectionChange, this.baseRetryMs = e.retryDelayMs ?? Gt, this.maxRetryMs = e.maxRetryDelayMs ?? Ut, this._trpcClient = this.buildTrpcClient(), this._systemProxy = ee(this._trpcClient);
+  }
+  // ── Connection state ─────────────────────────────────────────────
+  get connectionVersion() {
+    return this._connectionVersion;
+  }
+  /**
+  * Subscribe to connection-state transitions. Called with `('connected'
+  * | 'disconnected' | 'connecting', version)` whenever the SDK opens,
+  * closes, or starts a manual reconnect. Listener errors are swallowed
+  * so a misbehaving consumer cannot break the SDK's event loop.
+  */
+  subscribeConnectionEvents(e) {
+    return this.connectionListeners.add(e), () => {
+      this.connectionListeners.delete(e);
+    };
+  }
+  emitConnectionEvent(e) {
+    try {
+      this.onConnectionChange?.(e);
+    } catch {
+    }
+    for (const t of this.connectionListeners)
+      try {
+        t(e, this._connectionVersion);
+      } catch {
+      }
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────
+  /**
+  * Wait until the underlying tRPC transport is connected AND the
+  * server has responded to a cheap auth round-trip (`auth.me`). This
+  * is the canonical "ready to issue queries" gate.
+  *
+  * Why a probe, not just `ws.readyState === OPEN`?
+  *   The WS handshake completes asynchronously: tRPC's `wsLink`
+  *   queues outgoing messages and only flushes them after `open()`
+  *   resolves (post `connectionParams` send). On the server, the
+  *   tRPC context is created lazily once the connectionParams
+  *   message is received. A query fired between WS-open and
+  *   connection-params-processed is technically queued by tRPC, but
+  *   the auth context for that query is only resolved once the
+  *   handshake message is decoded server-side. A probe round-trip is
+  *   the safest way to confirm both sides have agreed on the auth
+  *   identity before the React tree starts firing parallel queries
+  *   (which can otherwise land before any addon-side service
+  *   discovery has settled, returning empty results that get cached).
+  *
+  * Idempotent — concurrent callers await the same in-flight Promise.
+  * Bounded by `timeoutMs` (default 15s) — beyond which a
+  * `Error('System.awaitConnected: probe timed out after Xms')` is
+  * thrown so the host can render a clear error state instead of
+  * hanging on a bricked socket.
+  */
+  async awaitConnected(e) {
+    if (this.connected) return;
+    if (this.connectedPromise) return this.connectedPromise;
+    const t = e ?? 15e3;
+    this.connectedPromise = (async () => {
+      const r = this._trpcClient.auth.me.query();
+      Number.isFinite(t) ? await new Promise((n, i) => {
+        const s = setTimeout(() => i(new Error(`System.awaitConnected: probe timed out after ${t}ms`)), t);
+        r.then(() => {
+          clearTimeout(s), n();
+        }, (c) => {
+          clearTimeout(s), i(c instanceof Error ? c : new Error(String(c)));
+        });
+      }) : await r, this.connected = !0;
+    })();
+    try {
+      await this.connectedPromise;
+    } finally {
+      this.connectedPromise = null;
+    }
+  }
+  /**
+  * Warm-boot the device mirror. Awaits the transport probe first
+  * (`awaitConnected`) so the three mirror round-trips
+  * (`getAllBindings` + `getAllSnapshots` + `listAll`) cannot race
+  * against the WS auth handshake. Subsequent `getDevice(id)` calls
+  * are sync; live `device.*` event subscriptions keep the caches
+  * fresh.
+  *
+  * Idempotent — concurrent callers await the same in-flight Promise.
+  */
+  async init(e) {
+    if (this.mirror?.isReady()) return;
+    if (this.mirrorInit) return this.mirrorInit;
+    const t = new rt(this._trpcClient);
+    return this.mirror = t, this.mirrorInit = (async () => {
+      await this.awaitConnected(e), await t.init(e);
+    })().finally(() => {
+      this.mirrorInit = null;
+    }), this.mirrorInit;
+  }
+  /** Promise that resolves once `init()` has completed. */
+  async awaitReady() {
+    if (!this.mirror?.isReady())
+      return this.mirrorInit ? this.mirrorInit : this.init();
+  }
+  /** True after `init()` resolves. */
+  isReady() {
+    return this.mirror?.isReady() ?? !1;
+  }
+  /** True after the transport probe has succeeded at least once. */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+  * Force a fresh WebSocket handshake. Tears down the wsClient + tRPC
+  * client + mirror (the mirror captures the tRPC reference at
+  * construction time and would otherwise dispatch through a closed
+  * client) and rebuilds them. No-op for HTTP transport.
+  */
+  reconnect() {
+    this.useWs && (this.emitConnectionEvent("connecting"), this._wsClient?.close(), this.disposeMirror(), this.connected = !1, this.connectedPromise = null, this._trpcClient = this.buildTrpcClient(), this._systemProxy = ee(this._trpcClient));
+  }
+  /** Tear down WS connection + mirror. The instance is unusable afterwards. */
+  close() {
+    this.disposeMirror(), this.connected = !1, this.connectedPromise = null, this._wsClient?.close();
+  }
+  disposeMirror() {
+    this.mirror?.dispose(), this.mirror = null, this.mirrorInit = null;
+  }
+  // ── Auth ──────────────────────────────────────────────────────────
+  async login(e, t) {
+    const r = await this._trpcClient.auth.login.mutate({
+      username: e,
+      password: t
+    });
+    if (typeof r == "object" && r !== null && "token" in r) {
+      const n = r.token;
+      typeof n == "string" && this.setToken(n);
+    }
+    return r;
+  }
+  async logout() {
+    await this._trpcClient.auth.logout.mutate();
+  }
+  async getMe() {
+    return await this._trpcClient.auth.me.query();
+  }
+  /** Update the auth token (e.g. after login or token refresh). */
+  setToken(e) {
+    this.token = e;
+  }
+  // ── Devices ──────────────────────────────────────────────────────
+  /**
+  * Synchronous snapshot of every device matching the optional filters.
+  * Backed by the `SystemMirror` warm-boot cache — call `init()` first
+  * (or `awaitReady()`) before invoking. Returns an empty array if the
+  * mirror has not yet been booted.
+  *
+  * Each returned proxy has `binding` populated from the mirror's
+  * binding cache (Phase 5 dedup), so consumers no longer need to
+  * make a separate `deviceManager.getBindings` round-trip.
+  */
+  listDevices(e) {
+    return this.mirror ? (e ? this.mirror.query(e) : this.mirror.getAllDevices()).map((r) => this.attachBinding(r)) : [];
+  }
+  /**
+  * Sync lookup by numeric id. `null` if the mirror has not been booted
+  * or the device is unknown.
+  */
+  getDevice(e) {
+    const t = this.mirror?.getDeviceById(e) ?? null;
+    return t ? this.attachBinding(t) : null;
+  }
+  /** Sync lookup by display name (exact match). */
+  getDeviceByName(e) {
+    const t = this.mirror?.getDeviceByName(e) ?? null;
+    return t ? this.attachBinding(t) : null;
+  }
+  /** Sync lookup by stableId. */
+  getDeviceByStableId(e) {
+    const t = this.mirror?.getDeviceByStableId(e) ?? null;
+    return t ? this.attachBinding(t) : null;
+  }
+  /**
+  * Resolve when a device with `deviceId` becomes available. Resolves
+  * immediately if already known; rejects with a timeout error
+  * otherwise (default 30s).
+  */
+  async waitForDevice(e, t) {
+    this.mirror || await this.init();
+    const r = await this.mirror.waitForDevice(e, t ?? 3e4);
+    return this.attachBinding(r);
+  }
+  /** Subscribe to `device.registered` events. */
+  onDeviceAdded(e) {
+    if (!this.mirror)
+      throw new Error("System.onDeviceAdded: call init() before subscribing");
+    return this.mirror.onDeviceAdded(e);
+  }
+  /** Subscribe to `device.unregistered` events. */
+  onDeviceRemoved(e) {
+    if (!this.mirror)
+      throw new Error("System.onDeviceRemoved: call init() before subscribing");
+    return this.mirror.onDeviceRemoved(e);
+  }
+  /**
+  * Patch the proxy's `binding` field from the mirror's cache. The
+  * generated `createDeviceProxy()` already sets `binding` to the
+  * binding it was constructed with — this is a defensive overwrite
+  * that uses the latest cached entry in case a `binding-changed`
+  * event landed between proxy creation and access.
+  */
+  attachBinding(e) {
+    const t = this.lookupBinding(e.deviceId);
+    if (t === e.binding) return e;
+    const r = e;
+    return r.binding = t, e;
+  }
+  /** Fetch the latest cached binding from the mirror, or `null`. */
+  lookupBinding(e) {
+    return this.mirror ? this.mirror.getDeviceById(e)?.binding ?? null : null;
+  }
+  // ── System caps ──────────────────────────────────────────────────
+  //
+  // One getter per `scope: 'system'` capability. The actual surface
+  // comes from `createSystemProxy(api)` (codegen). Adding a new
+  // system cap regenerates the proxy and the new namespace surfaces
+  // automatically via `system.<newCap>.<method>(input)`.
+  get addonPages() {
+    return this._systemProxy.addonPages;
+  }
+  get addonSettings() {
+    return this._systemProxy.addonSettings;
+  }
+  get alerts() {
+    return this._systemProxy.alerts;
+  }
+  get audioAnalyzer() {
+    return this._systemProxy.audioAnalyzer;
+  }
+  get audioCodec() {
+    return this._systemProxy.audioCodec;
+  }
+  get backup() {
+    return this._systemProxy.backup;
+  }
+  get decoder() {
+    return this._systemProxy.decoder;
+  }
+  get deviceManager() {
+    return this._systemProxy.deviceManager;
+  }
+  get deviceProvider() {
+    return this._systemProxy.deviceProvider;
+  }
+  get deviceState() {
+    return this._systemProxy.deviceState;
+  }
+  get metricsProvider() {
+    return this._systemProxy.metricsProvider;
+  }
+  get notificationOutput() {
+    return this._systemProxy.notificationOutput;
+  }
+  get pipelineExecutor() {
+    return this._systemProxy.pipelineExecutor;
+  }
+  get pipelineOrchestrator() {
+    return this._systemProxy.pipelineOrchestrator;
+  }
+  get pipelineRunner() {
+    return this._systemProxy.pipelineRunner;
+  }
+  get platformProbe() {
+    return this._systemProxy.platformProbe;
+  }
+  get recordingEngine() {
+    return this._systemProxy.recordingEngine;
+  }
+  get settingsStore() {
+    return this._systemProxy.settingsStore;
+  }
+  get storage() {
+    return this._systemProxy.storage;
+  }
+  get streamBroker() {
+    return this._systemProxy.streamBroker;
+  }
+  get turnProvider() {
+    return this._systemProxy.turnProvider;
+  }
+  get userManagement() {
+    return this._systemProxy.userManagement;
+  }
+  // ── Live events ──────────────────────────────────────────────────
+  /**
+  * Subscribe to a single event category. Returns an unsubscribe
+  * handle. Errors thrown by the listener are swallowed so a single
+  * misbehaving consumer cannot tear down the WS subscription.
+  *
+  * Categories should be values from the `EventCategory` enum
+  * (`@camstack/types`) — passing a raw string works for forward-compat
+  * but loses type safety. The SDK forwards the value verbatim to the
+  * server's `live.onEvent` subscription.
+  */
+  subscribeEvent(e, t) {
+    const r = this._trpcClient.live.onEvent.subscribe({
+      category: e
+    }, {
+      onData: /* @__PURE__ */ o((n) => {
+        try {
+          t(n);
+        } catch {
+        }
+      }, "onData")
+    });
+    return () => {
+      try {
+        r.unsubscribe();
+      } catch {
+      }
+    };
+  }
+  // ── Escape hatches ───────────────────────────────────────────────
+  //
+  // Kept public so the ui-library `<TrpcProvider>` can seed React
+  // Query with the same WebSocket connection during Phase 2. Phase 4
+  // is expected to revisit whether either field can be hidden.
+  /** Direct tRPC client. Read once per call; rebuilt on `reconnect()`. */
+  get trpcClient() {
+    return this._trpcClient;
+  }
+  /**
+  * Underlying WSClient (or `null` for HTTP transport). Used by
+  * advanced consumers that need direct access to the WebSocket
+  * (e.g. for keep-alive metrics). Rebuilt on `reconnect()`.
+  */
+  get wsClient() {
+    return this._wsClient;
+  }
+  // ── Internals ────────────────────────────────────────────────────
+  buildTrpcClient() {
+    const e = /* @__PURE__ */ o(() => {
+      const t = {};
+      return this.token && (t.Authorization = `Bearer ${this.token}`), t;
+    }, "headers");
+    if (this.useWs) {
+      const t = this.serverUrl.replace(/^http/, "ws") + "/trpc", r = this.baseRetryMs, n = this.maxRetryMs;
+      return this._wsClient = We({
+        url: t,
+        connectionParams: /* @__PURE__ */ o(() => ({
+          token: this.token
+        }), "connectionParams"),
+        retryDelayMs: /* @__PURE__ */ o((i) => Math.min(r * Math.pow(2, i), n), "retryDelayMs"),
+        keepAlive: {
+          enabled: !0,
+          intervalMs: zt,
+          pongTimeoutMs: $t
+        },
+        onOpen: /* @__PURE__ */ o(() => {
+          this._connectionVersion += 1, this.emitConnectionEvent("connected");
+        }, "onOpen"),
+        onClose: /* @__PURE__ */ o(() => {
+          this.emitConnectionEvent("disconnected");
+        }, "onClose")
+      }), $({
+        links: [
+          Be({
+            client: this._wsClient,
+            transformer: Q
+          })
+        ]
+      });
+    }
+    return this._wsClient = null, $({
+      links: [
+        je({
+          url: `${this.serverUrl}/trpc`,
+          headers: e,
+          transformer: Q
+        })
+      ]
+    });
+  }
+};
+function Vt(e) {
+  return new Ht(e);
+}
+o(Vt, "createSystem");
+var Kt = /* @__PURE__ */ (function(e) {
+  return e.Motion = "motion", e.Person = "person", e.Vehicle = "vehicle", e.Animal = "animal", e.Audio = "audio", e.Face = "face", e.Plate = "plate", e.Package = "package", e.Doorbell = "doorbell", e.Sensor = "sensor", e;
+})({}), $e = [
+  "animal",
+  "dog_cat",
+  "dog",
+  "cat",
+  "horse",
+  "sheep",
+  "cow",
+  "elephant",
+  "bear",
+  "zebra",
+  "giraffe",
+  "mouse",
+  "rabbit",
+  "deer",
+  "lion",
+  "tiger",
+  "bird",
+  "eagle",
+  "owl",
+  "pigeon",
+  "fish",
+  "whale",
+  "dolphin",
+  "snake",
+  "turtle",
+  "lizard"
+], Ge = [
+  "person",
+  "people",
+  "pedestrian",
+  "rider",
+  "driver",
+  "cyclist",
+  "skier",
+  "skateboarder",
+  "face",
+  "hand",
+  "head",
+  "body"
+], Ue = [
+  "vehicle",
+  "car",
+  "truck",
+  "bus",
+  "motorcycle",
+  "bicycle",
+  "van",
+  "ambulance",
+  "police_car",
+  "fire_truck",
+  "train",
+  "subway",
+  "tram",
+  "airplane",
+  "boat",
+  "ship",
+  "helicopter"
+], He = [
+  "face",
+  "eyes",
+  "nose",
+  "mouth",
+  "ears",
+  "eyebrows",
+  "left_eye",
+  "right_eye",
+  "pupil",
+  "iris",
+  "eyelid",
+  "eye_corner",
+  "upper_lip",
+  "lower_lip",
+  "teeth",
+  "chin",
+  "cheek",
+  "forehead",
+  "jaw",
+  "glasses",
+  "sunglasses",
+  "facial_hair",
+  "beard",
+  "mustache",
+  "facial_landmark",
+  "facial_keypoint"
+], Ve = [
+  "plate",
+  "license_plate",
+  "front_plate",
+  "rear_plate",
+  "motorcycle_plate",
+  "temporary_plate",
+  "dealer_plate",
+  "licensePlate",
+  "plate_number",
+  "plate_character",
+  "plate_digit",
+  "plate_letter",
+  "plate_symbol",
+  "plate_region",
+  "plate_country_identifier",
+  "plate_frame",
+  "plate_bolt",
+  "plate_sticker",
+  "plate_validation_tag",
+  "damaged_plate",
+  "obscured_plate",
+  "dirty_plate"
+], Ke = [
+  "motion",
+  "movement",
+  "other"
+], Ye = [
+  "package",
+  "packet"
+], Je = [
+  "audio"
+], Xe = [
+  "speech",
+  "scream",
+  "babbling",
+  "yell",
+  "bellow",
+  "whoop",
+  "whispering",
+  "laughter",
+  "snicker",
+  "crying",
+  "cry",
+  "sigh",
+  "singing",
+  "choir",
+  "chant",
+  "mantra",
+  "child_singing",
+  "rapping",
+  "humming",
+  "groan",
+  "grunt",
+  "whistling",
+  "breathing",
+  "wheeze",
+  "snoring",
+  "gasp",
+  "pant",
+  "snort",
+  "cough",
+  "throat_clearing",
+  "sneeze",
+  "sniff",
+  "cheering",
+  "applause",
+  "chatter",
+  "crowd",
+  "children_playing",
+  "bark",
+  "yip",
+  "howl",
+  "bow-wow",
+  "growling",
+  "whimper_dog",
+  "purr",
+  "meow",
+  "hiss",
+  "caterwaul",
+  "pets",
+  "livestock",
+  "doorbell",
+  "ding-dong",
+  "door",
+  "slam",
+  "knock",
+  "alarm",
+  "telephone",
+  "music",
+  "dog",
+  "dogs"
+], Ze = [
+  "doorbell",
+  "ring"
+], Qe = [
+  "lock",
+  "binary",
+  "flood",
+  "entry",
+  "door",
+  "leak",
+  "door_open",
+  "flooded",
+  "entry_open"
+], et = {
+  ...$e.reduce((e, t) => ({
+    ...e,
+    [t]: "animal"
+  }), {}),
+  ...Ge.reduce((e, t) => ({
+    ...e,
+    [t]: "person"
+  }), {}),
+  ...Ue.reduce((e, t) => ({
+    ...e,
+    [t]: "vehicle"
+  }), {}),
+  ...Ke.reduce((e, t) => ({
+    ...e,
+    [t]: "motion"
+  }), {}),
+  ...Ye.reduce((e, t) => ({
+    ...e,
+    [t]: "package"
+  }), {}),
+  ...He.reduce((e, t) => ({
+    ...e,
+    [t]: "face"
+  }), {}),
+  ...Ve.reduce((e, t) => ({
+    ...e,
+    [t]: "plate"
+  }), {}),
+  ...Je.reduce((e, t) => ({
+    ...e,
+    [t]: "audio"
+  }), {}),
+  ...Xe.reduce((e, t) => ({
+    ...e,
+    [t]: "audio"
+  }), {}),
+  ...Ze.reduce((e, t) => ({
+    ...e,
+    [t]: "doorbell"
+  }), {}),
+  ...Qe.reduce((e, t) => ({
+    ...e,
+    [t]: "sensor"
+  }), {})
+}, Yt = /* @__PURE__ */ o((e) => He.includes(e), "isFaceClassname"), Jt = /* @__PURE__ */ o((e) => Ve.includes(e), "isPlateClassname"), dr = /* @__PURE__ */ o((e) => $e.includes(e), "isAnimalClassname"), pr = /* @__PURE__ */ o((e) => Ge.includes(e), "isPersonClassname"), fr = /* @__PURE__ */ o((e) => Ue.includes(e), "isVehicleClassname"), hr = /* @__PURE__ */ o((e) => Ke.includes(e), "isMotionClassname"), mr = /* @__PURE__ */ o((e) => Ze.includes(e), "isDoorbellClassname"), yr = /* @__PURE__ */ o((e) => Ye.includes(e), "isPackageClassname"), vr = /* @__PURE__ */ o((e) => Je.includes(e) || Xe.includes(e), "isAudioClassname"), br = /* @__PURE__ */ o((e) => Qe.includes(e), "isSensorLabelClassname"), gr = /* @__PURE__ */ o((e) => Yt(e) || Jt(e), "isLabelDetection"), _r = /* @__PURE__ */ o((e) => et[e], "getParentClass"), Pr = /* @__PURE__ */ o((e) => {
+  const { className: t } = e, r = {
+    face: "person",
+    plate: "vehicle"
+  }, n = et[t];
+  return n && n !== t ? n : r[t];
+}, "getParentDetectionClass"), Xt = Object.values(Kt), G = Xt.filter((e) => e !== "motion"), tt = [
+  "person",
+  "doorbell",
+  "package"
+], Zt = [
+  ...tt,
+  "vehicle",
+  "animal",
+  "audio",
+  "face",
+  "plate"
+], Qt = [
+  ...G
+];
+function er(e, t) {
+  switch (e) {
+    case "critical":
+      return tt;
+    case "important":
+      return Zt;
+    case "all":
+      return Qt;
+    case "custom":
+      return t?.length ? t : G;
+    default:
+      return G;
+  }
+}
+o(er, "getClassesForTimelinePreset");
+var se = {
+  // Scrypted PascalCase
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Outlet: "switch",
+  // Home Assistant lowercase domains
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  media_player: "media_player",
+  script: "script"
+}, wr = {
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  binary_sensor: "sensor",
+  media_player: "media_player",
+  script: "script",
+  climate: "climate",
+  camera: "camera",
+  fan: "fan",
+  vacuum: "vacuum",
+  automation: "automation",
+  scene: "scene",
+  input_number: "sensor",
+  person: "person",
+  device_tracker: "tracker",
+  weather: "weather",
+  water_heater: "climate"
+}, xr = {
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Camera: "camera",
+  Doorbell: "doorbell",
+  Fan: "fan",
+  Outlet: "switch"
+};
+function tr(e) {
+  const t = se[e];
+  if (t) return t;
+  const r = e.toLowerCase();
+  return se[r] ?? null;
+}
+o(tr, "getCanonicalDeviceType");
+var rr = [
+  "Entry",
+  "Light",
+  "Switch",
+  "Lock",
+  "SecuritySystem",
+  "Buttons",
+  "WindowCovering",
+  "Siren",
+  "Sensor",
+  "Select",
+  "Program"
+], Sr = new Set(rr), nr = [
+  "light",
+  "switch",
+  "input_boolean",
+  "cover",
+  "lock",
+  "alarm_control_panel",
+  "input_button",
+  "button",
+  "input_select",
+  "select",
+  "siren",
+  "media_player",
+  "script"
+], Cr = new Set(nr), Z = [
+  {
+    id: "liveStream",
+    label: "Live Stream",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !0
+    },
+    adapterMethod: "getLiveStream"
+  },
+  {
+    id: "multiResolution",
+    label: "Multi-Resolution",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getResolutions"
+  },
+  {
+    id: "motion",
+    label: "Motion Detection",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getMotion"
+  },
+  {
+    id: "objectDetection",
+    label: "Object Detection",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getObjectDetections"
+  },
+  {
+    id: "audioVolume",
+    label: "Audio Level",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getAudioVolume"
+  },
+  {
+    id: "audioVolumes",
+    label: "Audio Volumes (dBFS)",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getAudioVolumes"
+  },
+  {
+    id: "ptz",
+    label: "PTZ Control",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getPTZ"
+  },
+  {
+    id: "intercom",
+    label: "Intercom (Mic)",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getIntercomSupport"
+  },
+  {
+    id: "deviceStatus",
+    label: "Device Status",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getStatus"
+  },
+  {
+    id: "timeline",
+    label: "Detection Timeline",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getCameraDayData"
+  },
+  {
+    id: "clusteredTimeline",
+    label: "Clustered Timeline",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    requiresBackend: !0,
+    adapterMethod: "getClusteredDayData"
+  },
+  {
+    id: "detectionClasses",
+    label: "Detection Classes",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getDetectionClasses"
+  },
+  {
+    id: "videoClips",
+    label: "Video Clips",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getVideoClips"
+  },
+  {
+    id: "nvrPlayback",
+    label: "NVR Playback",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getNvrPlaybackSupported"
+  },
+  {
+    id: "nvrScrub",
+    label: "NVR Scrub/Seek",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "seekRecordingStream"
+  },
+  {
+    id: "recordingThumbnail",
+    label: "Recording Thumbnails",
+    sources: {
+      frigate: !0,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "getRecordingStreamThumbnail"
+  },
+  {
+    id: "nvrSeekToLive",
+    label: "Seek to Live",
+    sources: {
+      frigate: !1,
+      scrypted: !0,
+      rtsp: !1
+    },
+    adapterMethod: "seekNvrToLive"
+  }
+];
+function ir(e, t, r) {
+  const n = Z.find((i) => i.id === e);
+  return !(!n || !n.sources[t] || n.platforms && n.platforms[r] === !1);
+}
+o(ir, "isFeatureAvailable");
+function or(e) {
+  return Z.filter((t) => t.sources[e]);
+}
+o(or, "getSourceFeatures");
+function sr() {
+  return Z.filter((e) => e.requiresBackend);
+}
+o(sr, "getBackendRequiredFeatures");
+function ar(e, t, r) {
+  if (e.length === 0) return null;
+  const n = t.viewportWidth * t.viewportHeight * (t.pixelRatio ?? 1), i = t.bandwidthMbps ?? 100, s = t.packetLoss ?? 0, c = t.rttMs ?? 50;
+  let a = "high";
+  t.maxResolution === "low" || t.isCellular || i < 1 || s > 0.05 ? a = "low" : t.maxResolution === "medium" || i < 5 || n < 5e5 || c > 200 ? a = "medium" : (t.maxResolution === "high" || n > 2e6) && (a = "high");
+  const u = {
+    main: "high",
+    sub: "medium",
+    ext: "low"
+  }, l = r ?? "native", d = e.map((f) => {
+    let h = 0;
+    const y = u[f.profile] ?? "medium";
+    if (y === a ? h += 100 : (a === "high" && y === "medium" || a === "medium" && y === "high" || a === "medium" && y === "low" || a === "low" && y === "medium") && (h += 50), f.transport === l ? h += 30 : f.transport === "native" ? h += 20 : f.transport === "rtsp" ? h += 15 : f.transport === "rtmp" && (h += 10), f.metadata?.width && f.metadata?.height) {
+      const w = f.metadata.width * f.metadata.height / Math.max(n, 1);
+      w >= 0.8 && w <= 2 ? h += 25 : w >= 0.5 && w <= 3 && (h += 15), w > 4 && i < 10 && (h -= 20);
+    }
+    return f.metadata?.codec && (i < 5 && f.metadata.codec.includes("265") && (h += 10), i >= 10 && f.metadata.codec.includes("264") && (h += 5)), {
+      ...f,
+      score: h,
+      targetTier: a
+    };
+  });
+  d.sort((f, h) => h.score - f.score);
+  const p = d[0];
+  return {
+    streamName: p.streamName,
+    profile: p.profile,
+    transport: p.transport,
+    label: p.label,
+    metadata: p.metadata,
+    reason: `${p.targetTier} quality → ${p.profile}/${p.transport} (score: ${p.score})`
+  };
+}
+o(ar, "selectOptimalStream");
+function cr(e, t) {
+  return t ? 10 : e.isCellular || (e.packetLoss ?? 0) > 0.02 ? 15 : 30;
+}
+o(cr, "getNextEvalInterval");
+/*! Bundled license information:
+
+@trpc/client/dist/httpLink-lG_6juPY.mjs:
+  (* istanbul ignore if -- @preserve *)
+*/
+export {
+  G as DEFAULT_ENABLED_CLASSES,
+  Kt as DetectionClass,
+  nr as ELIGIBLE_HA_DOMAINS,
+  Cr as ELIGIBLE_HA_DOMAINS_SET,
+  rr as ELIGIBLE_SCRYPTED_DEVICE_TYPES,
+  Sr as ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET,
+  Z as FEATURE_MATRIX,
+  wr as HA_DOMAIN_TYPE_MAP,
+  se as RAW_TO_CANONICAL,
+  xr as SCRYPTED_TYPE_TO_CANONICAL,
+  Ht as System,
+  Qt as TIMELINE_PRESET_ALL,
+  tt as TIMELINE_PRESET_CRITICAL,
+  Zt as TIMELINE_PRESET_IMPORTANT,
+  $e as animalClasses,
+  Je as audioClasses,
+  Xe as audioLabelClasses,
+  Vt as createSystem,
+  Xt as defaultDetectionClasses,
+  et as detectionClassesDefaultMap,
+  Ze as doorbellClasses,
+  He as faceClasses,
+  sr as getBackendRequiredFeatures,
+  tr as getCanonicalDeviceType,
+  er as getClassesForTimelinePreset,
+  cr as getNextEvalInterval,
+  _r as getParentClass,
+  Pr as getParentDetectionClass,
+  or as getSourceFeatures,
+  dr as isAnimalClassname,
+  vr as isAudioClassname,
+  mr as isDoorbellClassname,
+  Yt as isFaceClassname,
+  ir as isFeatureAvailable,
+  gr as isLabelDetection,
+  hr as isMotionClassname,
+  yr as isPackageClassname,
+  pr as isPersonClassname,
+  Jt as isPlateClassname,
+  br as isSensorLabelClassname,
+  fr as isVehicleClassname,
+  Ve as licensePlateClasses,
+  Ke as motionClasses,
+  Ye as packageClasses,
+  Ge as personClasses,
+  ar as selectOptimalStream,
+  Qe as sensorLabelClasses,
+  Ue as vehicleClasses
+};