rails-profiler 0.27.0 → 0.28.0

data/app/assets/builds/profiler.js

@@ -1,5 +1,22 @@
 "use strict";
 (() => {
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+  var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+  var __privateWrapper = (obj, member, setter, getter) => ({
+    set _(value) {
+      __privateSet(obj, member, value, setter);
+    },
+    get _() {
+      return __privateGet(obj, member, getter);
+    }
+  });
+
   // node_modules/preact/dist/preact.module.js
   var n;
   var l;
@@ -68,8 +85,8 @@
     }
   }
   function P(n2, l3, u4, t3, i3, r3, o3, e3, f4, c3, s3) {
-    var a3, h3, y3, d3, w3, g2, _2, m3 = t3 && t3.__k || v, b = l3.length;
-    for (f4 = A(u4, l3, m3, f4, b), a3 = 0; a3 < b; a3++) null != (y3 = u4.__k[a3]) && (h3 = -1 != y3.__i && m3[y3.__i] || p, y3.__i = a3, g2 = z(n2, y3, h3, i3, r3, o3, e3, f4, c3, s3), d3 = y3.__e, y3.ref && h3.ref != y3.ref && (h3.ref && D(h3.ref, null, y3), s3.push(y3.ref, y3.__c || d3, y3)), null == w3 && null != d3 && (w3 = d3), (_2 = !!(4 & y3.__u)) || h3.__k === y3.__k ? f4 = H(y3, f4, n2, _2) : "function" == typeof y3.type && void 0 !== g2 ? f4 = g2 : d3 && (f4 = d3.nextSibling), y3.__u &= -7);
+    var a3, h3, y3, d3, w3, g2, _3, m3 = t3 && t3.__k || v, b = l3.length;
+    for (f4 = A(u4, l3, m3, f4, b), a3 = 0; a3 < b; a3++) null != (y3 = u4.__k[a3]) && (h3 = -1 != y3.__i && m3[y3.__i] || p, y3.__i = a3, g2 = z(n2, y3, h3, i3, r3, o3, e3, f4, c3, s3), d3 = y3.__e, y3.ref && h3.ref != y3.ref && (h3.ref && D(h3.ref, null, y3), s3.push(y3.ref, y3.__c || d3, y3)), null == w3 && null != d3 && (w3 = d3), (_3 = !!(4 & y3.__u)) || h3.__k === y3.__k ? f4 = H(y3, f4, n2, _3) : "function" == typeof y3.type && void 0 !== g2 ? f4 = g2 : d3 && (f4 = d3.nextSibling), y3.__u &= -7);
     return u4.__e = w3, f4;
   }
   function A(n2, l3, u4, t3, i3) {
@@ -130,11 +147,11 @@
     };
   }
   function z(n2, u4, t3, i3, r3, o3, e3, f4, c3, s3) {
-    var a3, h3, p3, y3, _2, m3, b, S2, C3, M2, $2, I2, A3, H2, L, T3 = u4.type;
+    var a3, h3, p3, y3, _3, m3, b, S2, C3, M2, $2, I2, A3, H2, L, T3 = u4.type;
     if (void 0 !== u4.constructor) return null;
     128 & t3.__u && (c3 = !!(32 & t3.__u), o3 = [f4 = u4.__e = t3.__e]), (a3 = l.__b) && a3(u4);
     n: if ("function" == typeof T3) try {
-      if (S2 = u4.props, C3 = T3.prototype && T3.prototype.render, M2 = (a3 = T3.contextType) && i3[a3.__c], $2 = a3 ? M2 ? M2.props.value : a3.__ : i3, t3.__c ? b = (h3 = u4.__c = t3.__c).__ = h3.__E : (C3 ? u4.__c = h3 = new T3(S2, $2) : (u4.__c = h3 = new x(S2, $2), h3.constructor = T3, h3.render = G), M2 && M2.sub(h3), h3.state || (h3.state = {}), h3.__n = i3, p3 = h3.__d = true, h3.__h = [], h3._sb = []), C3 && null == h3.__s && (h3.__s = h3.state), C3 && null != T3.getDerivedStateFromProps && (h3.__s == h3.state && (h3.__s = w({}, h3.__s)), w(h3.__s, T3.getDerivedStateFromProps(S2, h3.__s))), y3 = h3.props, _2 = h3.state, h3.__v = u4, p3) C3 && null == T3.getDerivedStateFromProps && null != h3.componentWillMount && h3.componentWillMount(), C3 && null != h3.componentDidMount && h3.__h.push(h3.componentDidMount);
+      if (S2 = u4.props, C3 = T3.prototype && T3.prototype.render, M2 = (a3 = T3.contextType) && i3[a3.__c], $2 = a3 ? M2 ? M2.props.value : a3.__ : i3, t3.__c ? b = (h3 = u4.__c = t3.__c).__ = h3.__E : (C3 ? u4.__c = h3 = new T3(S2, $2) : (u4.__c = h3 = new x(S2, $2), h3.constructor = T3, h3.render = G), M2 && M2.sub(h3), h3.state || (h3.state = {}), h3.__n = i3, p3 = h3.__d = true, h3.__h = [], h3._sb = []), C3 && null == h3.__s && (h3.__s = h3.state), C3 && null != T3.getDerivedStateFromProps && (h3.__s == h3.state && (h3.__s = w({}, h3.__s)), w(h3.__s, T3.getDerivedStateFromProps(S2, h3.__s))), y3 = h3.props, _3 = h3.state, h3.__v = u4, p3) C3 && null == T3.getDerivedStateFromProps && null != h3.componentWillMount && h3.componentWillMount(), C3 && null != h3.componentDidMount && h3.__h.push(h3.componentDidMount);
       else {
         if (C3 && null == T3.getDerivedStateFromProps && S2 !== y3 && null != h3.componentWillReceiveProps && h3.componentWillReceiveProps(S2, $2), u4.__v == t3.__v || !h3.__e && null != h3.shouldComponentUpdate && false === h3.shouldComponentUpdate(S2, h3.__s, $2)) {
           u4.__v != t3.__v && (h3.props = S2, h3.state = h3.__s, h3.__d = false), u4.__e = t3.__e, u4.__k = t3.__k, u4.__k.some(function(n3) {
@@ -143,14 +160,14 @@
           break n;
         }
         null != h3.componentWillUpdate && h3.componentWillUpdate(S2, h3.__s, $2), C3 && null != h3.componentDidUpdate && h3.__h.push(function() {
-          h3.componentDidUpdate(y3, _2, m3);
+          h3.componentDidUpdate(y3, _3, m3);
         });
       }
       if (h3.context = $2, h3.props = S2, h3.__P = n2, h3.__e = false, I2 = l.__r, A3 = 0, C3) h3.state = h3.__s, h3.__d = false, I2 && I2(u4), a3 = h3.render(h3.props, h3.state, h3.context), v.push.apply(h3.__h, h3._sb), h3._sb = [];
       else do {
         h3.__d = false, I2 && I2(u4), a3 = h3.render(h3.props, h3.state, h3.context), h3.state = h3.__s;
       } while (h3.__d && ++A3 < 25);
-      h3.state = h3.__s, null != h3.getChildContext && (i3 = w(w({}, i3), h3.getChildContext())), C3 && !p3 && null != h3.getSnapshotBeforeUpdate && (m3 = h3.getSnapshotBeforeUpdate(y3, _2)), H2 = null != a3 && a3.type === k && null == a3.key ? q(a3.props.children) : a3, f4 = P(n2, d(H2) ? H2 : [H2], u4, t3, i3, r3, o3, e3, f4, c3, s3), h3.base = u4.__e, u4.__u &= -161, h3.__h.length && e3.push(h3), b && (h3.__E = h3.__ = null);
+      h3.state = h3.__s, null != h3.getChildContext && (i3 = w(w({}, i3), h3.getChildContext())), C3 && !p3 && null != h3.getSnapshotBeforeUpdate && (m3 = h3.getSnapshotBeforeUpdate(y3, _3)), H2 = null != a3 && a3.type === k && null == a3.key ? q(a3.props.children) : a3, f4 = P(n2, d(H2) ? H2 : [H2], u4, t3, i3, r3, o3, e3, f4, c3, s3), h3.base = u4.__e, u4.__u &= -161, h3.__h.length && e3.push(h3), b && (h3.__E = h3.__ = null);
     } catch (n3) {
       if (u4.__v = null, c3 || null != o3) if (n3.then) {
         for (u4.__u |= c3 ? 160 : 128; f4 && 8 == f4.nodeType && f4.nextSibling; ) f4 = f4.nextSibling;
@@ -184,25 +201,25 @@
     return "object" != typeof n2 || null == n2 || n2.__b > 0 ? n2 : d(n2) ? n2.map(q) : w({}, n2);
   }
   function B(u4, t3, i3, r3, o3, e3, f4, c3, s3) {
-    var a3, h3, v3, y3, w3, _2, m3, b = i3.props || p, k3 = t3.props, x2 = t3.type;
-    if ("svg" == x2 ? o3 = "http://www.w3.org/2000/svg" : "math" == x2 ? o3 = "http://www.w3.org/1998/Math/MathML" : o3 || (o3 = "http://www.w3.org/1999/xhtml"), null != e3) {
-      for (a3 = 0; a3 < e3.length; a3++) if ((w3 = e3[a3]) && "setAttribute" in w3 == !!x2 && (x2 ? w3.localName == x2 : 3 == w3.nodeType)) {
+    var a3, h3, v3, y3, w3, _3, m3, b = i3.props || p, k3 = t3.props, x3 = t3.type;
+    if ("svg" == x3 ? o3 = "http://www.w3.org/2000/svg" : "math" == x3 ? o3 = "http://www.w3.org/1998/Math/MathML" : o3 || (o3 = "http://www.w3.org/1999/xhtml"), null != e3) {
+      for (a3 = 0; a3 < e3.length; a3++) if ((w3 = e3[a3]) && "setAttribute" in w3 == !!x3 && (x3 ? w3.localName == x3 : 3 == w3.nodeType)) {
         u4 = w3, e3[a3] = null;
         break;
       }
     }
     if (null == u4) {
-      if (null == x2) return document.createTextNode(k3);
-      u4 = document.createElementNS(o3, x2, k3.is && k3), c3 && (l.__m && l.__m(t3, e3), c3 = false), e3 = null;
+      if (null == x3) return document.createTextNode(k3);
+      u4 = document.createElementNS(o3, x3, k3.is && k3), c3 && (l.__m && l.__m(t3, e3), c3 = false), e3 = null;
     }
-    if (null == x2) b === k3 || c3 && u4.data == k3 || (u4.data = k3);
+    if (null == x3) b === k3 || c3 && u4.data == k3 || (u4.data = k3);
     else {
       if (e3 = e3 && n.call(u4.childNodes), !c3 && null != e3) for (b = {}, a3 = 0; a3 < u4.attributes.length; a3++) b[(w3 = u4.attributes[a3]).name] = w3.value;
       for (a3 in b) w3 = b[a3], "dangerouslySetInnerHTML" == a3 ? v3 = w3 : "children" == a3 || a3 in k3 || "value" == a3 && "defaultValue" in k3 || "checked" == a3 && "defaultChecked" in k3 || F(u4, a3, null, w3, o3);
-      for (a3 in k3) w3 = k3[a3], "children" == a3 ? y3 = w3 : "dangerouslySetInnerHTML" == a3 ? h3 = w3 : "value" == a3 ? _2 = w3 : "checked" == a3 ? m3 = w3 : c3 && "function" != typeof w3 || b[a3] === w3 || F(u4, a3, w3, b[a3], o3);
+      for (a3 in k3) w3 = k3[a3], "children" == a3 ? y3 = w3 : "dangerouslySetInnerHTML" == a3 ? h3 = w3 : "value" == a3 ? _3 = w3 : "checked" == a3 ? m3 = w3 : c3 && "function" != typeof w3 || b[a3] === w3 || F(u4, a3, w3, b[a3], o3);
       if (h3) c3 || v3 && (h3.__html == v3.__html || h3.__html == u4.innerHTML) || (u4.innerHTML = h3.__html), t3.__k = [];
-      else if (v3 && (u4.innerHTML = ""), P("template" == t3.type ? u4.content : u4, d(y3) ? y3 : [y3], t3, i3, r3, "foreignObject" == x2 ? "http://www.w3.org/1999/xhtml" : o3, e3, f4, e3 ? e3[0] : i3.__k && S(i3, 0), c3, s3), null != e3) for (a3 = e3.length; a3--; ) g(e3[a3]);
-      c3 || (a3 = "value", "progress" == x2 && null == _2 ? u4.removeAttribute("value") : null != _2 && (_2 !== u4[a3] || "progress" == x2 && !_2 || "option" == x2 && _2 != b[a3]) && F(u4, a3, _2, b[a3], o3), a3 = "checked", null != m3 && m3 != u4[a3] && F(u4, a3, m3, b[a3], o3));
+      else if (v3 && (u4.innerHTML = ""), P("template" == t3.type ? u4.content : u4, d(y3) ? y3 : [y3], t3, i3, r3, "foreignObject" == x3 ? "http://www.w3.org/1999/xhtml" : o3, e3, f4, e3 ? e3[0] : i3.__k && S(i3, 0), c3, s3), null != e3) for (a3 = e3.length; a3--; ) g(e3[a3]);
+      c3 || (a3 = "value", "progress" == x3 && null == _3 ? u4.removeAttribute("value") : null != _3 && (_3 !== u4[a3] || "progress" == x3 && !_3 || "option" == x3 && _3 != b[a3]) && F(u4, a3, _3, b[a3], o3), a3 = "checked", null != m3 && m3 != u4[a3] && F(u4, a3, m3, b[a3], o3));
     }
     return u4;
   }
@@ -236,6 +253,29 @@
     var r3, o3, e3, f4;
     t3 == document && (t3 = document.documentElement), l.__ && l.__(u4, t3), o3 = (r3 = "function" == typeof i3) ? null : i3 && i3.__k || t3.__k, e3 = [], f4 = [], z(t3, u4 = (!r3 && i3 || t3).__k = _(k, null, [u4]), o3 || p, p, t3.namespaceURI, !r3 && i3 ? [i3] : o3 ? null : t3.firstChild ? n.call(t3.childNodes) : null, e3, !r3 && i3 ? i3 : o3 ? o3.__e : t3.firstChild, r3, f4), V(e3, u4, f4);
   }
+  function R(n2) {
+    function l3(n3) {
+      var u4, t3;
+      return this.getChildContext || (u4 = /* @__PURE__ */ new Set(), (t3 = {})[l3.__c] = this, this.getChildContext = function() {
+        return t3;
+      }, this.componentWillUnmount = function() {
+        u4 = null;
+      }, this.shouldComponentUpdate = function(n4) {
+        this.props.value != n4.value && u4.forEach(function(n5) {
+          n5.__e = true, $(n5);
+        });
+      }, this.sub = function(n4) {
+        u4.add(n4);
+        var l4 = n4.componentWillUnmount;
+        n4.componentWillUnmount = function() {
+          u4 && u4.delete(n4), l4 && l4.call(n4);
+        };
+      }), n3.children;
+    }
+    return l3.__c = "__cC" + h++, l3.__ = n2, l3.Provider = l3.__l = (l3.Consumer = function(n3, l4) {
+      return n3.children(l4);
+    }).contextType = l3, l3;
+  }
   n = v.slice, l = { __e: function(n2, l3, u4, t3) {
     for (var i3, r3, o3; l3 = l3.__; ) if ((i3 = l3.__c) && !i3.__) try {
       if ((r3 = i3.constructor) && null != r3.getDerivedStateFromError && (i3.setState(r3.getDerivedStateFromError(n2)), o3 = i3.__d), null != i3.componentDidCatch && (i3.componentDidCatch(n2, t3 || {}), o3 = i3.__d), o3) return i3.__E = i3;
@@ -254,152 +294,3667 @@
     return n2.__v.__b - l3.__v.__b;
   }, I.__r = 0, f = /(PointerCapture)$|Capture$/i, c = 0, s = O(false), a = O(true), h = 0;
 
-  // node_modules/preact/hooks/dist/hooks.module.js
-  var t2;
-  var r2;
-  var u2;
-  var i2;
-  var o2 = 0;
-  var f2 = [];
-  var c2 = l;
-  var e2 = c2.__b;
-  var a2 = c2.__r;
-  var v2 = c2.diffed;
-  var l2 = c2.__c;
-  var m2 = c2.unmount;
-  var s2 = c2.__;
-  function p2(n2, t3) {
-    c2.__h && c2.__h(r2, n2, o2 || t3), o2 = 0;
-    var u4 = r2.__H || (r2.__H = { __: [], __h: [] });
-    return n2 >= u4.__.length && u4.__.push({}), u4.__[n2];
+  // node_modules/@tanstack/query-core/build/modern/subscribable.js
+  var Subscribable = class {
+    constructor() {
+      this.listeners = /* @__PURE__ */ new Set();
+      this.subscribe = this.subscribe.bind(this);
+    }
+    subscribe(listener) {
+      this.listeners.add(listener);
+      this.onSubscribe();
+      return () => {
+        this.listeners.delete(listener);
+        this.onUnsubscribe();
+      };
+    }
+    hasListeners() {
+      return this.listeners.size > 0;
+    }
+    onSubscribe() {
+    }
+    onUnsubscribe() {
+    }
+  };
+
+  // node_modules/@tanstack/query-core/build/modern/focusManager.js
+  var _focused, _cleanup, _setup, _a;
+  var FocusManager = (_a = class extends Subscribable {
+    constructor() {
+      super();
+      __privateAdd(this, _focused);
+      __privateAdd(this, _cleanup);
+      __privateAdd(this, _setup);
+      __privateSet(this, _setup, (onFocus) => {
+        if (typeof window !== "undefined" && window.addEventListener) {
+          const listener = () => onFocus();
+          window.addEventListener("visibilitychange", listener, false);
+          return () => {
+            window.removeEventListener("visibilitychange", listener);
+          };
+        }
+        return;
+      });
+    }
+    onSubscribe() {
+      if (!__privateGet(this, _cleanup)) {
+        this.setEventListener(__privateGet(this, _setup));
+      }
+    }
+    onUnsubscribe() {
+      var _a12;
+      if (!this.hasListeners()) {
+        (_a12 = __privateGet(this, _cleanup)) == null ? void 0 : _a12.call(this);
+        __privateSet(this, _cleanup, void 0);
+      }
+    }
+    setEventListener(setup) {
+      var _a12;
+      __privateSet(this, _setup, setup);
+      (_a12 = __privateGet(this, _cleanup)) == null ? void 0 : _a12.call(this);
+      __privateSet(this, _cleanup, setup((focused) => {
+        if (typeof focused === "boolean") {
+          this.setFocused(focused);
+        } else {
+          this.onFocus();
+        }
+      }));
+    }
+    setFocused(focused) {
+      const changed = __privateGet(this, _focused) !== focused;
+      if (changed) {
+        __privateSet(this, _focused, focused);
+        this.onFocus();
+      }
+    }
+    onFocus() {
+      const isFocused = this.isFocused();
+      this.listeners.forEach((listener) => {
+        listener(isFocused);
+      });
+    }
+    isFocused() {
+      if (typeof __privateGet(this, _focused) === "boolean") {
+        return __privateGet(this, _focused);
+      }
+      return globalThis.document?.visibilityState !== "hidden";
+    }
+  }, _focused = new WeakMap(), _cleanup = new WeakMap(), _setup = new WeakMap(), _a);
+  var focusManager = new FocusManager();
+
+  // node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+  var defaultTimeoutProvider = {
+    // We need the wrapper function syntax below instead of direct references to
+    // global setTimeout etc.
+    //
+    // BAD: `setTimeout: setTimeout`
+    // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+    //
+    // If we use direct references here, then anything that wants to spy on or
+    // replace the global setTimeout (like tests) won't work since we'll already
+    // have a hard reference to the original implementation at the time when this
+    // file was imported.
+    setTimeout: (callback, delay) => setTimeout(callback, delay),
+    clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+    setInterval: (callback, delay) => setInterval(callback, delay),
+    clearInterval: (intervalId) => clearInterval(intervalId)
+  };
+  var _provider, _providerCalled, _a2;
+  var TimeoutManager = (_a2 = class {
+    constructor() {
+      // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+      // type at app boot; and if we leave that type, then any new timer provider
+      // would need to support the default provider's concrete timer ID, which is
+      // infeasible across environments.
+      //
+      // We settle for type safety for the TimeoutProvider type, and accept that
+      // this class is unsafe internally to allow for extension.
+      __privateAdd(this, _provider, defaultTimeoutProvider);
+      __privateAdd(this, _providerCalled, false);
+    }
+    setTimeoutProvider(provider) {
+      if (true) {
+        if (__privateGet(this, _providerCalled) && provider !== __privateGet(this, _provider)) {
+          console.error(
+            `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+            { previous: __privateGet(this, _provider), provider }
+          );
+        }
+      }
+      __privateSet(this, _provider, provider);
+      if (true) {
+        __privateSet(this, _providerCalled, false);
+      }
+    }
+    setTimeout(callback, delay) {
+      if (true) {
+        __privateSet(this, _providerCalled, true);
+      }
+      return __privateGet(this, _provider).setTimeout(callback, delay);
+    }
+    clearTimeout(timeoutId) {
+      __privateGet(this, _provider).clearTimeout(timeoutId);
+    }
+    setInterval(callback, delay) {
+      if (true) {
+        __privateSet(this, _providerCalled, true);
+      }
+      return __privateGet(this, _provider).setInterval(callback, delay);
+    }
+    clearInterval(intervalId) {
+      __privateGet(this, _provider).clearInterval(intervalId);
+    }
+  }, _provider = new WeakMap(), _providerCalled = new WeakMap(), _a2);
+  var timeoutManager = new TimeoutManager();
+  function systemSetTimeoutZero(callback) {
+    setTimeout(callback, 0);
   }
-  function d2(n2) {
-    return o2 = 1, h2(D2, n2);
+
+  // node_modules/@tanstack/query-core/build/modern/utils.js
+  var isServer = typeof window === "undefined" || "Deno" in globalThis;
+  function noop() {
+  }
+  function functionalUpdate(updater, input) {
+    return typeof updater === "function" ? updater(input) : updater;
+  }
+  function isValidTimeout(value) {
+    return typeof value === "number" && value >= 0 && value !== Infinity;
+  }
+  function timeUntilStale(updatedAt, staleTime) {
+    return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+  }
+  function resolveStaleTime(staleTime, query) {
+    return typeof staleTime === "function" ? staleTime(query) : staleTime;
+  }
+  function resolveQueryBoolean(option, query) {
+    return typeof option === "function" ? option(query) : option;
+  }
+  function matchQuery(filters, query) {
+    const {
+      type = "all",
+      exact,
+      fetchStatus,
+      predicate,
+      queryKey,
+      stale
+    } = filters;
+    if (queryKey) {
+      if (exact) {
+        if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+          return false;
+        }
+      } else if (!partialMatchKey(query.queryKey, queryKey)) {
+        return false;
+      }
+    }
+    if (type !== "all") {
+      const isActive = query.isActive();
+      if (type === "active" && !isActive) {
+        return false;
+      }
+      if (type === "inactive" && isActive) {
+        return false;
+      }
+    }
+    if (typeof stale === "boolean" && query.isStale() !== stale) {
+      return false;
+    }
+    if (fetchStatus && fetchStatus !== query.state.fetchStatus) {
+      return false;
+    }
+    if (predicate && !predicate(query)) {
+      return false;
+    }
+    return true;
   }
-  function h2(n2, u4, i3) {
-    var o3 = p2(t2++, 2);
-    if (o3.t = n2, !o3.__c && (o3.__ = [i3 ? i3(u4) : D2(void 0, u4), function(n3) {
-      var t3 = o3.__N ? o3.__N[0] : o3.__[0], r3 = o3.t(t3, n3);
-      t3 !== r3 && (o3.__N = [r3, o3.__[1]], o3.__c.setState({}));
-    }], o3.__c = r2, !r2.__f)) {
-      var f4 = function(n3, t3, r3) {
-        if (!o3.__c.__H) return true;
-        var u5 = o3.__c.__H.__.filter(function(n4) {
-          return n4.__c;
-        });
-        if (u5.every(function(n4) {
-          return !n4.__N;
-        })) return !c3 || c3.call(this, n3, t3, r3);
-        var i4 = o3.__c.props !== n3;
-        return u5.some(function(n4) {
-          if (n4.__N) {
-            var t4 = n4.__[0];
-            n4.__ = n4.__N, n4.__N = void 0, t4 !== n4.__[0] && (i4 = true);
-          }
-        }), c3 && c3.call(this, n3, t3, r3) || i4;
-      };
-      r2.__f = true;
-      var c3 = r2.shouldComponentUpdate, e3 = r2.componentWillUpdate;
-      r2.componentWillUpdate = function(n3, t3, r3) {
-        if (this.__e) {
-          var u5 = c3;
-          c3 = void 0, f4(n3, t3, r3), c3 = u5;
+  function matchMutation(filters, mutation) {
+    const { exact, status, predicate, mutationKey } = filters;
+    if (mutationKey) {
+      if (!mutation.options.mutationKey) {
+        return false;
+      }
+      if (exact) {
+        if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {
+          return false;
         }
-        e3 && e3.call(this, n3, t3, r3);
-      }, r2.shouldComponentUpdate = f4;
+      } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
+        return false;
+      }
     }
-    return o3.__N || o3.__;
+    if (status && mutation.state.status !== status) {
+      return false;
+    }
+    if (predicate && !predicate(mutation)) {
+      return false;
+    }
+    return true;
   }
-  function y2(n2, u4) {
-    var i3 = p2(t2++, 3);
-    !c2.__s && C2(i3.__H, u4) && (i3.__ = n2, i3.u = u4, r2.__H.__h.push(i3));
+  function hashQueryKeyByOptions(queryKey, options) {
+    const hashFn = options?.queryKeyHashFn || hashKey;
+    return hashFn(queryKey);
+  }
+  function hashKey(queryKey) {
+    return JSON.stringify(
+      queryKey,
+      (_3, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+        result[key] = val[key];
+        return result;
+      }, {}) : val
+    );
   }
-  function A2(n2) {
-    return o2 = 5, T2(function() {
-      return { current: n2 };
-    }, []);
+  function partialMatchKey(a3, b) {
+    if (a3 === b) {
+      return true;
+    }
+    if (typeof a3 !== typeof b) {
+      return false;
+    }
+    if (a3 && b && typeof a3 === "object" && typeof b === "object") {
+      return Object.keys(b).every((key) => partialMatchKey(a3[key], b[key]));
+    }
+    return false;
   }
-  function T2(n2, r3) {
-    var u4 = p2(t2++, 7);
-    return C2(u4.__H, r3) && (u4.__ = n2(), u4.__H = r3, u4.__h = n2), u4.__;
+  var hasOwn = Object.prototype.hasOwnProperty;
+  function replaceEqualDeep(a3, b, depth = 0) {
+    if (a3 === b) {
+      return a3;
+    }
+    if (depth > 500) return b;
+    const array = isPlainArray(a3) && isPlainArray(b);
+    if (!array && !(isPlainObject(a3) && isPlainObject(b))) return b;
+    const aItems = array ? a3 : Object.keys(a3);
+    const aSize = aItems.length;
+    const bItems = array ? b : Object.keys(b);
+    const bSize = bItems.length;
+    const copy = array ? new Array(bSize) : {};
+    let equalItems = 0;
+    for (let i3 = 0; i3 < bSize; i3++) {
+      const key = array ? i3 : bItems[i3];
+      const aItem = a3[key];
+      const bItem = b[key];
+      if (aItem === bItem) {
+        copy[key] = aItem;
+        if (array ? i3 < aSize : hasOwn.call(a3, key)) equalItems++;
+        continue;
+      }
+      if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+        copy[key] = bItem;
+        continue;
+      }
+      const v3 = replaceEqualDeep(aItem, bItem, depth + 1);
+      copy[key] = v3;
+      if (v3 === aItem) equalItems++;
+    }
+    return aSize === bSize && equalItems === aSize ? a3 : copy;
   }
-  function q2(n2, t3) {
-    return o2 = 8, T2(function() {
-      return n2;
-    }, t3);
+  function shallowEqualObjects(a3, b) {
+    if (!b || Object.keys(a3).length !== Object.keys(b).length) {
+      return false;
+    }
+    for (const key in a3) {
+      if (a3[key] !== b[key]) {
+        return false;
+      }
+    }
+    return true;
   }
-  function j2() {
-    for (var n2; n2 = f2.shift(); ) {
-      var t3 = n2.__H;
-      if (n2.__P && t3) try {
-        t3.__h.some(z2), t3.__h.some(B2), t3.__h = [];
-      } catch (r3) {
-        t3.__h = [], c2.__e(r3, n2.__v);
+  function isPlainArray(value) {
+    return Array.isArray(value) && value.length === Object.keys(value).length;
+  }
+  function isPlainObject(o3) {
+    if (!hasObjectPrototype(o3)) {
+      return false;
+    }
+    const ctor = o3.constructor;
+    if (ctor === void 0) {
+      return true;
+    }
+    const prot = ctor.prototype;
+    if (!hasObjectPrototype(prot)) {
+      return false;
+    }
+    if (!prot.hasOwnProperty("isPrototypeOf")) {
+      return false;
+    }
+    if (Object.getPrototypeOf(o3) !== Object.prototype) {
+      return false;
+    }
+    return true;
+  }
+  function hasObjectPrototype(o3) {
+    return Object.prototype.toString.call(o3) === "[object Object]";
+  }
+  function sleep(timeout) {
+    return new Promise((resolve) => {
+      timeoutManager.setTimeout(resolve, timeout);
+    });
+  }
+  function replaceData(prevData, data, options) {
+    if (typeof options.structuralSharing === "function") {
+      return options.structuralSharing(prevData, data);
+    } else if (options.structuralSharing !== false) {
+      if (true) {
+        try {
+          return replaceEqualDeep(prevData, data);
+        } catch (error) {
+          console.error(
+            `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
+          );
+          throw error;
+        }
+      }
+      return replaceEqualDeep(prevData, data);
+    }
+    return data;
+  }
+  function addToEnd(items, item, max = 0) {
+    const newItems = [...items, item];
+    return max && newItems.length > max ? newItems.slice(1) : newItems;
+  }
+  function addToStart(items, item, max = 0) {
+    const newItems = [item, ...items];
+    return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+  }
+  var skipToken = /* @__PURE__ */ Symbol();
+  function ensureQueryFn(options, fetchOptions) {
+    if (true) {
+      if (options.queryFn === skipToken) {
+        console.error(
+          `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`
+        );
+      }
+    }
+    if (!options.queryFn && fetchOptions?.initialPromise) {
+      return () => fetchOptions.initialPromise;
+    }
+    if (!options.queryFn || options.queryFn === skipToken) {
+      return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`));
+    }
+    return options.queryFn;
+  }
+  function shouldThrowError(throwOnError, params) {
+    if (typeof throwOnError === "function") {
+      return throwOnError(...params);
+    }
+    return !!throwOnError;
+  }
+  function addConsumeAwareSignal(object, getSignal, onCancelled) {
+    let consumed = false;
+    let signal;
+    Object.defineProperty(object, "signal", {
+      enumerable: true,
+      get: () => {
+        signal ?? (signal = getSignal());
+        if (consumed) {
+          return signal;
+        }
+        consumed = true;
+        if (signal.aborted) {
+          onCancelled();
+        } else {
+          signal.addEventListener("abort", onCancelled, { once: true });
+        }
+        return signal;
+      }
+    });
+    return object;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/environmentManager.js
+  var environmentManager = /* @__PURE__ */ (() => {
+    let isServerFn = () => isServer;
+    return {
+      /**
+       * Returns whether the current runtime should be treated as a server environment.
+       */
+      isServer() {
+        return isServerFn();
+      },
+      /**
+       * Overrides the server check globally.
+       */
+      setIsServer(isServerValue) {
+        isServerFn = isServerValue;
+      }
+    };
+  })();
+
+  // node_modules/@tanstack/query-core/build/modern/thenable.js
+  function pendingThenable() {
+    let resolve;
+    let reject;
+    const thenable = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+    });
+    thenable.status = "pending";
+    thenable.catch(() => {
+    });
+    function finalize(data) {
+      Object.assign(thenable, data);
+      delete thenable.resolve;
+      delete thenable.reject;
+    }
+    thenable.resolve = (value) => {
+      finalize({
+        status: "fulfilled",
+        value
+      });
+      resolve(value);
+    };
+    thenable.reject = (reason) => {
+      finalize({
+        status: "rejected",
+        reason
+      });
+      reject(reason);
+    };
+    return thenable;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/notifyManager.js
+  var defaultScheduler = systemSetTimeoutZero;
+  function createNotifyManager() {
+    let queue = [];
+    let transactions = 0;
+    let notifyFn = (callback) => {
+      callback();
+    };
+    let batchNotifyFn = (callback) => {
+      callback();
+    };
+    let scheduleFn = defaultScheduler;
+    const schedule = (callback) => {
+      if (transactions) {
+        queue.push(callback);
+      } else {
+        scheduleFn(() => {
+          notifyFn(callback);
+        });
+      }
+    };
+    const flush = () => {
+      const originalQueue = queue;
+      queue = [];
+      if (originalQueue.length) {
+        scheduleFn(() => {
+          batchNotifyFn(() => {
+            originalQueue.forEach((callback) => {
+              notifyFn(callback);
+            });
+          });
+        });
+      }
+    };
+    return {
+      batch: (callback) => {
+        let result;
+        transactions++;
+        try {
+          result = callback();
+        } finally {
+          transactions--;
+          if (!transactions) {
+            flush();
+          }
+        }
+        return result;
+      },
+      /**
+       * All calls to the wrapped function will be batched.
+       */
+      batchCalls: (callback) => {
+        return (...args) => {
+          schedule(() => {
+            callback(...args);
+          });
+        };
+      },
+      schedule,
+      /**
+       * Use this method to set a custom notify function.
+       * This can be used to for example wrap notifications with `React.act` while running tests.
+       */
+      setNotifyFunction: (fn) => {
+        notifyFn = fn;
+      },
+      /**
+       * Use this method to set a custom function to batch notifications together into a single tick.
+       * By default React Query will use the batch function provided by ReactDOM or React Native.
+       */
+      setBatchNotifyFunction: (fn) => {
+        batchNotifyFn = fn;
+      },
+      setScheduler: (fn) => {
+        scheduleFn = fn;
+      }
+    };
+  }
+  var notifyManager = createNotifyManager();
+
+  // node_modules/@tanstack/query-core/build/modern/onlineManager.js
+  var _online, _cleanup2, _setup2, _a3;
+  var OnlineManager = (_a3 = class extends Subscribable {
+    constructor() {
+      super();
+      __privateAdd(this, _online, true);
+      __privateAdd(this, _cleanup2);
+      __privateAdd(this, _setup2);
+      __privateSet(this, _setup2, (onOnline) => {
+        if (typeof window !== "undefined" && window.addEventListener) {
+          const onlineListener = () => onOnline(true);
+          const offlineListener = () => onOnline(false);
+          window.addEventListener("online", onlineListener, false);
+          window.addEventListener("offline", offlineListener, false);
+          return () => {
+            window.removeEventListener("online", onlineListener);
+            window.removeEventListener("offline", offlineListener);
+          };
+        }
+        return;
+      });
+    }
+    onSubscribe() {
+      if (!__privateGet(this, _cleanup2)) {
+        this.setEventListener(__privateGet(this, _setup2));
+      }
+    }
+    onUnsubscribe() {
+      var _a12;
+      if (!this.hasListeners()) {
+        (_a12 = __privateGet(this, _cleanup2)) == null ? void 0 : _a12.call(this);
+        __privateSet(this, _cleanup2, void 0);
+      }
+    }
+    setEventListener(setup) {
+      var _a12;
+      __privateSet(this, _setup2, setup);
+      (_a12 = __privateGet(this, _cleanup2)) == null ? void 0 : _a12.call(this);
+      __privateSet(this, _cleanup2, setup(this.setOnline.bind(this)));
+    }
+    setOnline(online) {
+      const changed = __privateGet(this, _online) !== online;
+      if (changed) {
+        __privateSet(this, _online, online);
+        this.listeners.forEach((listener) => {
+          listener(online);
+        });
+      }
+    }
+    isOnline() {
+      return __privateGet(this, _online);
+    }
+  }, _online = new WeakMap(), _cleanup2 = new WeakMap(), _setup2 = new WeakMap(), _a3);
+  var onlineManager = new OnlineManager();
+
+  // node_modules/@tanstack/query-core/build/modern/retryer.js
+  function defaultRetryDelay(failureCount) {
+    return Math.min(1e3 * 2 ** failureCount, 3e4);
+  }
+  function canFetch(networkMode) {
+    return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+  }
+  var CancelledError = class extends Error {
+    constructor(options) {
+      super("CancelledError");
+      this.revert = options?.revert;
+      this.silent = options?.silent;
+    }
+  };
+  function createRetryer(config) {
+    let isRetryCancelled = false;
+    let failureCount = 0;
+    let continueFn;
+    const thenable = pendingThenable();
+    const isResolved = () => thenable.status !== "pending";
+    const cancel = (cancelOptions) => {
+      if (!isResolved()) {
+        const error = new CancelledError(cancelOptions);
+        reject(error);
+        config.onCancel?.(error);
+      }
+    };
+    const cancelRetry = () => {
+      isRetryCancelled = true;
+    };
+    const continueRetry = () => {
+      isRetryCancelled = false;
+    };
+    const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
+    const canStart = () => canFetch(config.networkMode) && config.canRun();
+    const resolve = (value) => {
+      if (!isResolved()) {
+        continueFn?.();
+        thenable.resolve(value);
+      }
+    };
+    const reject = (value) => {
+      if (!isResolved()) {
+        continueFn?.();
+        thenable.reject(value);
+      }
+    };
+    const pause = () => {
+      return new Promise((continueResolve) => {
+        continueFn = (value) => {
+          if (isResolved() || canContinue()) {
+            continueResolve(value);
+          }
+        };
+        config.onPause?.();
+      }).then(() => {
+        continueFn = void 0;
+        if (!isResolved()) {
+          config.onContinue?.();
+        }
+      });
+    };
+    const run = () => {
+      if (isResolved()) {
+        return;
+      }
+      let promiseOrValue;
+      const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+      try {
+        promiseOrValue = initialPromise ?? config.fn();
+      } catch (error) {
+        promiseOrValue = Promise.reject(error);
+      }
+      Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
+        if (isResolved()) {
+          return;
+        }
+        const retry = config.retry ?? (environmentManager.isServer() ? 0 : 3);
+        const retryDelay = config.retryDelay ?? defaultRetryDelay;
+        const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
+        const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
+        if (isRetryCancelled || !shouldRetry) {
+          reject(error);
+          return;
+        }
+        failureCount++;
+        config.onFail?.(failureCount, error);
+        sleep(delay).then(() => {
+          return canContinue() ? void 0 : pause();
+        }).then(() => {
+          if (isRetryCancelled) {
+            reject(error);
+          } else {
+            run();
+          }
+        });
+      });
+    };
+    return {
+      promise: thenable,
+      status: () => thenable.status,
+      cancel,
+      continue: () => {
+        continueFn?.();
+        return thenable;
+      },
+      cancelRetry,
+      continueRetry,
+      canStart,
+      start: () => {
+        if (canStart()) {
+          run();
+        } else {
+          pause().then(run);
+        }
+        return thenable;
+      }
+    };
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/removable.js
+  var _gcTimeout, _a4;
+  var Removable = (_a4 = class {
+    constructor() {
+      __privateAdd(this, _gcTimeout);
+    }
+    destroy() {
+      this.clearGcTimeout();
+    }
+    scheduleGc() {
+      this.clearGcTimeout();
+      if (isValidTimeout(this.gcTime)) {
+        __privateSet(this, _gcTimeout, timeoutManager.setTimeout(() => {
+          this.optionalRemove();
+        }, this.gcTime));
+      }
+    }
+    updateGcTime(newGcTime) {
+      this.gcTime = Math.max(
+        this.gcTime || 0,
+        newGcTime ?? (environmentManager.isServer() ? Infinity : 5 * 60 * 1e3)
+      );
+    }
+    clearGcTimeout() {
+      if (__privateGet(this, _gcTimeout) !== void 0) {
+        timeoutManager.clearTimeout(__privateGet(this, _gcTimeout));
+        __privateSet(this, _gcTimeout, void 0);
+      }
+    }
+  }, _gcTimeout = new WeakMap(), _a4);
+
+  // node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+  function infiniteQueryBehavior(pages) {
+    return {
+      onFetch: (context, query) => {
+        const options = context.options;
+        const direction = context.fetchOptions?.meta?.fetchMore?.direction;
+        const oldPages = context.state.data?.pages || [];
+        const oldPageParams = context.state.data?.pageParams || [];
+        let result = { pages: [], pageParams: [] };
+        let currentPage = 0;
+        const fetchFn = async () => {
+          let cancelled = false;
+          const addSignalProperty = (object) => {
+            addConsumeAwareSignal(
+              object,
+              () => context.signal,
+              () => cancelled = true
+            );
+          };
+          const queryFn = ensureQueryFn(context.options, context.fetchOptions);
+          const fetchPage = async (data, param, previous) => {
+            if (cancelled) {
+              return Promise.reject(context.signal.reason);
+            }
+            if (param == null && data.pages.length) {
+              return Promise.resolve(data);
+            }
+            const createQueryFnContext = () => {
+              const queryFnContext2 = {
+                client: context.client,
+                queryKey: context.queryKey,
+                pageParam: param,
+                direction: previous ? "backward" : "forward",
+                meta: context.options.meta
+              };
+              addSignalProperty(queryFnContext2);
+              return queryFnContext2;
+            };
+            const queryFnContext = createQueryFnContext();
+            const page = await queryFn(queryFnContext);
+            const { maxPages } = context.options;
+            const addTo = previous ? addToStart : addToEnd;
+            return {
+              pages: addTo(data.pages, page, maxPages),
+              pageParams: addTo(data.pageParams, param, maxPages)
+            };
+          };
+          if (direction && oldPages.length) {
+            const previous = direction === "backward";
+            const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+            const oldData = {
+              pages: oldPages,
+              pageParams: oldPageParams
+            };
+            const param = pageParamFn(options, oldData);
+            result = await fetchPage(oldData, param, previous);
+          } else {
+            const remainingPages = pages ?? oldPages.length;
+            do {
+              const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);
+              if (currentPage > 0 && param == null) {
+                break;
+              }
+              result = await fetchPage(result, param);
+              currentPage++;
+            } while (currentPage < remainingPages);
+          }
+          return result;
+        };
+        if (context.options.persister) {
+          context.fetchFn = () => {
+            return context.options.persister?.(
+              fetchFn,
+              {
+                client: context.client,
+                queryKey: context.queryKey,
+                meta: context.options.meta,
+                signal: context.signal
+              },
+              query
+            );
+          };
+        } else {
+          context.fetchFn = fetchFn;
+        }
+      }
+    };
+  }
+  function getNextPageParam(options, { pages, pageParams }) {
+    const lastIndex = pages.length - 1;
+    return pages.length > 0 ? options.getNextPageParam(
+      pages[lastIndex],
+      pages,
+      pageParams[lastIndex],
+      pageParams
+    ) : void 0;
+  }
+  function getPreviousPageParam(options, { pages, pageParams }) {
+    return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;
+  }
+  function hasNextPage(options, data) {
+    if (!data) return false;
+    return getNextPageParam(options, data) != null;
+  }
+  function hasPreviousPage(options, data) {
+    if (!data || !options.getPreviousPageParam) return false;
+    return getPreviousPageParam(options, data) != null;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/query.js
+  var _queryType, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, isInitialPausedFetch_fn, dispatch_fn, _a5;
+  var Query = (_a5 = class extends Removable {
+    constructor(config) {
+      super();
+      __privateAdd(this, _Query_instances);
+      __privateAdd(this, _queryType);
+      __privateAdd(this, _initialState);
+      __privateAdd(this, _revertState);
+      __privateAdd(this, _cache);
+      __privateAdd(this, _client);
+      __privateAdd(this, _retryer);
+      __privateAdd(this, _defaultOptions);
+      __privateAdd(this, _abortSignalConsumed);
+      __privateSet(this, _abortSignalConsumed, false);
+      __privateSet(this, _defaultOptions, config.defaultOptions);
+      this.setOptions(config.options);
+      this.observers = [];
+      __privateSet(this, _client, config.client);
+      __privateSet(this, _cache, __privateGet(this, _client).getQueryCache());
+      this.queryKey = config.queryKey;
+      this.queryHash = config.queryHash;
+      __privateSet(this, _initialState, getDefaultState(this.options));
+      this.state = config.state ?? __privateGet(this, _initialState);
+      this.scheduleGc();
+    }
+    get meta() {
+      return this.options.meta;
+    }
+    get queryType() {
+      return __privateGet(this, _queryType);
+    }
+    get promise() {
+      return __privateGet(this, _retryer)?.promise;
+    }
+    setOptions(options) {
+      this.options = { ...__privateGet(this, _defaultOptions), ...options };
+      if (options?._type) {
+        __privateSet(this, _queryType, options._type);
+      }
+      this.updateGcTime(this.options.gcTime);
+      if (this.state && this.state.data === void 0) {
+        const defaultState = getDefaultState(this.options);
+        if (defaultState.data !== void 0) {
+          this.setState(
+            successState(defaultState.data, defaultState.dataUpdatedAt)
+          );
+          __privateSet(this, _initialState, defaultState);
+        }
+      }
+    }
+    optionalRemove() {
+      if (!this.observers.length && this.state.fetchStatus === "idle") {
+        __privateGet(this, _cache).remove(this);
+      }
+    }
+    setData(newData, options) {
+      const data = replaceData(this.state.data, newData, this.options);
+      __privateMethod(this, _Query_instances, dispatch_fn).call(this, {
+        data,
+        type: "success",
+        dataUpdatedAt: options?.updatedAt,
+        manual: options?.manual
+      });
+      return data;
+    }
+    setState(state) {
+      __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "setState", state });
+    }
+    cancel(options) {
+      const promise = __privateGet(this, _retryer)?.promise;
+      __privateGet(this, _retryer)?.cancel(options);
+      return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+    }
+    destroy() {
+      super.destroy();
+      this.cancel({ silent: true });
+    }
+    get resetState() {
+      return __privateGet(this, _initialState);
+    }
+    reset() {
+      this.destroy();
+      this.setState(this.resetState);
+    }
+    isActive() {
+      return this.observers.some(
+        (observer) => resolveQueryBoolean(observer.options.enabled, this) !== false
+      );
+    }
+    isDisabled() {
+      if (this.getObserversCount() > 0) {
+        return !this.isActive();
+      }
+      return this.options.queryFn === skipToken || !this.isFetched();
+    }
+    isFetched() {
+      return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+    }
+    isStatic() {
+      if (this.getObserversCount() > 0) {
+        return this.observers.some(
+          (observer) => resolveStaleTime(observer.options.staleTime, this) === "static"
+        );
+      }
+      return false;
+    }
+    isStale() {
+      if (this.getObserversCount() > 0) {
+        return this.observers.some(
+          (observer) => observer.getCurrentResult().isStale
+        );
+      }
+      return this.state.data === void 0 || this.state.isInvalidated;
+    }
+    isStaleByTime(staleTime = 0) {
+      if (this.state.data === void 0) {
+        return true;
+      }
+      if (staleTime === "static") {
+        return false;
+      }
+      if (this.state.isInvalidated) {
+        return true;
+      }
+      return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+    }
+    onFocus() {
+      const observer = this.observers.find((x3) => x3.shouldFetchOnWindowFocus());
+      observer?.refetch({ cancelRefetch: false });
+      __privateGet(this, _retryer)?.continue();
+    }
+    onOnline() {
+      const observer = this.observers.find((x3) => x3.shouldFetchOnReconnect());
+      observer?.refetch({ cancelRefetch: false });
+      __privateGet(this, _retryer)?.continue();
+    }
+    addObserver(observer) {
+      if (!this.observers.includes(observer)) {
+        this.observers.push(observer);
+        this.clearGcTimeout();
+        __privateGet(this, _cache).notify({ type: "observerAdded", query: this, observer });
+      }
+    }
+    removeObserver(observer) {
+      if (this.observers.includes(observer)) {
+        this.observers = this.observers.filter((x3) => x3 !== observer);
+        if (!this.observers.length) {
+          if (__privateGet(this, _retryer)) {
+            if (__privateGet(this, _abortSignalConsumed) || __privateMethod(this, _Query_instances, isInitialPausedFetch_fn).call(this)) {
+              __privateGet(this, _retryer).cancel({ revert: true });
+            } else {
+              __privateGet(this, _retryer).cancelRetry();
+            }
+          }
+          this.scheduleGc();
+        }
+        __privateGet(this, _cache).notify({ type: "observerRemoved", query: this, observer });
+      }
+    }
+    getObserversCount() {
+      return this.observers.length;
+    }
+    invalidate() {
+      if (!this.state.isInvalidated) {
+        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "invalidate" });
+      }
+    }
+    async fetch(options, fetchOptions) {
+      if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely
+      // re-start the fetch; there is a chance that the query is still in a
+      // pending state when that happens
+      __privateGet(this, _retryer)?.status() !== "rejected") {
+        if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) {
+          this.cancel({ silent: true });
+        } else if (__privateGet(this, _retryer)) {
+          __privateGet(this, _retryer).continueRetry();
+          return __privateGet(this, _retryer).promise;
+        }
+      }
+      if (options) {
+        this.setOptions(options);
+      }
+      if (!this.options.queryFn) {
+        const observer = this.observers.find((x3) => x3.options.queryFn);
+        if (observer) {
+          this.setOptions(observer.options);
+        }
+      }
+      if (true) {
+        if (!Array.isArray(this.options.queryKey)) {
+          console.error(
+            `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`
+          );
+        }
+      }
+      const abortController = new AbortController();
+      const addSignalProperty = (object) => {
+        Object.defineProperty(object, "signal", {
+          enumerable: true,
+          get: () => {
+            __privateSet(this, _abortSignalConsumed, true);
+            return abortController.signal;
+          }
+        });
+      };
+      const fetchFn = () => {
+        const queryFn = ensureQueryFn(this.options, fetchOptions);
+        const createQueryFnContext = () => {
+          const queryFnContext2 = {
+            client: __privateGet(this, _client),
+            queryKey: this.queryKey,
+            meta: this.meta
+          };
+          addSignalProperty(queryFnContext2);
+          return queryFnContext2;
+        };
+        const queryFnContext = createQueryFnContext();
+        __privateSet(this, _abortSignalConsumed, false);
+        if (this.options.persister) {
+          return this.options.persister(
+            queryFn,
+            queryFnContext,
+            this
+          );
+        }
+        return queryFn(queryFnContext);
+      };
+      const createFetchContext = () => {
+        const context2 = {
+          fetchOptions,
+          options: this.options,
+          queryKey: this.queryKey,
+          client: __privateGet(this, _client),
+          state: this.state,
+          fetchFn
+        };
+        addSignalProperty(context2);
+        return context2;
+      };
+      const context = createFetchContext();
+      const behavior = __privateGet(this, _queryType) === "infinite" ? infiniteQueryBehavior(
+        this.options.pages
+      ) : this.options.behavior;
+      behavior?.onFetch(context, this);
+      __privateSet(this, _revertState, this.state);
+      if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) {
+        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "fetch", meta: context.fetchOptions?.meta });
+      }
+      __privateSet(this, _retryer, createRetryer({
+        initialPromise: fetchOptions?.initialPromise,
+        fn: context.fetchFn,
+        onCancel: (error) => {
+          if (error instanceof CancelledError && error.revert) {
+            this.setState({
+              ...__privateGet(this, _revertState),
+              fetchStatus: "idle"
+            });
+          }
+          abortController.abort();
+        },
+        onFail: (failureCount, error) => {
+          __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "failed", failureCount, error });
+        },
+        onPause: () => {
+          __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "pause" });
+        },
+        onContinue: () => {
+          __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "continue" });
+        },
+        retry: context.options.retry,
+        retryDelay: context.options.retryDelay,
+        networkMode: context.options.networkMode,
+        canRun: () => true
+      }));
+      try {
+        const data = await __privateGet(this, _retryer).start();
+        if (data === void 0) {
+          if (true) {
+            console.error(
+              `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+            );
+          }
+          throw new Error(`${this.queryHash} data is undefined`);
+        }
+        this.setData(data);
+        __privateGet(this, _cache).config.onSuccess?.(data, this);
+        __privateGet(this, _cache).config.onSettled?.(
+          data,
+          this.state.error,
+          this
+        );
+        return data;
+      } catch (error) {
+        if (error instanceof CancelledError) {
+          if (error.silent) {
+            return __privateGet(this, _retryer).promise;
+          } else if (error.revert) {
+            if (this.state.data === void 0) {
+              throw error;
+            }
+            return this.state.data;
+          }
+        }
+        __privateMethod(this, _Query_instances, dispatch_fn).call(this, {
+          type: "error",
+          error
+        });
+        __privateGet(this, _cache).config.onError?.(
+          error,
+          this
+        );
+        __privateGet(this, _cache).config.onSettled?.(
+          this.state.data,
+          error,
+          this
+        );
+        throw error;
+      } finally {
+        this.scheduleGc();
+      }
+    }
+  }, _queryType = new WeakMap(), _initialState = new WeakMap(), _revertState = new WeakMap(), _cache = new WeakMap(), _client = new WeakMap(), _retryer = new WeakMap(), _defaultOptions = new WeakMap(), _abortSignalConsumed = new WeakMap(), _Query_instances = new WeakSet(), isInitialPausedFetch_fn = function() {
+    return this.state.fetchStatus === "paused" && this.state.status === "pending";
+  }, dispatch_fn = function(action) {
+    const reducer = (state) => {
+      switch (action.type) {
+        case "failed":
+          return {
+            ...state,
+            fetchFailureCount: action.failureCount,
+            fetchFailureReason: action.error
+          };
+        case "pause":
+          return {
+            ...state,
+            fetchStatus: "paused"
+          };
+        case "continue":
+          return {
+            ...state,
+            fetchStatus: "fetching"
+          };
+        case "fetch":
+          return {
+            ...state,
+            ...fetchState(state.data, this.options),
+            fetchMeta: action.meta ?? null
+          };
+        case "success":
+          const newState = {
+            ...state,
+            ...successState(action.data, action.dataUpdatedAt),
+            dataUpdateCount: state.dataUpdateCount + 1,
+            ...!action.manual && {
+              fetchStatus: "idle",
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            }
+          };
+          __privateSet(this, _revertState, action.manual ? newState : void 0);
+          return newState;
+        case "error":
+          const error = action.error;
+          return {
+            ...state,
+            error,
+            errorUpdateCount: state.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: state.fetchFailureCount + 1,
+            fetchFailureReason: error,
+            fetchStatus: "idle",
+            status: "error",
+            // flag existing data as invalidated if we get a background error
+            // note that "no data" always means stale so we can set unconditionally here
+            isInvalidated: true
+          };
+        case "invalidate":
+          return {
+            ...state,
+            isInvalidated: true
+          };
+        case "setState":
+          return {
+            ...state,
+            ...action.state
+          };
+      }
+    };
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      this.observers.forEach((observer) => {
+        observer.onQueryUpdate();
+      });
+      __privateGet(this, _cache).notify({ query: this, type: "updated", action });
+    });
+  }, _a5);
+  function fetchState(data, options) {
+    return {
+      fetchFailureCount: 0,
+      fetchFailureReason: null,
+      fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+      ...data === void 0 && {
+        error: null,
+        status: "pending"
+      }
+    };
+  }
+  function successState(data, dataUpdatedAt) {
+    return {
+      data,
+      dataUpdatedAt: dataUpdatedAt ?? Date.now(),
+      error: null,
+      isInvalidated: false,
+      status: "success"
+    };
+  }
+  function getDefaultState(options) {
+    const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+    const hasData = data !== void 0;
+    const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+    return {
+      data,
+      dataUpdateCount: 0,
+      dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
+      error: null,
+      errorUpdateCount: 0,
+      errorUpdatedAt: 0,
+      fetchFailureCount: 0,
+      fetchFailureReason: null,
+      fetchMeta: null,
+      isInvalidated: false,
+      status: hasData ? "success" : "pending",
+      fetchStatus: "idle"
+    };
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/queryObserver.js
+  var _client2, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_fn, notify_fn, _a6;
+  var QueryObserver = (_a6 = class extends Subscribable {
+    constructor(client, options) {
+      super();
+      __privateAdd(this, _QueryObserver_instances);
+      __privateAdd(this, _client2);
+      __privateAdd(this, _currentQuery);
+      __privateAdd(this, _currentQueryInitialState);
+      __privateAdd(this, _currentResult);
+      __privateAdd(this, _currentResultState);
+      __privateAdd(this, _currentResultOptions);
+      __privateAdd(this, _currentThenable);
+      __privateAdd(this, _selectError);
+      __privateAdd(this, _selectFn);
+      __privateAdd(this, _selectResult);
+      // This property keeps track of the last query with defined data.
+      // It will be used to pass the previous data and query to the placeholder function between renders.
+      __privateAdd(this, _lastQueryWithDefinedData);
+      __privateAdd(this, _staleTimeoutId);
+      __privateAdd(this, _refetchIntervalId);
+      __privateAdd(this, _currentRefetchInterval);
+      __privateAdd(this, _trackedProps, /* @__PURE__ */ new Set());
+      this.options = options;
+      __privateSet(this, _client2, client);
+      __privateSet(this, _selectError, null);
+      __privateSet(this, _currentThenable, pendingThenable());
+      this.bindMethods();
+      this.setOptions(options);
+    }
+    bindMethods() {
+      this.refetch = this.refetch.bind(this);
+    }
+    onSubscribe() {
+      if (this.listeners.size === 1) {
+        __privateGet(this, _currentQuery).addObserver(this);
+        if (shouldFetchOnMount(__privateGet(this, _currentQuery), this.options)) {
+          __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+        } else {
+          this.updateResult();
+        }
+        __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+      }
+    }
+    onUnsubscribe() {
+      if (!this.hasListeners()) {
+        this.destroy();
+      }
+    }
+    shouldFetchOnReconnect() {
+      return shouldFetchOn(
+        __privateGet(this, _currentQuery),
+        this.options,
+        this.options.refetchOnReconnect
+      );
+    }
+    shouldFetchOnWindowFocus() {
+      return shouldFetchOn(
+        __privateGet(this, _currentQuery),
+        this.options,
+        this.options.refetchOnWindowFocus
+      );
+    }
+    destroy() {
+      this.listeners = /* @__PURE__ */ new Set();
+      __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+      __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+      __privateGet(this, _currentQuery).removeObserver(this);
+    }
+    setOptions(options) {
+      const prevOptions = this.options;
+      const prevQuery = __privateGet(this, _currentQuery);
+      this.options = __privateGet(this, _client2).defaultQueryOptions(options);
+      if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== "boolean") {
+        throw new Error(
+          "Expected enabled to be a boolean or a callback that returns a boolean"
+        );
+      }
+      __privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
+      __privateGet(this, _currentQuery).setOptions(this.options);
+      if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+        __privateGet(this, _client2).getQueryCache().notify({
+          type: "observerOptionsUpdated",
+          query: __privateGet(this, _currentQuery),
+          observer: this
+        });
+      }
+      const mounted = this.hasListeners();
+      if (mounted && shouldFetchOptionally(
+        __privateGet(this, _currentQuery),
+        prevQuery,
+        this.options,
+        prevOptions
+      )) {
+        __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+      }
+      this.updateResult();
+      if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryBoolean(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveStaleTime(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveStaleTime(prevOptions.staleTime, __privateGet(this, _currentQuery)))) {
+        __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+      }
+      const nextRefetchInterval = __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this);
+      if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryBoolean(prevOptions.enabled, __privateGet(this, _currentQuery)) || nextRefetchInterval !== __privateGet(this, _currentRefetchInterval))) {
+        __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, nextRefetchInterval);
+      }
+    }
+    getOptimisticResult(options) {
+      const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), options);
+      const result = this.createResult(query, options);
+      if (shouldAssignObserverCurrentProperties(this, result)) {
+        __privateSet(this, _currentResult, result);
+        __privateSet(this, _currentResultOptions, this.options);
+        __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+      }
+      return result;
+    }
+    getCurrentResult() {
+      return __privateGet(this, _currentResult);
+    }
+    trackResult(result, onPropTracked) {
+      return new Proxy(result, {
+        get: (target, key) => {
+          this.trackProp(key);
+          onPropTracked?.(key);
+          if (key === "promise") {
+            this.trackProp("data");
+            if (!this.options.experimental_prefetchInRender && __privateGet(this, _currentThenable).status === "pending") {
+              __privateGet(this, _currentThenable).reject(
+                new Error(
+                  "experimental_prefetchInRender feature flag is not enabled"
+                )
+              );
+            }
+          }
+          return Reflect.get(target, key);
+        }
+      });
+    }
+    trackProp(key) {
+      __privateGet(this, _trackedProps).add(key);
+    }
+    getCurrentQuery() {
+      return __privateGet(this, _currentQuery);
+    }
+    refetch({ ...options } = {}) {
+      return this.fetch({
+        ...options
+      });
+    }
+    fetchOptimistic(options) {
+      const defaultedOptions = __privateGet(this, _client2).defaultQueryOptions(options);
+      const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), defaultedOptions);
+      return query.fetch().then(() => this.createResult(query, defaultedOptions));
+    }
+    fetch(fetchOptions) {
+      return __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this, {
+        ...fetchOptions,
+        cancelRefetch: fetchOptions.cancelRefetch ?? true
+      }).then(() => {
+        this.updateResult();
+        return __privateGet(this, _currentResult);
+      });
+    }
+    createResult(query, options) {
+      const prevQuery = __privateGet(this, _currentQuery);
+      const prevOptions = this.options;
+      const prevResult = __privateGet(this, _currentResult);
+      const prevResultState = __privateGet(this, _currentResultState);
+      const prevResultOptions = __privateGet(this, _currentResultOptions);
+      const queryChange = query !== prevQuery;
+      const queryInitialState = queryChange ? query.state : __privateGet(this, _currentQueryInitialState);
+      const { state } = query;
+      let newState = { ...state };
+      let isPlaceholderData = false;
+      let data;
+      if (options._optimisticResults) {
+        const mounted = this.hasListeners();
+        const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+        const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+        if (fetchOnMount || fetchOptionally) {
+          newState = {
+            ...newState,
+            ...fetchState(state.data, query.options)
+          };
+        }
+        if (options._optimisticResults === "isRestoring") {
+          newState.fetchStatus = "idle";
+        }
+      }
+      let { error, errorUpdatedAt, status } = newState;
+      data = newState.data;
+      let skipSelect = false;
+      if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+        let placeholderData;
+        if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+          placeholderData = prevResult.data;
+          skipSelect = true;
+        } else {
+          placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
+            __privateGet(this, _lastQueryWithDefinedData)?.state.data,
+            __privateGet(this, _lastQueryWithDefinedData)
+          ) : options.placeholderData;
+        }
+        if (placeholderData !== void 0) {
+          status = "success";
+          data = replaceData(
+            prevResult?.data,
+            placeholderData,
+            options
+          );
+          isPlaceholderData = true;
+        }
+      }
+      if (options.select && data !== void 0 && !skipSelect) {
+        if (prevResult && data === prevResultState?.data && options.select === __privateGet(this, _selectFn)) {
+          data = __privateGet(this, _selectResult);
+        } else {
+          try {
+            __privateSet(this, _selectFn, options.select);
+            data = options.select(data);
+            data = replaceData(prevResult?.data, data, options);
+            __privateSet(this, _selectResult, data);
+            __privateSet(this, _selectError, null);
+          } catch (selectError) {
+            __privateSet(this, _selectError, selectError);
+          }
+        }
+      }
+      if (__privateGet(this, _selectError)) {
+        error = __privateGet(this, _selectError);
+        data = __privateGet(this, _selectResult);
+        errorUpdatedAt = Date.now();
+        status = "error";
+      }
+      const isFetching = newState.fetchStatus === "fetching";
+      const isPending = status === "pending";
+      const isError = status === "error";
+      const isLoading = isPending && isFetching;
+      const hasData = data !== void 0;
+      const result = {
+        status,
+        fetchStatus: newState.fetchStatus,
+        isPending,
+        isSuccess: status === "success",
+        isError,
+        isInitialLoading: isLoading,
+        isLoading,
+        data,
+        dataUpdatedAt: newState.dataUpdatedAt,
+        error,
+        errorUpdatedAt,
+        failureCount: newState.fetchFailureCount,
+        failureReason: newState.fetchFailureReason,
+        errorUpdateCount: newState.errorUpdateCount,
+        isFetched: query.isFetched(),
+        isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+        isFetching,
+        isRefetching: isFetching && !isPending,
+        isLoadingError: isError && !hasData,
+        isPaused: newState.fetchStatus === "paused",
+        isPlaceholderData,
+        isRefetchError: isError && hasData,
+        isStale: isStale(query, options),
+        refetch: this.refetch,
+        promise: __privateGet(this, _currentThenable),
+        isEnabled: resolveQueryBoolean(options.enabled, query) !== false
+      };
+      const nextResult = result;
+      if (this.options.experimental_prefetchInRender) {
+        const hasResultData = nextResult.data !== void 0;
+        const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
+        const finalizeThenableIfPossible = (thenable) => {
+          if (isErrorWithoutData) {
+            thenable.reject(nextResult.error);
+          } else if (hasResultData) {
+            thenable.resolve(nextResult.data);
+          }
+        };
+        const recreateThenable = () => {
+          const pending = __privateSet(this, _currentThenable, nextResult.promise = pendingThenable());
+          finalizeThenableIfPossible(pending);
+        };
+        const prevThenable = __privateGet(this, _currentThenable);
+        switch (prevThenable.status) {
+          case "pending":
+            if (query.queryHash === prevQuery.queryHash) {
+              finalizeThenableIfPossible(prevThenable);
+            }
+            break;
+          case "fulfilled":
+            if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
+              recreateThenable();
+            }
+            break;
+          case "rejected":
+            if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
+              recreateThenable();
+            }
+            break;
+        }
+      }
+      return nextResult;
+    }
+    updateResult() {
+      const prevResult = __privateGet(this, _currentResult);
+      const nextResult = this.createResult(__privateGet(this, _currentQuery), this.options);
+      __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+      __privateSet(this, _currentResultOptions, this.options);
+      if (__privateGet(this, _currentResultState).data !== void 0) {
+        __privateSet(this, _lastQueryWithDefinedData, __privateGet(this, _currentQuery));
+      }
+      if (shallowEqualObjects(nextResult, prevResult)) {
+        return;
+      }
+      __privateSet(this, _currentResult, nextResult);
+      const shouldNotifyListeners = () => {
+        if (!prevResult) {
+          return true;
+        }
+        const { notifyOnChangeProps } = this.options;
+        const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+        if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !__privateGet(this, _trackedProps).size) {
+          return true;
+        }
+        const includedProps = new Set(
+          notifyOnChangePropsValue ?? __privateGet(this, _trackedProps)
+        );
+        if (this.options.throwOnError) {
+          includedProps.add("error");
+        }
+        return Object.keys(__privateGet(this, _currentResult)).some((key) => {
+          const typedKey = key;
+          const changed = __privateGet(this, _currentResult)[typedKey] !== prevResult[typedKey];
+          return changed && includedProps.has(typedKey);
+        });
+      };
+      __privateMethod(this, _QueryObserver_instances, notify_fn).call(this, { listeners: shouldNotifyListeners() });
+    }
+    onQueryUpdate() {
+      this.updateResult();
+      if (this.hasListeners()) {
+        __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+      }
+    }
+  }, _client2 = new WeakMap(), _currentQuery = new WeakMap(), _currentQueryInitialState = new WeakMap(), _currentResult = new WeakMap(), _currentResultState = new WeakMap(), _currentResultOptions = new WeakMap(), _currentThenable = new WeakMap(), _selectError = new WeakMap(), _selectFn = new WeakMap(), _selectResult = new WeakMap(), _lastQueryWithDefinedData = new WeakMap(), _staleTimeoutId = new WeakMap(), _refetchIntervalId = new WeakMap(), _currentRefetchInterval = new WeakMap(), _trackedProps = new WeakMap(), _QueryObserver_instances = new WeakSet(), executeFetch_fn = function(fetchOptions) {
+    __privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
+    let promise = __privateGet(this, _currentQuery).fetch(
+      this.options,
+      fetchOptions
+    );
+    if (!fetchOptions?.throwOnError) {
+      promise = promise.catch(noop);
+    }
+    return promise;
+  }, updateStaleTimeout_fn = function() {
+    __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+    const staleTime = resolveStaleTime(
+      this.options.staleTime,
+      __privateGet(this, _currentQuery)
+    );
+    if (environmentManager.isServer() || __privateGet(this, _currentResult).isStale || !isValidTimeout(staleTime)) {
+      return;
+    }
+    const time = timeUntilStale(__privateGet(this, _currentResult).dataUpdatedAt, staleTime);
+    const timeout = time + 1;
+    __privateSet(this, _staleTimeoutId, timeoutManager.setTimeout(() => {
+      if (!__privateGet(this, _currentResult).isStale) {
+        this.updateResult();
+      }
+    }, timeout));
+  }, computeRefetchInterval_fn = function() {
+    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(__privateGet(this, _currentQuery)) : this.options.refetchInterval) ?? false;
+  }, updateRefetchInterval_fn = function(nextInterval) {
+    __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+    __privateSet(this, _currentRefetchInterval, nextInterval);
+    if (environmentManager.isServer() || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) === false || !isValidTimeout(__privateGet(this, _currentRefetchInterval)) || __privateGet(this, _currentRefetchInterval) === 0) {
+      return;
+    }
+    __privateSet(this, _refetchIntervalId, timeoutManager.setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+      }
+    }, __privateGet(this, _currentRefetchInterval)));
+  }, updateTimers_fn = function() {
+    __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+    __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this));
+  }, clearStaleTimeout_fn = function() {
+    if (__privateGet(this, _staleTimeoutId) !== void 0) {
+      timeoutManager.clearTimeout(__privateGet(this, _staleTimeoutId));
+      __privateSet(this, _staleTimeoutId, void 0);
+    }
+  }, clearRefetchInterval_fn = function() {
+    if (__privateGet(this, _refetchIntervalId) !== void 0) {
+      timeoutManager.clearInterval(__privateGet(this, _refetchIntervalId));
+      __privateSet(this, _refetchIntervalId, void 0);
+    }
+  }, updateQuery_fn = function() {
+    const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), this.options);
+    if (query === __privateGet(this, _currentQuery)) {
+      return;
+    }
+    const prevQuery = __privateGet(this, _currentQuery);
+    __privateSet(this, _currentQuery, query);
+    __privateSet(this, _currentQueryInitialState, query.state);
+    if (this.hasListeners()) {
+      prevQuery?.removeObserver(this);
+      query.addObserver(this);
+    }
+  }, notify_fn = function(notifyOptions) {
+    notifyManager.batch(() => {
+      if (notifyOptions.listeners) {
+        this.listeners.forEach((listener) => {
+          listener(__privateGet(this, _currentResult));
+        });
+      }
+      __privateGet(this, _client2).getQueryCache().notify({
+        query: __privateGet(this, _currentQuery),
+        type: "observerResultsUpdated"
+      });
+    });
+  }, _a6);
+  function shouldLoadOnMount(query, options) {
+    return resolveQueryBoolean(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryBoolean(options.retryOnMount, query) === false);
+  }
+  function shouldFetchOnMount(query, options) {
+    return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+  }
+  function shouldFetchOn(query, options, field) {
+    if (resolveQueryBoolean(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+      const value = typeof field === "function" ? field(query) : field;
+      return value === "always" || value !== false && isStale(query, options);
+    }
+    return false;
+  }
+  function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+    return (query !== prevQuery || resolveQueryBoolean(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+  }
+  function isStale(query, options) {
+    return resolveQueryBoolean(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+  }
+  function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+    if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+      return true;
+    }
+    return false;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js
+  var InfiniteQueryObserver = class extends QueryObserver {
+    constructor(client, options) {
+      super(client, options);
+    }
+    bindMethods() {
+      super.bindMethods();
+      this.fetchNextPage = this.fetchNextPage.bind(this);
+      this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+    }
+    setOptions(options) {
+      options._type = "infinite";
+      super.setOptions(options);
+    }
+    getOptimisticResult(options) {
+      options._type = "infinite";
+      return super.getOptimisticResult(options);
+    }
+    fetchNextPage(options) {
+      return this.fetch({
+        ...options,
+        meta: {
+          fetchMore: { direction: "forward" }
+        }
+      });
+    }
+    fetchPreviousPage(options) {
+      return this.fetch({
+        ...options,
+        meta: {
+          fetchMore: { direction: "backward" }
+        }
+      });
+    }
+    createResult(query, options) {
+      const { state } = query;
+      const parentResult = super.createResult(query, options);
+      const { isFetching, isRefetching, isError, isRefetchError } = parentResult;
+      const fetchDirection = state.fetchMeta?.fetchMore?.direction;
+      const isFetchNextPageError = isError && fetchDirection === "forward";
+      const isFetchingNextPage = isFetching && fetchDirection === "forward";
+      const isFetchPreviousPageError = isError && fetchDirection === "backward";
+      const isFetchingPreviousPage = isFetching && fetchDirection === "backward";
+      const result = {
+        ...parentResult,
+        fetchNextPage: this.fetchNextPage,
+        fetchPreviousPage: this.fetchPreviousPage,
+        hasNextPage: hasNextPage(options, state.data),
+        hasPreviousPage: hasPreviousPage(options, state.data),
+        isFetchNextPageError,
+        isFetchingNextPage,
+        isFetchPreviousPageError,
+        isFetchingPreviousPage,
+        isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,
+        isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
+      };
+      return result;
+    }
+  };
+
+  // node_modules/@tanstack/query-core/build/modern/mutation.js
+  var _client3, _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _a7;
+  var Mutation = (_a7 = class extends Removable {
+    constructor(config) {
+      super();
+      __privateAdd(this, _Mutation_instances);
+      __privateAdd(this, _client3);
+      __privateAdd(this, _observers);
+      __privateAdd(this, _mutationCache);
+      __privateAdd(this, _retryer2);
+      __privateSet(this, _client3, config.client);
+      this.mutationId = config.mutationId;
+      __privateSet(this, _mutationCache, config.mutationCache);
+      __privateSet(this, _observers, []);
+      this.state = config.state || getDefaultState2();
+      this.setOptions(config.options);
+      this.scheduleGc();
+    }
+    setOptions(options) {
+      this.options = options;
+      this.updateGcTime(this.options.gcTime);
+    }
+    get meta() {
+      return this.options.meta;
+    }
+    addObserver(observer) {
+      if (!__privateGet(this, _observers).includes(observer)) {
+        __privateGet(this, _observers).push(observer);
+        this.clearGcTimeout();
+        __privateGet(this, _mutationCache).notify({
+          type: "observerAdded",
+          mutation: this,
+          observer
+        });
+      }
+    }
+    removeObserver(observer) {
+      __privateSet(this, _observers, __privateGet(this, _observers).filter((x3) => x3 !== observer));
+      this.scheduleGc();
+      __privateGet(this, _mutationCache).notify({
+        type: "observerRemoved",
+        mutation: this,
+        observer
+      });
+    }
+    optionalRemove() {
+      if (!__privateGet(this, _observers).length) {
+        if (this.state.status === "pending") {
+          this.scheduleGc();
+        } else {
+          __privateGet(this, _mutationCache).remove(this);
+        }
+      }
+    }
+    continue() {
+      return __privateGet(this, _retryer2)?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+      this.execute(this.state.variables);
+    }
+    async execute(variables) {
+      const onContinue = () => {
+        __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "continue" });
+      };
+      const mutationFnContext = {
+        client: __privateGet(this, _client3),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      __privateSet(this, _retryer2, createRetryer({
+        fn: () => {
+          if (!this.options.mutationFn) {
+            return Promise.reject(new Error("No mutationFn found"));
+          }
+          return this.options.mutationFn(variables, mutationFnContext);
+        },
+        onFail: (failureCount, error) => {
+          __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "failed", failureCount, error });
+        },
+        onPause: () => {
+          __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "pause" });
+        },
+        onContinue,
+        retry: this.options.retry ?? 0,
+        retryDelay: this.options.retryDelay,
+        networkMode: this.options.networkMode,
+        canRun: () => __privateGet(this, _mutationCache).canRun(this)
+      }));
+      const restored = this.state.status === "pending";
+      const isPaused = !__privateGet(this, _retryer2).canStart();
+      try {
+        if (restored) {
+          onContinue();
+        } else {
+          __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "pending", variables, isPaused });
+          if (__privateGet(this, _mutationCache).config.onMutate) {
+            await __privateGet(this, _mutationCache).config.onMutate(
+              variables,
+              this,
+              mutationFnContext
+            );
+          }
+          const context = await this.options.onMutate?.(
+            variables,
+            mutationFnContext
+          );
+          if (context !== this.state.context) {
+            __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, {
+              type: "pending",
+              context,
+              variables,
+              isPaused
+            });
+          }
+        }
+        const data = await __privateGet(this, _retryer2).start();
+        await __privateGet(this, _mutationCache).config.onSuccess?.(
+          data,
+          variables,
+          this.state.context,
+          this,
+          mutationFnContext
+        );
+        await this.options.onSuccess?.(
+          data,
+          variables,
+          this.state.context,
+          mutationFnContext
+        );
+        await __privateGet(this, _mutationCache).config.onSettled?.(
+          data,
+          null,
+          this.state.variables,
+          this.state.context,
+          this,
+          mutationFnContext
+        );
+        await this.options.onSettled?.(
+          data,
+          null,
+          variables,
+          this.state.context,
+          mutationFnContext
+        );
+        __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "success", data });
+        return data;
+      } catch (error) {
+        try {
+          await __privateGet(this, _mutationCache).config.onError?.(
+            error,
+            variables,
+            this.state.context,
+            this,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        try {
+          await this.options.onError?.(
+            error,
+            variables,
+            this.state.context,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        try {
+          await __privateGet(this, _mutationCache).config.onSettled?.(
+            void 0,
+            error,
+            this.state.variables,
+            this.state.context,
+            this,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        try {
+          await this.options.onSettled?.(
+            void 0,
+            error,
+            variables,
+            this.state.context,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "error", error });
+        throw error;
+      } finally {
+        __privateGet(this, _mutationCache).runNext(this);
+      }
+    }
+  }, _client3 = new WeakMap(), _observers = new WeakMap(), _mutationCache = new WeakMap(), _retryer2 = new WeakMap(), _Mutation_instances = new WeakSet(), dispatch_fn2 = function(action) {
+    const reducer = (state) => {
+      switch (action.type) {
+        case "failed":
+          return {
+            ...state,
+            failureCount: action.failureCount,
+            failureReason: action.error
+          };
+        case "pause":
+          return {
+            ...state,
+            isPaused: true
+          };
+        case "continue":
+          return {
+            ...state,
+            isPaused: false
+          };
+        case "pending":
+          return {
+            ...state,
+            context: action.context,
+            data: void 0,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: action.isPaused,
+            status: "pending",
+            variables: action.variables,
+            submittedAt: Date.now()
+          };
+        case "success":
+          return {
+            ...state,
+            data: action.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: "success",
+            isPaused: false
+          };
+        case "error":
+          return {
+            ...state,
+            data: void 0,
+            error: action.error,
+            failureCount: state.failureCount + 1,
+            failureReason: action.error,
+            isPaused: false,
+            status: "error"
+          };
+      }
+    };
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      __privateGet(this, _observers).forEach((observer) => {
+        observer.onMutationUpdate(action);
+      });
+      __privateGet(this, _mutationCache).notify({
+        mutation: this,
+        type: "updated",
+        action
+      });
+    });
+  }, _a7);
+  function getDefaultState2() {
+    return {
+      context: void 0,
+      data: void 0,
+      error: null,
+      failureCount: 0,
+      failureReason: null,
+      isPaused: false,
+      status: "idle",
+      variables: void 0,
+      submittedAt: 0
+    };
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/mutationCache.js
+  var _mutations, _scopes, _mutationId, _a8;
+  var MutationCache = (_a8 = class extends Subscribable {
+    constructor(config = {}) {
+      super();
+      __privateAdd(this, _mutations);
+      __privateAdd(this, _scopes);
+      __privateAdd(this, _mutationId);
+      this.config = config;
+      __privateSet(this, _mutations, /* @__PURE__ */ new Set());
+      __privateSet(this, _scopes, /* @__PURE__ */ new Map());
+      __privateSet(this, _mutationId, 0);
+    }
+    build(client, options, state) {
+      const mutation = new Mutation({
+        client,
+        mutationCache: this,
+        mutationId: ++__privateWrapper(this, _mutationId)._,
+        options: client.defaultMutationOptions(options),
+        state
+      });
+      this.add(mutation);
+      return mutation;
+    }
+    add(mutation) {
+      __privateGet(this, _mutations).add(mutation);
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const scopedMutations = __privateGet(this, _scopes).get(scope);
+        if (scopedMutations) {
+          scopedMutations.push(mutation);
+        } else {
+          __privateGet(this, _scopes).set(scope, [mutation]);
+        }
+      }
+      this.notify({ type: "added", mutation });
+    }
+    remove(mutation) {
+      if (__privateGet(this, _mutations).delete(mutation)) {
+        const scope = scopeFor(mutation);
+        if (typeof scope === "string") {
+          const scopedMutations = __privateGet(this, _scopes).get(scope);
+          if (scopedMutations) {
+            if (scopedMutations.length > 1) {
+              const index = scopedMutations.indexOf(mutation);
+              if (index !== -1) {
+                scopedMutations.splice(index, 1);
+              }
+            } else if (scopedMutations[0] === mutation) {
+              __privateGet(this, _scopes).delete(scope);
+            }
+          }
+        }
+      }
+      this.notify({ type: "removed", mutation });
+    }
+    canRun(mutation) {
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const mutationsWithSameScope = __privateGet(this, _scopes).get(scope);
+        const firstPendingMutation = mutationsWithSameScope?.find(
+          (m3) => m3.state.status === "pending"
+        );
+        return !firstPendingMutation || firstPendingMutation === mutation;
+      } else {
+        return true;
+      }
+    }
+    runNext(mutation) {
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const foundMutation = __privateGet(this, _scopes).get(scope)?.find((m3) => m3 !== mutation && m3.state.isPaused);
+        return foundMutation?.continue() ?? Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    }
+    clear() {
+      notifyManager.batch(() => {
+        __privateGet(this, _mutations).forEach((mutation) => {
+          this.notify({ type: "removed", mutation });
+        });
+        __privateGet(this, _mutations).clear();
+        __privateGet(this, _scopes).clear();
+      });
+    }
+    getAll() {
+      return Array.from(__privateGet(this, _mutations));
+    }
+    find(filters) {
+      const defaultedFilters = { exact: true, ...filters };
+      return this.getAll().find(
+        (mutation) => matchMutation(defaultedFilters, mutation)
+      );
+    }
+    findAll(filters = {}) {
+      return this.getAll().filter((mutation) => matchMutation(filters, mutation));
+    }
+    notify(event) {
+      notifyManager.batch(() => {
+        this.listeners.forEach((listener) => {
+          listener(event);
+        });
+      });
+    }
+    resumePausedMutations() {
+      const pausedMutations = this.getAll().filter((x3) => x3.state.isPaused);
+      return notifyManager.batch(
+        () => Promise.all(
+          pausedMutations.map((mutation) => mutation.continue().catch(noop))
+        )
+      );
+    }
+  }, _mutations = new WeakMap(), _scopes = new WeakMap(), _mutationId = new WeakMap(), _a8);
+  function scopeFor(mutation) {
+    return mutation.options.scope?.id;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+  var _client4, _currentResult2, _currentMutation, _mutateOptions, _MutationObserver_instances, updateResult_fn, notify_fn2, _a9;
+  var MutationObserver = (_a9 = class extends Subscribable {
+    constructor(client, options) {
+      super();
+      __privateAdd(this, _MutationObserver_instances);
+      __privateAdd(this, _client4);
+      __privateAdd(this, _currentResult2);
+      __privateAdd(this, _currentMutation);
+      __privateAdd(this, _mutateOptions);
+      __privateSet(this, _client4, client);
+      this.setOptions(options);
+      this.bindMethods();
+      __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    }
+    bindMethods() {
+      this.mutate = this.mutate.bind(this);
+      this.reset = this.reset.bind(this);
+    }
+    setOptions(options) {
+      const prevOptions = this.options;
+      this.options = __privateGet(this, _client4).defaultMutationOptions(options);
+      if (!shallowEqualObjects(this.options, prevOptions)) {
+        __privateGet(this, _client4).getMutationCache().notify({
+          type: "observerOptionsUpdated",
+          mutation: __privateGet(this, _currentMutation),
+          observer: this
+        });
+      }
+      if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) {
+        this.reset();
+      } else if (__privateGet(this, _currentMutation)?.state.status === "pending") {
+        __privateGet(this, _currentMutation).setOptions(this.options);
+      }
+    }
+    onUnsubscribe() {
+      if (!this.hasListeners()) {
+        __privateGet(this, _currentMutation)?.removeObserver(this);
+      }
+    }
+    onMutationUpdate(action) {
+      __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+      __privateMethod(this, _MutationObserver_instances, notify_fn2).call(this, action);
+    }
+    getCurrentResult() {
+      return __privateGet(this, _currentResult2);
+    }
+    reset() {
+      __privateGet(this, _currentMutation)?.removeObserver(this);
+      __privateSet(this, _currentMutation, void 0);
+      __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+      __privateMethod(this, _MutationObserver_instances, notify_fn2).call(this);
+    }
+    mutate(variables, options) {
+      __privateSet(this, _mutateOptions, options);
+      __privateGet(this, _currentMutation)?.removeObserver(this);
+      __privateSet(this, _currentMutation, __privateGet(this, _client4).getMutationCache().build(__privateGet(this, _client4), this.options));
+      __privateGet(this, _currentMutation).addObserver(this);
+      return __privateGet(this, _currentMutation).execute(variables);
+    }
+  }, _client4 = new WeakMap(), _currentResult2 = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _MutationObserver_instances = new WeakSet(), updateResult_fn = function() {
+    const state = __privateGet(this, _currentMutation)?.state ?? getDefaultState2();
+    __privateSet(this, _currentResult2, {
+      ...state,
+      isPending: state.status === "pending",
+      isSuccess: state.status === "success",
+      isError: state.status === "error",
+      isIdle: state.status === "idle",
+      mutate: this.mutate,
+      reset: this.reset
+    });
+  }, notify_fn2 = function(action) {
+    notifyManager.batch(() => {
+      if (__privateGet(this, _mutateOptions) && this.hasListeners()) {
+        const variables = __privateGet(this, _currentResult2).variables;
+        const onMutateResult = __privateGet(this, _currentResult2).context;
+        const context = {
+          client: __privateGet(this, _client4),
+          meta: this.options.meta,
+          mutationKey: this.options.mutationKey
+        };
+        if (action?.type === "success") {
+          try {
+            __privateGet(this, _mutateOptions).onSuccess?.(
+              action.data,
+              variables,
+              onMutateResult,
+              context
+            );
+          } catch (e3) {
+            void Promise.reject(e3);
+          }
+          try {
+            __privateGet(this, _mutateOptions).onSettled?.(
+              action.data,
+              null,
+              variables,
+              onMutateResult,
+              context
+            );
+          } catch (e3) {
+            void Promise.reject(e3);
+          }
+        } else if (action?.type === "error") {
+          try {
+            __privateGet(this, _mutateOptions).onError?.(
+              action.error,
+              variables,
+              onMutateResult,
+              context
+            );
+          } catch (e3) {
+            void Promise.reject(e3);
+          }
+          try {
+            __privateGet(this, _mutateOptions).onSettled?.(
+              void 0,
+              action.error,
+              variables,
+              onMutateResult,
+              context
+            );
+          } catch (e3) {
+            void Promise.reject(e3);
+          }
+        }
+      }
+      this.listeners.forEach((listener) => {
+        listener(__privateGet(this, _currentResult2));
+      });
+    });
+  }, _a9);
+
+  // node_modules/@tanstack/query-core/build/modern/queryCache.js
+  var _queries, _a10;
+  var QueryCache = (_a10 = class extends Subscribable {
+    constructor(config = {}) {
+      super();
+      __privateAdd(this, _queries);
+      this.config = config;
+      __privateSet(this, _queries, /* @__PURE__ */ new Map());
+    }
+    build(client, options, state) {
+      const queryKey = options.queryKey;
+      const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
+      let query = this.get(queryHash);
+      if (!query) {
+        query = new Query({
+          client,
+          queryKey,
+          queryHash,
+          options: client.defaultQueryOptions(options),
+          state,
+          defaultOptions: client.getQueryDefaults(queryKey)
+        });
+        this.add(query);
+      }
+      return query;
+    }
+    add(query) {
+      if (!__privateGet(this, _queries).has(query.queryHash)) {
+        __privateGet(this, _queries).set(query.queryHash, query);
+        this.notify({
+          type: "added",
+          query
+        });
+      }
+    }
+    remove(query) {
+      const queryInMap = __privateGet(this, _queries).get(query.queryHash);
+      if (queryInMap) {
+        query.destroy();
+        if (queryInMap === query) {
+          __privateGet(this, _queries).delete(query.queryHash);
+        }
+        this.notify({ type: "removed", query });
+      }
+    }
+    clear() {
+      notifyManager.batch(() => {
+        this.getAll().forEach((query) => {
+          this.remove(query);
+        });
+      });
+    }
+    get(queryHash) {
+      return __privateGet(this, _queries).get(queryHash);
+    }
+    getAll() {
+      return [...__privateGet(this, _queries).values()];
+    }
+    find(filters) {
+      const defaultedFilters = { exact: true, ...filters };
+      return this.getAll().find(
+        (query) => matchQuery(defaultedFilters, query)
+      );
+    }
+    findAll(filters = {}) {
+      const queries = this.getAll();
+      return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
+    }
+    notify(event) {
+      notifyManager.batch(() => {
+        this.listeners.forEach((listener) => {
+          listener(event);
+        });
+      });
+    }
+    onFocus() {
+      notifyManager.batch(() => {
+        this.getAll().forEach((query) => {
+          query.onFocus();
+        });
+      });
+    }
+    onOnline() {
+      notifyManager.batch(() => {
+        this.getAll().forEach((query) => {
+          query.onOnline();
+        });
+      });
+    }
+  }, _queries = new WeakMap(), _a10);
+
+  // node_modules/@tanstack/query-core/build/modern/queryClient.js
+  var _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _a11;
+  var QueryClient = (_a11 = class {
+    constructor(config = {}) {
+      __privateAdd(this, _queryCache);
+      __privateAdd(this, _mutationCache2);
+      __privateAdd(this, _defaultOptions2);
+      __privateAdd(this, _queryDefaults);
+      __privateAdd(this, _mutationDefaults);
+      __privateAdd(this, _mountCount);
+      __privateAdd(this, _unsubscribeFocus);
+      __privateAdd(this, _unsubscribeOnline);
+      __privateSet(this, _queryCache, config.queryCache || new QueryCache());
+      __privateSet(this, _mutationCache2, config.mutationCache || new MutationCache());
+      __privateSet(this, _defaultOptions2, config.defaultOptions || {});
+      __privateSet(this, _queryDefaults, /* @__PURE__ */ new Map());
+      __privateSet(this, _mutationDefaults, /* @__PURE__ */ new Map());
+      __privateSet(this, _mountCount, 0);
+    }
+    mount() {
+      __privateWrapper(this, _mountCount)._++;
+      if (__privateGet(this, _mountCount) !== 1) return;
+      __privateSet(this, _unsubscribeFocus, focusManager.subscribe(async (focused) => {
+        if (focused) {
+          await this.resumePausedMutations();
+          __privateGet(this, _queryCache).onFocus();
+        }
+      }));
+      __privateSet(this, _unsubscribeOnline, onlineManager.subscribe(async (online) => {
+        if (online) {
+          await this.resumePausedMutations();
+          __privateGet(this, _queryCache).onOnline();
+        }
+      }));
+    }
+    unmount() {
+      var _a12, _b;
+      __privateWrapper(this, _mountCount)._--;
+      if (__privateGet(this, _mountCount) !== 0) return;
+      (_a12 = __privateGet(this, _unsubscribeFocus)) == null ? void 0 : _a12.call(this);
+      __privateSet(this, _unsubscribeFocus, void 0);
+      (_b = __privateGet(this, _unsubscribeOnline)) == null ? void 0 : _b.call(this);
+      __privateSet(this, _unsubscribeOnline, void 0);
+    }
+    isFetching(filters) {
+      return __privateGet(this, _queryCache).findAll({ ...filters, fetchStatus: "fetching" }).length;
+    }
+    isMutating(filters) {
+      return __privateGet(this, _mutationCache2).findAll({ ...filters, status: "pending" }).length;
+    }
+    /**
+     * Imperative (non-reactive) way to retrieve data for a QueryKey.
+     * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+     *
+     * Hint: Do not use this function inside a component, because it won't receive updates.
+     * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+     */
+    getQueryData(queryKey) {
+      const options = this.defaultQueryOptions({ queryKey });
+      return __privateGet(this, _queryCache).get(options.queryHash)?.state.data;
+    }
+    ensureQueryData(options) {
+      const defaultedOptions = this.defaultQueryOptions(options);
+      const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
+      const cachedData = query.state.data;
+      if (cachedData === void 0) {
+        return this.fetchQuery(options);
+      }
+      if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) {
+        void this.prefetchQuery(defaultedOptions);
+      }
+      return Promise.resolve(cachedData);
+    }
+    getQueriesData(filters) {
+      return __privateGet(this, _queryCache).findAll(filters).map(({ queryKey, state }) => {
+        const data = state.data;
+        return [queryKey, data];
+      });
+    }
+    setQueryData(queryKey, updater, options) {
+      const defaultedOptions = this.defaultQueryOptions({ queryKey });
+      const query = __privateGet(this, _queryCache).get(
+        defaultedOptions.queryHash
+      );
+      const prevData = query?.state.data;
+      const data = functionalUpdate(updater, prevData);
+      if (data === void 0) {
+        return void 0;
+      }
+      return __privateGet(this, _queryCache).build(this, defaultedOptions).setData(data, { ...options, manual: true });
+    }
+    setQueriesData(filters, updater, options) {
+      return notifyManager.batch(
+        () => __privateGet(this, _queryCache).findAll(filters).map(({ queryKey }) => [
+          queryKey,
+          this.setQueryData(queryKey, updater, options)
+        ])
+      );
+    }
+    getQueryState(queryKey) {
+      const options = this.defaultQueryOptions({ queryKey });
+      return __privateGet(this, _queryCache).get(
+        options.queryHash
+      )?.state;
+    }
+    removeQueries(filters) {
+      const queryCache = __privateGet(this, _queryCache);
+      notifyManager.batch(() => {
+        queryCache.findAll(filters).forEach((query) => {
+          queryCache.remove(query);
+        });
+      });
+    }
+    resetQueries(filters, options) {
+      const queryCache = __privateGet(this, _queryCache);
+      return notifyManager.batch(() => {
+        queryCache.findAll(filters).forEach((query) => {
+          query.reset();
+        });
+        return this.refetchQueries(
+          {
+            type: "active",
+            ...filters
+          },
+          options
+        );
+      });
+    }
+    cancelQueries(filters, cancelOptions = {}) {
+      const defaultedCancelOptions = { revert: true, ...cancelOptions };
+      const promises = notifyManager.batch(
+        () => __privateGet(this, _queryCache).findAll(filters).map((query) => query.cancel(defaultedCancelOptions))
+      );
+      return Promise.all(promises).then(noop).catch(noop);
+    }
+    invalidateQueries(filters, options = {}) {
+      return notifyManager.batch(() => {
+        __privateGet(this, _queryCache).findAll(filters).forEach((query) => {
+          query.invalidate();
+        });
+        if (filters?.refetchType === "none") {
+          return Promise.resolve();
+        }
+        return this.refetchQueries(
+          {
+            ...filters,
+            type: filters?.refetchType ?? filters?.type ?? "active"
+          },
+          options
+        );
+      });
+    }
+    refetchQueries(filters, options = {}) {
+      const fetchOptions = {
+        ...options,
+        cancelRefetch: options.cancelRefetch ?? true
+      };
+      const promises = notifyManager.batch(
+        () => __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => {
+          let promise = query.fetch(void 0, fetchOptions);
+          if (!fetchOptions.throwOnError) {
+            promise = promise.catch(noop);
+          }
+          return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
+        })
+      );
+      return Promise.all(promises).then(noop);
+    }
+    fetchQuery(options) {
+      const defaultedOptions = this.defaultQueryOptions(options);
+      if (defaultedOptions.retry === void 0) {
+        defaultedOptions.retry = false;
+      }
+      const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
+      return query.isStaleByTime(
+        resolveStaleTime(defaultedOptions.staleTime, query)
+      ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+    }
+    prefetchQuery(options) {
+      return this.fetchQuery(options).then(noop).catch(noop);
+    }
+    fetchInfiniteQuery(options) {
+      options._type = "infinite";
+      return this.fetchQuery(options);
+    }
+    prefetchInfiniteQuery(options) {
+      return this.fetchInfiniteQuery(options).then(noop).catch(noop);
+    }
+    ensureInfiniteQueryData(options) {
+      options._type = "infinite";
+      return this.ensureQueryData(options);
+    }
+    resumePausedMutations() {
+      if (onlineManager.isOnline()) {
+        return __privateGet(this, _mutationCache2).resumePausedMutations();
+      }
+      return Promise.resolve();
+    }
+    getQueryCache() {
+      return __privateGet(this, _queryCache);
+    }
+    getMutationCache() {
+      return __privateGet(this, _mutationCache2);
+    }
+    getDefaultOptions() {
+      return __privateGet(this, _defaultOptions2);
+    }
+    setDefaultOptions(options) {
+      __privateSet(this, _defaultOptions2, options);
+    }
+    setQueryDefaults(queryKey, options) {
+      __privateGet(this, _queryDefaults).set(hashKey(queryKey), {
+        queryKey,
+        defaultOptions: options
+      });
+    }
+    getQueryDefaults(queryKey) {
+      const defaults = [...__privateGet(this, _queryDefaults).values()];
+      const result = {};
+      defaults.forEach((queryDefault) => {
+        if (partialMatchKey(queryKey, queryDefault.queryKey)) {
+          Object.assign(result, queryDefault.defaultOptions);
+        }
+      });
+      return result;
+    }
+    setMutationDefaults(mutationKey, options) {
+      __privateGet(this, _mutationDefaults).set(hashKey(mutationKey), {
+        mutationKey,
+        defaultOptions: options
+      });
+    }
+    getMutationDefaults(mutationKey) {
+      const defaults = [...__privateGet(this, _mutationDefaults).values()];
+      const result = {};
+      defaults.forEach((queryDefault) => {
+        if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {
+          Object.assign(result, queryDefault.defaultOptions);
+        }
+      });
+      return result;
+    }
+    defaultQueryOptions(options) {
+      if (options._defaulted) {
+        return options;
+      }
+      const defaultedOptions = {
+        ...__privateGet(this, _defaultOptions2).queries,
+        ...this.getQueryDefaults(options.queryKey),
+        ...options,
+        _defaulted: true
+      };
+      if (!defaultedOptions.queryHash) {
+        defaultedOptions.queryHash = hashQueryKeyByOptions(
+          defaultedOptions.queryKey,
+          defaultedOptions
+        );
+      }
+      if (defaultedOptions.refetchOnReconnect === void 0) {
+        defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
+      }
+      if (defaultedOptions.throwOnError === void 0) {
+        defaultedOptions.throwOnError = !!defaultedOptions.suspense;
+      }
+      if (!defaultedOptions.networkMode && defaultedOptions.persister) {
+        defaultedOptions.networkMode = "offlineFirst";
+      }
+      if (defaultedOptions.queryFn === skipToken) {
+        defaultedOptions.enabled = false;
+      }
+      return defaultedOptions;
+    }
+    defaultMutationOptions(options) {
+      if (options?._defaulted) {
+        return options;
+      }
+      return {
+        ...__privateGet(this, _defaultOptions2).mutations,
+        ...options?.mutationKey && this.getMutationDefaults(options.mutationKey),
+        ...options,
+        _defaulted: true
+      };
+    }
+    clear() {
+      __privateGet(this, _queryCache).clear();
+      __privateGet(this, _mutationCache2).clear();
+    }
+  }, _queryCache = new WeakMap(), _mutationCache2 = new WeakMap(), _defaultOptions2 = new WeakMap(), _queryDefaults = new WeakMap(), _mutationDefaults = new WeakMap(), _mountCount = new WeakMap(), _unsubscribeFocus = new WeakMap(), _unsubscribeOnline = new WeakMap(), _a11);
+
+  // node_modules/preact/hooks/dist/hooks.module.js
+  var t2;
+  var r2;
+  var u2;
+  var i2;
+  var o2 = 0;
+  var f2 = [];
+  var c2 = l;
+  var e2 = c2.__b;
+  var a2 = c2.__r;
+  var v2 = c2.diffed;
+  var l2 = c2.__c;
+  var m2 = c2.unmount;
+  var s2 = c2.__;
+  function p2(n2, t3) {
+    c2.__h && c2.__h(r2, n2, o2 || t3), o2 = 0;
+    var u4 = r2.__H || (r2.__H = { __: [], __h: [] });
+    return n2 >= u4.__.length && u4.__.push({}), u4.__[n2];
+  }
+  function d2(n2) {
+    return o2 = 1, h2(D2, n2);
+  }
+  function h2(n2, u4, i3) {
+    var o3 = p2(t2++, 2);
+    if (o3.t = n2, !o3.__c && (o3.__ = [i3 ? i3(u4) : D2(void 0, u4), function(n3) {
+      var t3 = o3.__N ? o3.__N[0] : o3.__[0], r3 = o3.t(t3, n3);
+      t3 !== r3 && (o3.__N = [r3, o3.__[1]], o3.__c.setState({}));
+    }], o3.__c = r2, !r2.__f)) {
+      var f4 = function(n3, t3, r3) {
+        if (!o3.__c.__H) return true;
+        var u5 = o3.__c.__H.__.filter(function(n4) {
+          return n4.__c;
+        });
+        if (u5.every(function(n4) {
+          return !n4.__N;
+        })) return !c3 || c3.call(this, n3, t3, r3);
+        var i4 = o3.__c.props !== n3;
+        return u5.some(function(n4) {
+          if (n4.__N) {
+            var t4 = n4.__[0];
+            n4.__ = n4.__N, n4.__N = void 0, t4 !== n4.__[0] && (i4 = true);
+          }
+        }), c3 && c3.call(this, n3, t3, r3) || i4;
+      };
+      r2.__f = true;
+      var c3 = r2.shouldComponentUpdate, e3 = r2.componentWillUpdate;
+      r2.componentWillUpdate = function(n3, t3, r3) {
+        if (this.__e) {
+          var u5 = c3;
+          c3 = void 0, f4(n3, t3, r3), c3 = u5;
+        }
+        e3 && e3.call(this, n3, t3, r3);
+      }, r2.shouldComponentUpdate = f4;
+    }
+    return o3.__N || o3.__;
+  }
+  function y2(n2, u4) {
+    var i3 = p2(t2++, 3);
+    !c2.__s && C2(i3.__H, u4) && (i3.__ = n2, i3.u = u4, r2.__H.__h.push(i3));
+  }
+  function _2(n2, u4) {
+    var i3 = p2(t2++, 4);
+    !c2.__s && C2(i3.__H, u4) && (i3.__ = n2, i3.u = u4, r2.__h.push(i3));
+  }
+  function A2(n2) {
+    return o2 = 5, T2(function() {
+      return { current: n2 };
+    }, []);
+  }
+  function T2(n2, r3) {
+    var u4 = p2(t2++, 7);
+    return C2(u4.__H, r3) && (u4.__ = n2(), u4.__H = r3, u4.__h = n2), u4.__;
+  }
+  function q2(n2, t3) {
+    return o2 = 8, T2(function() {
+      return n2;
+    }, t3);
+  }
+  function x2(n2) {
+    var u4 = r2.context[n2.__c], i3 = p2(t2++, 9);
+    return i3.c = n2, u4 ? (null == i3.__ && (i3.__ = true, u4.sub(r2)), u4.props.value) : n2.__;
+  }
+  function j2() {
+    for (var n2; n2 = f2.shift(); ) {
+      var t3 = n2.__H;
+      if (n2.__P && t3) try {
+        t3.__h.some(z2), t3.__h.some(B2), t3.__h = [];
+      } catch (r3) {
+        t3.__h = [], c2.__e(r3, n2.__v);
+      }
+    }
+  }
+  c2.__b = function(n2) {
+    r2 = null, e2 && e2(n2);
+  }, c2.__ = function(n2, t3) {
+    n2 && t3.__k && t3.__k.__m && (n2.__m = t3.__k.__m), s2 && s2(n2, t3);
+  }, c2.__r = function(n2) {
+    a2 && a2(n2), t2 = 0;
+    var i3 = (r2 = n2.__c).__H;
+    i3 && (u2 === r2 ? (i3.__h = [], r2.__h = [], i3.__.some(function(n3) {
+      n3.__N && (n3.__ = n3.__N), n3.u = n3.__N = void 0;
+    })) : (i3.__h.some(z2), i3.__h.some(B2), i3.__h = [], t2 = 0)), u2 = r2;
+  }, c2.diffed = function(n2) {
+    v2 && v2(n2);
+    var t3 = n2.__c;
+    t3 && t3.__H && (t3.__H.__h.length && (1 !== f2.push(t3) && i2 === c2.requestAnimationFrame || ((i2 = c2.requestAnimationFrame) || w2)(j2)), t3.__H.__.some(function(n3) {
+      n3.u && (n3.__H = n3.u), n3.u = void 0;
+    })), u2 = r2 = null;
+  }, c2.__c = function(n2, t3) {
+    t3.some(function(n3) {
+      try {
+        n3.__h.some(z2), n3.__h = n3.__h.filter(function(n4) {
+          return !n4.__ || B2(n4);
+        });
+      } catch (r3) {
+        t3.some(function(n4) {
+          n4.__h && (n4.__h = []);
+        }), t3 = [], c2.__e(r3, n3.__v);
+      }
+    }), l2 && l2(n2, t3);
+  }, c2.unmount = function(n2) {
+    m2 && m2(n2);
+    var t3, r3 = n2.__c;
+    r3 && r3.__H && (r3.__H.__.some(function(n3) {
+      try {
+        z2(n3);
+      } catch (n4) {
+        t3 = n4;
+      }
+    }), r3.__H = void 0, t3 && c2.__e(t3, r3.__v));
+  };
+  var k2 = "function" == typeof requestAnimationFrame;
+  function w2(n2) {
+    var t3, r3 = function() {
+      clearTimeout(u4), k2 && cancelAnimationFrame(t3), setTimeout(n2);
+    }, u4 = setTimeout(r3, 35);
+    k2 && (t3 = requestAnimationFrame(r3));
+  }
+  function z2(n2) {
+    var t3 = r2, u4 = n2.__c;
+    "function" == typeof u4 && (n2.__c = void 0, u4()), r2 = t3;
+  }
+  function B2(n2) {
+    var t3 = r2;
+    n2.__c = n2.__(), r2 = t3;
+  }
+  function C2(n2, t3) {
+    return !n2 || n2.length !== t3.length || t3.some(function(t4, r3) {
+      return t4 !== n2[r3];
+    });
+  }
+  function D2(n2, t3) {
+    return "function" == typeof t3 ? t3(n2) : t3;
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/IsRestoringProvider.js
+  var IsRestoringContext = R(false);
+  var useIsRestoring = () => x2(IsRestoringContext);
+  var IsRestoringProvider = IsRestoringContext.Provider;
+
+  // node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js
+  var f3 = 0;
+  function u3(e3, t3, n2, o3, i3, u4) {
+    t3 || (t3 = {});
+    var a3, c3, p3 = t3;
+    if ("ref" in p3) for (c3 in p3 = {}, t3) "ref" == c3 ? a3 = t3[c3] : p3[c3] = t3[c3];
+    var l3 = { type: e3, props: p3, key: n2, ref: a3, __k: null, __: null, __b: 0, __e: null, __c: null, constructor: void 0, __v: --f3, __i: -1, __u: 0, __source: i3, __self: u4 };
+    if ("function" == typeof e3 && (a3 = e3.defaultProps)) for (c3 in a3) void 0 === p3[c3] && (p3[c3] = a3[c3]);
+    return l.vnode && l.vnode(l3), l3;
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/QueryClientProvider.js
+  var QueryClientContext = R(
+    void 0
+  );
+  var useQueryClient = (queryClient2) => {
+    const client = x2(QueryClientContext);
+    if (queryClient2) {
+      return queryClient2;
+    }
+    if (!client) {
+      throw new Error("No QueryClient set, use QueryClientProvider to set one");
+    }
+    return client;
+  };
+  var QueryClientProvider = ({
+    client,
+    children
+  }) => {
+    y2(() => {
+      client.mount();
+      return () => {
+        client.unmount();
+      };
+    }, [client]);
+    return /* @__PURE__ */ u3(QueryClientContext.Provider, { value: client, children });
+  };
+
+  // node_modules/@tanstack/preact-query/build/modern/QueryErrorResetBoundary.js
+  function createValue() {
+    let isReset = false;
+    return {
+      clearReset: () => {
+        isReset = false;
+      },
+      reset: () => {
+        isReset = true;
+      },
+      isReset: () => {
+        return isReset;
+      }
+    };
+  }
+  var QueryErrorResetBoundaryContext = R(createValue());
+  var useQueryErrorResetBoundary = () => x2(QueryErrorResetBoundaryContext);
+
+  // node_modules/@tanstack/preact-query/build/modern/errorBoundaryUtils.js
+  var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+    if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
+      if (!errorResetBoundary.isReset()) {
+        options.retryOnMount = false;
+      }
+    }
+  };
+  var useClearResetErrorBoundary = (errorResetBoundary) => {
+    y2(() => {
+      errorResetBoundary.clearReset();
+    }, [errorResetBoundary]);
+  };
+  var getHasError = ({
+    result,
+    errorResetBoundary,
+    throwOnError,
+    query,
+    suspense
+  }) => {
+    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+  };
+
+  // node_modules/@tanstack/preact-query/build/modern/suspense.js
+  var ensureSuspenseTimers = (defaultedOptions) => {
+    if (defaultedOptions.suspense) {
+      const MIN_SUSPENSE_TIME_MS = 1e3;
+      const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+      const originalStaleTime = defaultedOptions.staleTime;
+      defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
+      if (typeof defaultedOptions.gcTime === "number") {
+        defaultedOptions.gcTime = Math.max(
+          defaultedOptions.gcTime,
+          MIN_SUSPENSE_TIME_MS
+        );
+      }
+    }
+  };
+  var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+  var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
+  var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+    errorResetBoundary.clearReset();
+  });
+
+  // node_modules/@tanstack/preact-query/build/modern/utils.js
+  function useSyncExternalStore(subscribe, getSnapshot) {
+    const value = getSnapshot();
+    const [{ _instance }, forceUpdate] = d2({
+      _instance: { _value: value, _getSnapshot: getSnapshot }
+    });
+    _2(() => {
+      _instance._value = value;
+      _instance._getSnapshot = getSnapshot;
+      if (didSnapshotChange(_instance)) {
+        forceUpdate({ _instance });
+      }
+    }, [subscribe, value, getSnapshot]);
+    y2(() => {
+      if (didSnapshotChange(_instance)) {
+        forceUpdate({ _instance });
+      }
+      return subscribe(() => {
+        if (didSnapshotChange(_instance)) {
+          forceUpdate({ _instance });
+        }
+      });
+    }, [subscribe]);
+    return value;
+  }
+  function didSnapshotChange(inst) {
+    const latestGetSnapshot = inst._getSnapshot;
+    const prevValue = inst._value;
+    try {
+      const nextValue = latestGetSnapshot();
+      return !Object.is(prevValue, nextValue);
+    } catch (_error) {
+      return true;
+    }
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/useBaseQuery.js
+  function useBaseQuery(options, Observer, queryClient2) {
+    if (true) {
+      if (typeof options !== "object" || Array.isArray(options)) {
+        throw new Error(
+          'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+        );
+      }
+    }
+    const isRestoring = useIsRestoring();
+    const errorResetBoundary = useQueryErrorResetBoundary();
+    const client = useQueryClient(queryClient2);
+    const defaultedOptions = client.defaultQueryOptions(options);
+    client.getDefaultOptions().queries?._experimental_beforeQuery?.(
+      defaultedOptions
+    );
+    if (true) {
+      if (!defaultedOptions.queryFn) {
+        console.error(
+          `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+        );
+      }
+    }
+    defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+    ensureSuspenseTimers(defaultedOptions);
+    ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+    useClearResetErrorBoundary(errorResetBoundary);
+    const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+    const [observer] = d2(
+      () => new Observer(
+        client,
+        defaultedOptions
+      )
+    );
+    const result = observer.getOptimisticResult(defaultedOptions);
+    const shouldSubscribe = !isRestoring && options.subscribed !== false;
+    useSyncExternalStore(
+      q2(
+        (onStoreChange) => {
+          const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+          observer.updateResult();
+          return unsubscribe;
+        },
+        [observer, shouldSubscribe]
+      ),
+      () => observer.getCurrentResult()
+    );
+    y2(() => {
+      observer.setOptions(defaultedOptions);
+    }, [defaultedOptions, observer]);
+    if (shouldSuspend(defaultedOptions, result)) {
+      throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+    }
+    if (getHasError({
+      result,
+      errorResetBoundary,
+      throwOnError: defaultedOptions.throwOnError,
+      query: client.getQueryCache().get(defaultedOptions.queryHash),
+      suspense: defaultedOptions.suspense
+    })) {
+      throw result.error;
+    }
+    ;
+    client.getDefaultOptions().queries?._experimental_afterQuery?.(
+      defaultedOptions,
+      result
+    );
+    if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) {
+      const promise = isNewCacheEntry ? (
+        // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+        fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+      ) : (
+        // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+        client.getQueryCache().get(defaultedOptions.queryHash)?.promise
+      );
+      promise?.catch(noop).finally(() => {
+        observer.updateResult();
+      });
+    }
+    return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/useQuery.js
+  function useQuery(options, queryClient2) {
+    return useBaseQuery(options, QueryObserver, queryClient2);
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/useMutation.js
+  function useMutation(options, queryClient2) {
+    const client = useQueryClient(queryClient2);
+    const [observer] = d2(
+      () => new MutationObserver(
+        client,
+        options
+      )
+    );
+    y2(() => {
+      observer.setOptions(options);
+    }, [observer, options]);
+    const result = useSyncExternalStore(
+      q2(
+        (onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
+        [observer]
+      ),
+      () => observer.getCurrentResult()
+    );
+    const mutate = q2(
+      (variables, mutateOptions) => {
+        observer.mutate(variables, mutateOptions).catch(noop);
+      },
+      [observer]
+    );
+    if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) {
+      throw result.error;
+    }
+    return { ...result, mutate, mutateAsync: result.mutate };
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/useInfiniteQuery.js
+  function useInfiniteQuery(options, queryClient2) {
+    return useBaseQuery(
+      options,
+      InfiniteQueryObserver,
+      queryClient2
+    );
+  }
+
+  // app/assets/typescript/profiler/api-fetcher.ts
+  async function apiFetch(config) {
+    const { url, method, params, data, headers = {}, signal } = config;
+    const qs = params ? "?" + new URLSearchParams(Object.entries(params).map(([k3, v3]) => [k3, String(v3)])).toString() : "";
+    const res = await fetch(url + qs, {
+      method,
+      signal,
+      headers: data !== void 0 ? { "Content-Type": "application/json", ...headers } : headers,
+      body: data !== void 0 ? JSON.stringify(data) : void 0
+    });
+    if (res.status === 204) return {};
+    const json = await res.json();
+    if (!res.ok) {
+      throw Object.assign(new Error(json?.error ?? `HTTP ${res.status}`), { status: res.status, data: json });
+    }
+    return json;
+  }
+
+  // app/assets/typescript/profiler/generated/api.ts
+  var listConsoles = (params, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/console`,
+        method: "GET",
+        params,
+        signal
+      }
+    );
+  };
+  var getListConsolesInfiniteQueryKey = (params) => {
+    return [
+      "infinite",
+      `/_profiler/api/console`,
+      ...params ? [params] : []
+    ];
+  };
+  var getListConsolesInfiniteQueryOptions = (params, options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getListConsolesInfiniteQueryKey(params);
+    const queryFn = ({ signal }) => listConsoles(params, signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useListConsolesInfinite(params, options) {
+    const queryOptions = getListConsolesInfiniteQueryOptions(params, options);
+    const query = useInfiniteQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var deleteConsole = (id) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/console/${id}`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getDeleteConsoleMutationOptions = (options) => {
+    const mutationKey = ["deleteConsole"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { id } = props ?? {};
+      return deleteConsole(id);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useDeleteConsole = (options) => {
+    const mutationOptions = getDeleteConsoleMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var clearConsoles = () => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/console/clear`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getClearConsolesMutationOptions = (options) => {
+    const mutationKey = ["clearConsoles"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = () => {
+      return clearConsoles();
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useClearConsoles = (options) => {
+    const mutationOptions = getClearConsolesMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var getEnvVars = (signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/env_vars`,
+        method: "GET",
+        signal
+      }
+    );
+  };
+  var getGetEnvVarsQueryKey = () => {
+    return [
+      `/_profiler/api/env_vars`
+    ];
+  };
+  var getGetEnvVarsQueryOptions = (options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getGetEnvVarsQueryKey();
+    const queryFn = ({ signal }) => getEnvVars(signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useGetEnvVars(options) {
+    const queryOptions = getGetEnvVarsQueryOptions(options);
+    const query = useQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var updateEnvVar = (updateEnvVarBody) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/env_vars`,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        data: updateEnvVarBody
+      }
+    );
+  };
+  var getUpdateEnvVarMutationOptions = (options) => {
+    const mutationKey = ["updateEnvVar"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { data } = props ?? {};
+      return updateEnvVar(data);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useUpdateEnvVar = (options) => {
+    const mutationOptions = getUpdateEnvVarMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var resetEnvVar = (params) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/env_vars/reset`,
+        method: "DELETE",
+        params
+      }
+    );
+  };
+  var getResetEnvVarMutationOptions = (options) => {
+    const mutationKey = ["resetEnvVar"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { params } = props ?? {};
+      return resetEnvVar(params);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useResetEnvVar = (options) => {
+    const mutationOptions = getResetEnvVarMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var resetAllEnvVars = () => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/env_vars/reset_all`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getResetAllEnvVarsMutationOptions = (options) => {
+    const mutationKey = ["resetAllEnvVars"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = () => {
+      return resetAllEnvVars();
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useResetAllEnvVars = (options) => {
+    const mutationOptions = getResetAllEnvVarsMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var explainQuery = (explainQueryBody, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/explain`,
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        data: explainQueryBody,
+        signal
       }
-    }
-  }
-  c2.__b = function(n2) {
-    r2 = null, e2 && e2(n2);
-  }, c2.__ = function(n2, t3) {
-    n2 && t3.__k && t3.__k.__m && (n2.__m = t3.__k.__m), s2 && s2(n2, t3);
-  }, c2.__r = function(n2) {
-    a2 && a2(n2), t2 = 0;
-    var i3 = (r2 = n2.__c).__H;
-    i3 && (u2 === r2 ? (i3.__h = [], r2.__h = [], i3.__.some(function(n3) {
-      n3.__N && (n3.__ = n3.__N), n3.u = n3.__N = void 0;
-    })) : (i3.__h.some(z2), i3.__h.some(B2), i3.__h = [], t2 = 0)), u2 = r2;
-  }, c2.diffed = function(n2) {
-    v2 && v2(n2);
-    var t3 = n2.__c;
-    t3 && t3.__H && (t3.__H.__h.length && (1 !== f2.push(t3) && i2 === c2.requestAnimationFrame || ((i2 = c2.requestAnimationFrame) || w2)(j2)), t3.__H.__.some(function(n3) {
-      n3.u && (n3.__H = n3.u), n3.u = void 0;
-    })), u2 = r2 = null;
-  }, c2.__c = function(n2, t3) {
-    t3.some(function(n3) {
-      try {
-        n3.__h.some(z2), n3.__h = n3.__h.filter(function(n4) {
-          return !n4.__ || B2(n4);
-        });
-      } catch (r3) {
-        t3.some(function(n4) {
-          n4.__h && (n4.__h = []);
-        }), t3 = [], c2.__e(r3, n3.__v);
+    );
+  };
+  var getExplainQueryMutationOptions = (options) => {
+    const mutationKey = ["explainQuery"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { data } = props ?? {};
+      return explainQuery(data);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useExplainQuery = (options) => {
+    const mutationOptions = getExplainQueryMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var updateFunctionProfiling = (updateFunctionProfilingBody) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/function_profiling`,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        data: updateFunctionProfilingBody
       }
-    }), l2 && l2(n2, t3);
-  }, c2.unmount = function(n2) {
-    m2 && m2(n2);
-    var t3, r3 = n2.__c;
-    r3 && r3.__H && (r3.__H.__.some(function(n3) {
-      try {
-        z2(n3);
-      } catch (n4) {
-        t3 = n4;
+    );
+  };
+  var getUpdateFunctionProfilingMutationOptions = (options) => {
+    const mutationKey = ["updateFunctionProfiling"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { data } = props ?? {};
+      return updateFunctionProfiling(data);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useUpdateFunctionProfiling = (options) => {
+    const mutationOptions = getUpdateFunctionProfilingMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var listJobs = (params, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/jobs`,
+        method: "GET",
+        params,
+        signal
       }
-    }), r3.__H = void 0, t3 && c2.__e(t3, r3.__v));
+    );
+  };
+  var getListJobsInfiniteQueryKey = (params) => {
+    return [
+      "infinite",
+      `/_profiler/api/jobs`,
+      ...params ? [params] : []
+    ];
+  };
+  var getListJobsInfiniteQueryOptions = (params, options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getListJobsInfiniteQueryKey(params);
+    const queryFn = ({ signal }) => listJobs(params, signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useListJobsInfinite(params, options) {
+    const queryOptions = getListJobsInfiniteQueryOptions(params, options);
+    const query = useInfiniteQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var deleteJob = (id) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/jobs/${id}`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getDeleteJobMutationOptions = (options) => {
+    const mutationKey = ["deleteJob"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { id } = props ?? {};
+      return deleteJob(id);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useDeleteJob = (options) => {
+    const mutationOptions = getDeleteJobMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var clearJobs = () => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/jobs/clear`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getClearJobsMutationOptions = (options) => {
+    const mutationKey = ["clearJobs"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = () => {
+      return clearJobs();
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useClearJobs = (options) => {
+    const mutationOptions = getClearJobsMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var listOutboundRequests = (signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/outbound_http`,
+        method: "GET",
+        signal
+      }
+    );
+  };
+  var getListOutboundRequestsQueryKey = () => {
+    return [
+      `/_profiler/api/outbound_http`
+    ];
+  };
+  var getListOutboundRequestsQueryOptions = (options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getListOutboundRequestsQueryKey();
+    const queryFn = ({ signal }) => listOutboundRequests(signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useListOutboundRequests(options) {
+    const queryOptions = getListOutboundRequestsQueryOptions(options);
+    const query = useQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var listProfiles = (params, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/profiles`,
+        method: "GET",
+        params,
+        signal
+      }
+    );
+  };
+  var getListProfilesInfiniteQueryKey = (params) => {
+    return [
+      "infinite",
+      `/_profiler/api/profiles`,
+      ...params ? [params] : []
+    ];
+  };
+  var getListProfilesInfiniteQueryOptions = (params, options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getListProfilesInfiniteQueryKey(params);
+    const queryFn = ({ signal }) => listProfiles(params, signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useListProfilesInfinite(params, options) {
+    const queryOptions = getListProfilesInfiniteQueryOptions(params, options);
+    const query = useInfiniteQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var deleteProfile = (id) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/profiles/${id}`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getDeleteProfileMutationOptions = (options) => {
+    const mutationKey = ["deleteProfile"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { id } = props ?? {};
+      return deleteProfile(id);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useDeleteProfile = (options) => {
+    const mutationOptions = getDeleteProfileMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var clearProfiles = () => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/profiles/clear`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getClearProfilesMutationOptions = (options) => {
+    const mutationKey = ["clearProfiles"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = () => {
+      return clearProfiles();
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useClearProfiles = (options) => {
+    const mutationOptions = getClearProfilesMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var getTestRunnerFiles = (params, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/test_runner/files`,
+        method: "GET",
+        params,
+        signal
+      }
+    );
+  };
+  var getGetTestRunnerFilesQueryKey = (params) => {
+    return [
+      `/_profiler/api/test_runner/files`,
+      ...params ? [params] : []
+    ];
+  };
+  var getGetTestRunnerFilesQueryOptions = (params, options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getGetTestRunnerFilesQueryKey(params);
+    const queryFn = ({ signal }) => getTestRunnerFiles(params, signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useGetTestRunnerFiles(params, options) {
+    const queryOptions = getGetTestRunnerFilesQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var createTestRun = (createTestRunBody, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/test_runner/runs`,
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        data: createTestRunBody,
+        signal
+      }
+    );
+  };
+  var getCreateTestRunMutationOptions = (options) => {
+    const mutationKey = ["createTestRun"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { data } = props ?? {};
+      return createTestRun(data);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useCreateTestRun = (options) => {
+    const mutationOptions = getCreateTestRunMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var deleteTestRun = (id) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/test_runner/runs/${id}`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getDeleteTestRunMutationOptions = (options) => {
+    const mutationKey = ["deleteTestRun"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { id } = props ?? {};
+      return deleteTestRun(id);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useDeleteTestRun = (options) => {
+    const mutationOptions = getDeleteTestRunMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var listTests = (params, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/tests`,
+        method: "GET",
+        params,
+        signal
+      }
+    );
+  };
+  var getListTestsInfiniteQueryKey = (params) => {
+    return [
+      "infinite",
+      `/_profiler/api/tests`,
+      ...params ? [params] : []
+    ];
+  };
+  var getListTestsInfiniteQueryOptions = (params, options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getListTestsInfiniteQueryKey(params);
+    const queryFn = ({ signal }) => listTests(params, signal);
+    return { queryKey, queryFn, ...queryOptions };
+  };
+  function useListTestsInfinite(params, options) {
+    const queryOptions = getListTestsInfiniteQueryOptions(params, options);
+    const query = useInfiniteQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+  var deleteTest = (id) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/tests/${id}`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getDeleteTestMutationOptions = (options) => {
+    const mutationKey = ["deleteTest"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = (props) => {
+      const { id } = props ?? {};
+      return deleteTest(id);
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useDeleteTest = (options) => {
+    const mutationOptions = getDeleteTestMutationOptions(options);
+    return useMutation(mutationOptions);
+  };
+  var clearTests = () => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/tests/clear`,
+        method: "DELETE"
+      }
+    );
+  };
+  var getClearTestsMutationOptions = (options) => {
+    const mutationKey = ["clearTests"];
+    const { mutation: mutationOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : { ...options, mutation: { ...options.mutation, mutationKey } } : { mutation: { mutationKey } };
+    const mutationFn = () => {
+      return clearTests();
+    };
+    return { mutationFn, ...mutationOptions };
+  };
+  var useClearTests = (options) => {
+    const mutationOptions = getClearTestsMutationOptions(options);
+    return useMutation(mutationOptions);
   };
-  var k2 = "function" == typeof requestAnimationFrame;
-  function w2(n2) {
-    var t3, r3 = function() {
-      clearTimeout(u4), k2 && cancelAnimationFrame(t3), setTimeout(n2);
-    }, u4 = setTimeout(r3, 35);
-    k2 && (t3 = requestAnimationFrame(r3));
-  }
-  function z2(n2) {
-    var t3 = r2, u4 = n2.__c;
-    "function" == typeof u4 && (n2.__c = void 0, u4()), r2 = t3;
-  }
-  function B2(n2) {
-    var t3 = r2;
-    n2.__c = n2.__(), r2 = t3;
-  }
-  function C2(n2, t3) {
-    return !n2 || n2.length !== t3.length || t3.some(function(t4, r3) {
-      return t4 !== n2[r3];
-    });
-  }
-  function D2(n2, t3) {
-    return "function" == typeof t3 ? t3(n2) : t3;
-  }
 
   // app/assets/typescript/profiler/dashboard/utils.ts
   function getGemVersion() {
@@ -424,17 +3979,6 @@
     return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
   }
 
-  // node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js
-  var f3 = 0;
-  function u3(e3, t3, n2, o3, i3, u4) {
-    t3 || (t3 = {});
-    var a3, c3, p3 = t3;
-    if ("ref" in p3) for (c3 in p3 = {}, t3) "ref" == c3 ? a3 = t3[c3] : p3[c3] = t3[c3];
-    var l3 = { type: e3, props: p3, key: n2, ref: a3, __k: null, __: null, __b: 0, __e: null, __c: null, constructor: void 0, __v: --f3, __i: -1, __u: 0, __source: i3, __self: u4 };
-    if ("function" == typeof e3 && (a3 = e3.defaultProps)) for (c3 in a3) void 0 === p3[c3] && (p3[c3] = a3[c3]);
-    return l.vnode && l.vnode(l3), l3;
-  }
-
   // app/assets/typescript/profiler/components/dashboard/tabs/shared/HttpComponents.tsx
   function CopyButton({ text }) {
     const [copied, setCopied] = d2(false);
@@ -989,32 +4533,6 @@
     if (/^\d+(\.\d+)?$/.test(value)) return false;
     return true;
   }
-  async function patchEnvVar(key, value) {
-    const res = await fetch("/_profiler/api/env_vars", {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ key, value })
-    });
-    if (!res.ok) {
-      const body = await res.json().catch(() => ({}));
-      throw new Error(body.error ?? `Request failed (${res.status})`);
-    }
-    return res.json();
-  }
-  async function resetEnvVar(key) {
-    const res = await fetch(`/_profiler/api/env_vars/reset?key=${encodeURIComponent(key)}`, {
-      method: "DELETE"
-    });
-    if (!res.ok) {
-      const body = await res.json().catch(() => ({}));
-      throw new Error(body.error ?? `Request failed (${res.status})`);
-    }
-    return res.json();
-  }
-  async function resetAllEnvVars() {
-    const res = await fetch("/_profiler/api/env_vars/reset_all", { method: "DELETE" });
-    if (!res.ok) throw new Error(`Request failed (${res.status})`);
-  }
   function EnvTab({ envData, readOnly: forceReadOnly = false }) {
     const [initial, setInitial] = d2(() => ({ ...envData?.variables ?? {} }));
     const [variables, setVariables] = d2(initial);
@@ -1035,6 +4553,9 @@
     const [showImport, setShowImport] = d2(false);
     const [importContent, setImportContent] = d2("");
     const editInputRef = A2(null);
+    const { mutateAsync: patchEnvVar } = useUpdateEnvVar();
+    const { mutateAsync: resetEnvVar2 } = useResetEnvVar();
+    const { mutateAsync: resetAllEnvVars2 } = useResetAllEnvVars();
     y2(() => {
       if (editingKey !== null) editInputRef.current?.focus();
     }, [editingKey]);
@@ -1074,9 +4595,7 @@
     const refresh = async () => {
       setRefreshing(true);
       try {
-        const res = await fetch("/_profiler/api/env_vars");
-        if (!res.ok) throw new Error(`Request failed (${res.status})`);
-        const data = await res.json();
+        const data = await getEnvVars();
         setVariables(data.variables);
         setTotal(data.total);
         setOverrides(data.overrides ?? {});
@@ -1107,7 +4626,7 @@
       if (!entries.length) return;
       setSaving(true);
       try {
-        await Promise.all(entries.map(([k3, v3]) => patchEnvVar(k3, v3)));
+        await Promise.all(entries.map(([k3, v3]) => patchEnvVar({ key: k3, value: v3 })));
         setVariables((prev) => ({ ...prev, ...importPreview }));
         setImportContent("");
         setShowImport(false);
@@ -1135,7 +4654,7 @@
       }
       setSaving(true);
       try {
-        const data = await patchEnvVar(key, editValue);
+        const data = await patchEnvVar({ key, value: editValue });
         setVariables((prev) => ({ ...prev, [key]: editValue }));
         setOverrides((prev) => {
           const n2 = { ...prev };
@@ -1157,7 +4676,7 @@
     const deleteVar = async (key) => {
       setSaving(true);
       try {
-        const data = await patchEnvVar(key, null);
+        const data = await patchEnvVar({ key, value: null });
         setVariables((prev) => {
           const n2 = { ...prev };
           delete n2[key];
@@ -1189,7 +4708,7 @@
       const next = /^(true|yes)$/i.test(current) ? "false" : "true";
       setSaving(true);
       try {
-        const data = await patchEnvVar(key, next);
+        const data = await patchEnvVar({ key, value: next });
         setVariables((prev) => ({ ...prev, [key]: next }));
         setOverrides((prev) => {
           const n2 = { ...prev };
@@ -1211,7 +4730,7 @@
       if (!key) return;
       setSaving(true);
       try {
-        const data = await patchEnvVar(key, newValue);
+        const data = await patchEnvVar({ key, value: newValue });
         setVariables((prev) => ({ ...prev, [key]: newValue }));
         setOverrides((prev) => {
           const n2 = { ...prev };
@@ -1238,7 +4757,7 @@
     const resetVar = async (key) => {
       setSaving(true);
       try {
-        const data = await resetEnvVar(key);
+        const data = await resetEnvVar2({ key });
         setOverrides((prev) => {
           const n2 = { ...prev };
           delete n2[key];
@@ -1265,7 +4784,7 @@
     const doResetAll = async () => {
       setSaving(true);
       try {
-        await resetAllEnvVars();
+        await resetAllEnvVars2({});
         setOverrides({});
         const data = await refresh();
         if (data) setInitial(data.variables);
@@ -1793,40 +5312,27 @@
   var BASE = "/_profiler";
   function TestRunnerContent() {
     const [framework, setFramework] = d2("");
-    const [frameworks, setFrameworks] = d2([]);
-    const [tree, setTree] = d2([]);
     const [selected, setSelected] = d2(/* @__PURE__ */ new Set());
-    const [loading, setLoading] = d2(true);
     const [currentRun, setCurrentRun] = d2(null);
     const [isRunning, setIsRunning] = d2(false);
     const [error, setError] = d2(null);
-    const loadFiles = q2((fw) => {
-      setLoading(true);
-      fetch(`${BASE}/api/test_runner/files?framework=${fw}`).then((r3) => r3.json()).then((data) => {
-        setFrameworks(data.frameworks || []);
-        setTree(data.tree || []);
-        setSelected(/* @__PURE__ */ new Set());
-        setLoading(false);
-      }).catch(() => {
-        setError("Failed to load test files");
-        setLoading(false);
-      });
-    }, []);
+    const { data: filesData, isLoading: loading, refetch: refetchFiles } = useGetTestRunnerFiles(
+      framework ? { framework } : {},
+      { query: { refetchOnWindowFocus: false } }
+    );
+    const { mutateAsync: startTestRun } = useCreateTestRun();
+    const { mutateAsync: killTestRun } = useDeleteTestRun();
+    const frameworks = filesData?.frameworks ?? [];
+    const tree = filesData?.tree ?? [];
     y2(() => {
-      fetch(`${BASE}/api/test_runner/files`).then((r3) => r3.json()).then((data) => {
-        const fws = (data.frameworks || []).map(String);
-        setFrameworks(fws);
-        const defaultFw = fws[0] || "minitest";
-        setFramework(defaultFw);
-        return fetch(`${BASE}/api/test_runner/files?framework=${defaultFw}`);
-      }).then((r3) => r3.json()).then((data) => {
-        setTree(data.tree || []);
-        setLoading(false);
-      }).catch(() => {
-        setError("Failed to load test files");
-        setLoading(false);
-      });
-    }, []);
+      if (!framework && frameworks.length > 0) {
+        setFramework(frameworks[0]);
+      }
+    }, [frameworks]);
+    const loadFiles = q2((fw) => {
+      setSelected(/* @__PURE__ */ new Set());
+      refetchFiles();
+    }, [refetchFiles]);
     y2(() => {
       if (!currentRun || !isRunning) return;
       if (["passed", "failed", "killed", "error"].includes(currentRun.status)) {
@@ -1887,25 +5393,25 @@
       setSelected(new Set(all));
     };
     const selectNone = () => setSelected(/* @__PURE__ */ new Set());
-    const runTests = () => {
+    const runTests = async () => {
       if (selected.size === 0 || isRunning) return;
       setError(null);
-      fetch(`${BASE}/api/test_runner/runs`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ files: Array.from(selected), framework })
-      }).then((r3) => r3.json()).then((data) => {
+      try {
+        const data = await startTestRun({ files: Array.from(selected), framework });
         setCurrentRun(data);
         setIsRunning(true);
-      }).catch(() => setError("Failed to start test run"));
+      } catch {
+        setError("Failed to start test run");
+      }
     };
-    const stopRun = () => {
+    const stopRun = async () => {
       if (!currentRun) return;
-      fetch(`${BASE}/api/test_runner/runs/${currentRun.id}`, { method: "DELETE" }).then(() => {
+      try {
+        await killTestRun({ id: currentRun.id });
         setIsRunning(false);
         setCurrentRun((prev) => prev ? { ...prev, status: "killed" } : prev);
-      }).catch(() => {
-      });
+      } catch {
+      }
     };
     const totalFiles = tree.reduce((n2, d3) => n2 + d3.files.length, 0);
     return /* @__PURE__ */ u3("div", { children: [
@@ -1968,7 +5474,7 @@
   // app/assets/typescript/profiler/components/ProfileList.tsx
   var BASE2 = "/_profiler";
   function TableSkeleton({ cols, rows = 6 }) {
-    return /* @__PURE__ */ u3("div", { children: Array.from({ length: rows }).map((_2, i3) => /* @__PURE__ */ u3("div", { class: "profiler-skeleton__row", children: cols.map((size, j3) => /* @__PURE__ */ u3("div", { class: `profiler-skeleton__cell profiler-skeleton__cell--${size}` }, j3)) }, i3)) });
+    return /* @__PURE__ */ u3("div", { children: Array.from({ length: rows }).map((_3, i3) => /* @__PURE__ */ u3("div", { class: "profiler-skeleton__row", children: cols.map((size, j3) => /* @__PURE__ */ u3("div", { class: `profiler-skeleton__cell profiler-skeleton__cell--${size}` }, j3)) }, i3)) });
   }
   function methodClass(method) {
     const map = { GET: "badge-info", POST: "badge-success", PUT: "badge-warning", PATCH: "badge-warning", DELETE: "badge-error" };
@@ -2015,37 +5521,54 @@
       };
     };
     const [section, setSection] = d2(initialSection);
-    const [profiles, setProfiles] = d2([]);
-    const [httpOffset, setHttpOffset] = d2(0);
-    const [httpHasMore, setHttpHasMore] = d2(false);
-    const [httpLoadingMore, setHttpLoadingMore] = d2(false);
-    const [jobs, setJobs] = d2([]);
-    const [jobOffset, setJobOffset] = d2(0);
-    const [jobHasMore, setJobHasMore] = d2(false);
-    const [jobLoadingMore, setJobLoadingMore] = d2(false);
-    const [consoles, setConsoles] = d2([]);
-    const [consoleOffset, setConsoleOffset] = d2(0);
-    const [consoleHasMore, setConsoleHasMore] = d2(false);
-    const [consoleLoadingMore, setConsoleLoadingMore] = d2(false);
-    const [tests, setTests] = d2([]);
-    const [testOffset, setTestOffset] = d2(0);
-    const [testHasMore, setTestHasMore] = d2(false);
-    const [testLoadingMore, setTestLoadingMore] = d2(false);
-    const [loadingTests, setLoadingTests] = d2(initialSection() === "tests");
-    const [testsLoaded, setTestsLoaded] = d2(false);
-    const [testsError, setTestsError] = d2(null);
-    const [outboundRequests, setOutboundRequests] = d2([]);
-    const [loadingHttp, setLoadingHttp] = d2(initialSection() === "http");
-    const [loadingJobs, setLoadingJobs] = d2(initialSection() === "jobs");
-    const [loadingConsole, setLoadingConsole] = d2(initialSection() === "console");
-    const [loadingOutbound, setLoadingOutbound] = d2(initialSection() === "outbound");
-    const [error, setError] = d2(null);
-    const [jobsError, setJobsError] = d2(null);
-    const [consoleError, setConsoleError] = d2(null);
-    const [outboundError, setOutboundError] = d2(null);
-    const [envData, setEnvData] = d2(void 0);
-    const [loadingEnv, setLoadingEnv] = d2(initialSection() === "env");
-    const [envError, setEnvError] = d2(null);
+    const infiniteOpts = (key) => ({
+      query: {
+        enabled: section === key,
+        getNextPageParam: (lastPage) => lastPage.has_more ? lastPage.offset + lastPage.limit : void 0,
+        initialPageParam: 0,
+        refetchOnWindowFocus: false
+      }
+    });
+    const httpQuery = useListProfilesInfinite({ limit: 50 }, infiniteOpts("http"));
+    const jobsQuery = useListJobsInfinite({ limit: 50 }, infiniteOpts("jobs"));
+    const consolesQuery = useListConsolesInfinite({ limit: 50 }, infiniteOpts("console"));
+    const testsQuery = useListTestsInfinite({ limit: 50 }, infiniteOpts("tests"));
+    const outboundQuery = useListOutboundRequests({ query: { enabled: section === "outbound", refetchOnWindowFocus: false } });
+    const envQuery = useGetEnvVars({ query: { enabled: section === "env", refetchOnWindowFocus: false } });
+    const { mutateAsync: deleteProfileMutation } = useDeleteProfile();
+    const { mutateAsync: clearProfilesMutation } = useClearProfiles();
+    const { mutateAsync: deleteJobMutation } = useDeleteJob();
+    const { mutateAsync: clearJobsMutation } = useClearJobs();
+    const { mutateAsync: deleteConsoleMutation } = useDeleteConsole();
+    const { mutateAsync: clearConsolesMutation } = useClearConsoles();
+    const { mutateAsync: deleteTestMutation } = useDeleteTest();
+    const { mutateAsync: clearTestsMutation } = useClearTests();
+    const profiles = httpQuery.data?.pages.flatMap((p3) => p3.profiles) ?? [];
+    const jobs = jobsQuery.data?.pages.flatMap((p3) => p3.profiles) ?? [];
+    const consoles = consolesQuery.data?.pages.flatMap((p3) => p3.profiles) ?? [];
+    const tests = testsQuery.data?.pages.flatMap((p3) => p3.profiles) ?? [];
+    const outboundRequests = outboundQuery.data ?? [];
+    const envData = envQuery.data;
+    const loadingHttp = httpQuery.isLoading;
+    const loadingJobs = jobsQuery.isLoading;
+    const loadingConsole = consolesQuery.isLoading;
+    const loadingTests = testsQuery.isLoading;
+    const loadingOutbound = outboundQuery.isLoading;
+    const loadingEnv = envQuery.isLoading;
+    const error = httpQuery.error?.message ?? null;
+    const jobsError = jobsQuery.error?.message ?? null;
+    const consoleError = consolesQuery.error?.message ?? null;
+    const testsError = testsQuery.error?.message ?? null;
+    const outboundError = outboundQuery.error?.message ?? null;
+    const envError = envQuery.error?.message ?? null;
+    const httpHasMore = !!httpQuery.hasNextPage;
+    const jobHasMore = !!jobsQuery.hasNextPage;
+    const consoleHasMore = !!consolesQuery.hasNextPage;
+    const testHasMore = !!testsQuery.hasNextPage;
+    const httpLoadingMore = httpQuery.isFetchingNextPage;
+    const jobLoadingMore = jobsQuery.isFetchingNextPage;
+    const consoleLoadingMore = consolesQuery.isFetchingNextPage;
+    const testLoadingMore = testsQuery.isFetchingNextPage;
     const [copiedToken, setCopiedToken] = d2(null);
     const [httpSearch, setHttpSearch] = d2("");
     const [httpMethod, setHttpMethod] = d2("");
@@ -2069,9 +5592,6 @@
     const [outboundSearch, setOutboundSearch] = d2("");
     const [outboundMethod, setOutboundMethod] = d2("");
     const [outboundStatus, setOutboundStatus] = d2("");
-    y2(() => {
-      refreshSection(section);
-    }, []);
     y2(() => {
       const url = new URL(window.location.href);
       if (httpSort.col) {
@@ -2101,71 +5621,27 @@
     const togglePreset = (key) => {
       setHttpPreset((prev) => prev === key ? "" : key);
     };
-    const loadMoreHttp = () => {
-      setHttpLoadingMore(true);
-      fetch(`${BASE2}/api/profiles?limit=50&offset=${httpOffset}`).then((res) => res.json()).then((data) => {
-        setProfiles((prev) => [...prev, ...data.profiles]);
-        setHttpOffset((prev) => prev + data.profiles.length);
-        setHttpHasMore(data.has_more);
-        setHttpLoadingMore(false);
-      }).catch(() => setHttpLoadingMore(false));
-    };
-    const loadMoreJobs = () => {
-      setJobLoadingMore(true);
-      fetch(`${BASE2}/api/jobs?limit=50&offset=${jobOffset}`).then((res) => res.json()).then((data) => {
-        setJobs((prev) => [...prev, ...data.profiles]);
-        setJobOffset((prev) => prev + data.profiles.length);
-        setJobHasMore(data.has_more);
-        setJobLoadingMore(false);
-      }).catch(() => setJobLoadingMore(false));
-    };
-    const loadMoreConsole = () => {
-      setConsoleLoadingMore(true);
-      fetch(`${BASE2}/api/console?limit=50&offset=${consoleOffset}`).then((res) => res.json()).then((data) => {
-        setConsoles((prev) => [...prev, ...data.profiles]);
-        setConsoleOffset((prev) => prev + data.profiles.length);
-        setConsoleHasMore(data.has_more);
-        setConsoleLoadingMore(false);
-      }).catch(() => setConsoleLoadingMore(false));
-    };
-    const loadTests = () => {
-      if (testsLoaded) return;
-      setLoadingTests(true);
-      fetch(`${BASE2}/api/tests?limit=50&offset=0`).then((res) => res.json()).then((data) => {
-        setTests(data.profiles);
-        setTestOffset(data.profiles.length);
-        setTestHasMore(data.has_more);
-        setLoadingTests(false);
-        setTestsLoaded(true);
-      }).catch(() => {
-        setTestsError("Failed to load test profiles");
-        setLoadingTests(false);
-        setTestsLoaded(true);
-      });
-    };
-    const loadMoreTests = () => {
-      setTestLoadingMore(true);
-      fetch(`${BASE2}/api/tests?limit=50&offset=${testOffset}`).then((res) => res.json()).then((data) => {
-        setTests((prev) => [...prev, ...data.profiles]);
-        setTestOffset((prev) => prev + data.profiles.length);
-        setTestHasMore(data.has_more);
-        setTestLoadingMore(false);
-      }).catch(() => setTestLoadingMore(false));
+    const loadMoreHttp = () => httpQuery.fetchNextPage();
+    const loadMoreJobs = () => jobsQuery.fetchNextPage();
+    const loadMoreConsole = () => consolesQuery.fetchNextPage();
+    const loadMoreTests = () => testsQuery.fetchNextPage();
+    const refetchSection = (s3) => {
+      if (s3 === "http") httpQuery.refetch();
+      else if (s3 === "jobs") jobsQuery.refetch();
+      else if (s3 === "console") consolesQuery.refetch();
+      else if (s3 === "tests") testsQuery.refetch();
+      else if (s3 === "outbound") outboundQuery.refetch();
+      else if (s3 === "env") envQuery.refetch();
     };
     const handleSectionChange = (s3) => {
       if (s3 === section) {
-        refreshSection(s3);
+        refetchSection(s3);
         return;
       }
       setSection(s3);
       const url = new URL(window.location.href);
       url.searchParams.set("section", s3);
       history.pushState(null, "", url.toString());
-      if (s3 === "tests") {
-        loadTests();
-      } else {
-        refreshSection(s3);
-      }
       setHttpSearch("");
       setHttpMethod("");
       setHttpStatus("");
@@ -2192,131 +5668,39 @@
         setTimeout(() => setCopiedToken(null), 1500);
       });
     };
-    const deleteProfile = (token) => {
-      fetch(`${BASE2}/api/profiles/${token}`, { method: "DELETE" }).then(() => {
-        setProfiles((prev) => prev.filter((p3) => p3.token !== token));
-      });
-    };
-    const deleteJob = (token) => {
-      fetch(`${BASE2}/api/jobs/${token}`, { method: "DELETE" }).then(() => {
-        setJobs((prev) => prev.filter((p3) => p3.token !== token));
-      });
-    };
-    const deleteConsole = (token) => {
-      fetch(`${BASE2}/api/console/${token}`, { method: "DELETE" }).then(() => {
-        setConsoles((prev) => prev.filter((p3) => p3.token !== token));
-      });
-    };
-    const deleteTest = (token) => {
-      fetch(`${BASE2}/api/tests/${token}`, { method: "DELETE" }).then(() => {
-        setTests((prev) => prev.filter((p3) => p3.token !== token));
-      });
-    };
-    const clearProfiles = () => {
+    const deleteProfile2 = (token) => deleteProfileMutation({ id: token }).then(() => httpQuery.refetch());
+    const deleteJob2 = (token) => deleteJobMutation({ id: token }).then(() => jobsQuery.refetch());
+    const deleteConsole2 = (token) => deleteConsoleMutation({ id: token }).then(() => consolesQuery.refetch());
+    const deleteTest2 = (token) => deleteTestMutation({ id: token }).then(() => testsQuery.refetch());
+    const clearProfiles2 = () => {
       if (!window.confirm("Delete all HTTP profiles?")) return;
-      fetch(`${BASE2}/api/profiles/clear`, { method: "DELETE" }).then(() => {
-        setProfiles([]);
-      });
+      clearProfilesMutation().then(() => httpQuery.refetch());
     };
-    const clearJobs = () => {
+    const clearJobs2 = () => {
       if (!window.confirm("Delete all job profiles?")) return;
-      fetch(`${BASE2}/api/jobs/clear`, { method: "DELETE" }).then(() => {
-        setJobs([]);
-      });
+      clearJobsMutation().then(() => jobsQuery.refetch());
     };
     const clearConsole = () => {
       if (!window.confirm("Delete all console profiles?")) return;
-      fetch(`${BASE2}/api/console/clear`, { method: "DELETE" }).then(() => {
-        setConsoles([]);
-      });
+      clearConsolesMutation().then(() => consolesQuery.refetch());
     };
-    const clearTests = () => {
+    const clearTests2 = () => {
       if (!window.confirm("Delete all test profiles?")) return;
-      fetch(`${BASE2}/api/tests/clear`, { method: "DELETE" }).then(() => {
-        setTests([]);
-      });
+      clearTestsMutation().then(() => testsQuery.refetch());
     };
     const clearAll = () => {
       if (!window.confirm("Delete all HTTP, job and console profiles?")) return;
       Promise.all([
-        fetch(`${BASE2}/api/profiles/clear`, { method: "DELETE" }),
-        fetch(`${BASE2}/api/jobs/clear`, { method: "DELETE" }),
-        fetch(`${BASE2}/api/console/clear`, { method: "DELETE" })
+        clearProfilesMutation(),
+        clearJobsMutation(),
+        clearConsolesMutation()
       ]).then(() => {
-        setProfiles([]);
-        setJobs([]);
-        setConsoles([]);
+        httpQuery.refetch();
+        jobsQuery.refetch();
+        consolesQuery.refetch();
       });
     };
-    const refreshSection = (s3) => {
-      if (s3 === "http") {
-        setLoadingHttp(true);
-        fetch(`${BASE2}/api/profiles?limit=50&offset=0`).then((res) => res.json()).then((data) => {
-          setProfiles(data.profiles);
-          setHttpOffset(data.profiles.length);
-          setHttpHasMore(data.has_more);
-          setLoadingHttp(false);
-        }).catch(() => {
-          setError("Failed to load profiles");
-          setLoadingHttp(false);
-        });
-      } else if (s3 === "jobs") {
-        setLoadingJobs(true);
-        fetch(`${BASE2}/api/jobs?limit=50&offset=0`).then((res) => res.json()).then((data) => {
-          setJobs(data.profiles);
-          setJobOffset(data.profiles.length);
-          setJobHasMore(data.has_more);
-          setLoadingJobs(false);
-        }).catch(() => {
-          setJobsError("Failed to load job profiles");
-          setLoadingJobs(false);
-        });
-      } else if (s3 === "console") {
-        setLoadingConsole(true);
-        fetch(`${BASE2}/api/console?limit=50&offset=0`).then((res) => res.json()).then((data) => {
-          setConsoles(data.profiles);
-          setConsoleOffset(data.profiles.length);
-          setConsoleHasMore(data.has_more);
-          setLoadingConsole(false);
-        }).catch(() => {
-          setConsoleError("Failed to load console profiles");
-          setLoadingConsole(false);
-        });
-      } else if (s3 === "tests") {
-        setLoadingTests(true);
-        setTestsLoaded(false);
-        fetch(`${BASE2}/api/tests?limit=50&offset=0`).then((res) => res.json()).then((data) => {
-          setTests(data.profiles);
-          setTestOffset(data.profiles.length);
-          setTestHasMore(data.has_more);
-          setLoadingTests(false);
-          setTestsLoaded(true);
-        }).catch(() => {
-          setTestsError("Failed to load test profiles");
-          setLoadingTests(false);
-          setTestsLoaded(true);
-        });
-      } else if (s3 === "outbound") {
-        setLoadingOutbound(true);
-        fetch(`${BASE2}/api/outbound_http`).then((res) => res.json()).then((data) => {
-          setOutboundRequests(data);
-          setLoadingOutbound(false);
-        }).catch(() => {
-          setOutboundError("Failed to load outbound HTTP requests");
-          setLoadingOutbound(false);
-        });
-      } else if (s3 === "env") {
-        setLoadingEnv(true);
-        fetch(`${BASE2}/api/env_vars`).then((res) => res.json()).then((data) => {
-          setEnvData(data);
-          setLoadingEnv(false);
-        }).catch(() => {
-          setEnvError("Failed to load environment variables");
-          setLoadingEnv(false);
-        });
-      }
-    };
-    const refresh = () => refreshSection(section);
+    const refresh = () => refetchSection(section);
     const toggleConsoleSort = (col) => {
       setConsoleSort(
         (prev) => prev.col === col ? { col, dir: prev.dir === "asc" ? "desc" : "asc" } : { col, dir: "asc" }
@@ -2577,7 +5961,7 @@
                   profiles.length
                 ] }),
                 /* @__PURE__ */ u3("button", { class: `btn-refresh${loadingHttp ? " btn-refresh--spinning" : ""}`, onClick: refresh, disabled: loadingHttp, title: "Refresh", children: "\u21BA" }),
-                /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearProfiles, title: "Delete HTTP profiles", children: "Clear" }),
+                /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearProfiles2, title: "Delete HTTP profiles", children: "Clear" }),
                 /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearAll, title: "Delete all HTTP and job profiles", children: "Clear All" })
               ] })
             ] }),
@@ -2623,7 +6007,7 @@
                 /* @__PURE__ */ u3("td", { children: formatMemory(p3.memory) }),
                 /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("span", { class: statusClass(p3.status), children: p3.status }) }),
                 /* @__PURE__ */ u3("td", { class: "profiler-text--xs profiler-text--mono profiler-text--muted", children: /* @__PURE__ */ u3("button", { class: "token-copy", onClick: () => copyToken(p3.token), title: "Copy full token", children: copiedToken === p3.token ? "\u2713" : p3.token.substring(0, 8) + "\u2026" }) }),
-                /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteProfile(p3.token), title: "Delete", children: "\xD7" }) })
+                /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteProfile2(p3.token), title: "Delete", children: "\xD7" }) })
               ] }, p3.token)) })
             ] }),
             httpHasMore && !httpFiltersActive && /* @__PURE__ */ u3("div", { class: "profiler-load-more", children: /* @__PURE__ */ u3("button", { class: "btn btn-secondary", onClick: loadMoreHttp, disabled: httpLoadingMore, children: httpLoadingMore ? "Loading\u2026" : "Load more" }) })
@@ -2663,7 +6047,7 @@
                   jobs.length
                 ] }),
                 /* @__PURE__ */ u3("button", { class: `btn-refresh${loadingJobs ? " btn-refresh--spinning" : ""}`, onClick: refresh, disabled: loadingJobs, title: "Refresh", children: "\u21BA" }),
-                /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearJobs, title: "Delete job profiles", children: "Clear" }),
+                /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearJobs2, title: "Delete job profiles", children: "Clear" }),
                 /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearAll, title: "Delete all HTTP and job profiles", children: "Clear All" })
               ] })
             ] }),
@@ -2704,7 +6088,7 @@
                   /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("span", { class: isFailed ? "badge-error" : "badge-success", children: isFailed ? "\u2717 Failed" : "\u2713 Completed" }) }),
                   /* @__PURE__ */ u3("td", { children: jobData?.executions ?? "-" }),
                   /* @__PURE__ */ u3("td", { class: "profiler-text--xs profiler-text--mono profiler-text--muted", children: /* @__PURE__ */ u3("button", { class: "token-copy", onClick: () => copyToken(p3.token), title: "Copy full token", children: copiedToken === p3.token ? "\u2713" : p3.token.substring(0, 8) + "\u2026" }) }),
-                  /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteJob(p3.token), title: "Delete", children: "\xD7" }) })
+                  /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteJob2(p3.token), title: "Delete", children: "\xD7" }) })
                 ] }, p3.token);
               }) })
             ] }),
@@ -2781,7 +6165,7 @@
                   /* @__PURE__ */ u3("td", { children: p3.collectors_data?.database?.total_queries ?? "\u2014" }),
                   /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("span", { class: isError ? "badge-error" : "badge-success", children: isError ? "\u2717 Error" : "\u2713 OK" }) }),
                   /* @__PURE__ */ u3("td", { class: "profiler-text--xs profiler-text--mono profiler-text--muted", children: /* @__PURE__ */ u3("button", { class: "token-copy", onClick: () => copyToken(p3.token), title: "Copy full token", children: copiedToken === p3.token ? "\u2713" : p3.token.substring(0, 8) + "\u2026" }) }),
-                  /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteConsole(p3.token), title: "Delete", children: "\xD7" }) })
+                  /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteConsole2(p3.token), title: "Delete", children: "\xD7" }) })
                 ] }, p3.token);
               }) })
             ] }),
@@ -2826,7 +6210,7 @@
                   tests.length
                 ] }),
                 /* @__PURE__ */ u3("button", { class: `btn-refresh${loadingTests ? " btn-refresh--spinning" : ""}`, onClick: refresh, disabled: loadingTests, title: "Refresh", children: "\u21BA" }),
-                /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearTests, title: "Delete test profiles", children: "Clear All" })
+                /* @__PURE__ */ u3("button", { class: "btn btn-danger btn-sm", onClick: clearTests2, title: "Delete test profiles", children: "Clear All" })
               ] })
             ] }),
             filteredTests.length === 0 ? /* @__PURE__ */ u3("div", { class: "profiler-empty", children: /* @__PURE__ */ u3("div", { class: "profiler-empty__title", children: "No results match filters" }) }) : /* @__PURE__ */ u3("table", { children: [
@@ -2864,7 +6248,7 @@
                   /* @__PURE__ */ u3("td", { children: p3.collectors_data?.database?.total_queries ?? "\u2014" }),
                   /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("span", { class: status === "failed" ? "badge-error" : status === "pending" ? "badge-warning" : "badge-success", children: status === "failed" ? "\u2717 Failed" : status === "pending" ? "\u23F8 Pending" : "\u2713 Passed" }) }),
                   /* @__PURE__ */ u3("td", { class: "profiler-text--xs profiler-text--mono profiler-text--muted", children: /* @__PURE__ */ u3("button", { class: "token-copy", onClick: () => copyToken(p3.token), title: "Copy full token", children: copiedToken === p3.token ? "\u2713" : p3.token.substring(0, 8) + "\u2026" }) }),
-                  /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteTest(p3.token), title: "Delete", children: "\xD7" }) })
+                  /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteTest2(p3.token), title: "Delete", children: "\xD7" }) })
                 ] }, p3.token);
               }) })
             ] }),
@@ -3125,6 +6509,7 @@
       adapter: "",
       error: null
     });
+    const { mutateAsync: runExplainMutation } = useExplainQuery();
     if (!dbData?.queries) {
       return /* @__PURE__ */ u3("div", { class: "profiler-empty", children: /* @__PURE__ */ u3("p", { class: "profiler-empty__description", children: "No database queries recorded" }) });
     }
@@ -3140,17 +6525,7 @@
     const runExplain = async (queryIndex) => {
       setExplainState({ open: true, loading: true, result: null, format: "text", adapter: "", error: null });
       try {
-        const res = await fetch("/_profiler/api/explain", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ token, query_index: queryIndex })
-        });
-        if (!res.ok) {
-          const body = await res.json().catch(() => ({}));
-          setExplainState((s3) => ({ ...s3, loading: false, error: body.error ?? `HTTP ${res.status}` }));
-          return;
-        }
-        const data = await res.json();
+        const data = await runExplainMutation({ token, query_index: queryIndex });
         setExplainState((s3) => ({
           ...s3,
           loading: false,
@@ -3415,10 +6790,10 @@
       const vpRange = this.viewport.end - this.viewport.start;
       for (let i3 = this.frames.length - 1; i3 >= 0; i3--) {
         const f4 = this.frames[i3];
-        const x2 = (f4.absStart - this.viewport.start) / vpRange * w3;
+        const x3 = (f4.absStart - this.viewport.start) / vpRange * w3;
         const fw = (f4.absEnd - f4.absStart) / vpRange * w3;
         const y3 = f4.depth * ROW_HEIGHT;
-        if (mx >= x2 && mx <= x2 + fw && my >= y3 && my <= y3 + FRAME_HEIGHT) {
+        if (mx >= x3 && mx <= x3 + fw && my >= y3 && my <= y3 + FRAME_HEIGHT) {
           return f4;
         }
       }
@@ -3584,34 +6959,34 @@
         this.callbacks.onSearchResults(matchCount, this.frames.length);
       }
       for (const frame of this.frames) {
-        const x2 = (frame.absStart - this.viewport.start) / vpRange * w3;
+        const x3 = (frame.absStart - this.viewport.start) / vpRange * w3;
         const fw = (frame.absEnd - frame.absStart) / vpRange * w3;
         const y3 = frame.depth * ROW_HEIGHT;
-        if (x2 + fw < 0 || x2 > w3 || fw < 0.5) continue;
+        if (x3 + fw < 0 || x3 > w3 || fw < 0.5) continue;
         const color = CATEGORY_COLORS[frame.node.category] || "#a78bfa";
         const isHovered = frame === this.hoveredFrame;
         const isHighlighted = !!this.highlightName && frame.node.name === this.highlightName;
         const isMatch = !hasSearch || frame.node.name.toLowerCase().includes(searchLower);
         ctx.fillStyle = isHovered || isHighlighted ? this.lightenColor(color, 0.2) : color;
         ctx.globalAlpha = hasSearch && !isMatch ? 0.2 : isHovered || isHighlighted ? 1 : 0.85;
-        this.roundRect(ctx, x2, y3, fw, FRAME_HEIGHT, 3);
+        this.roundRect(ctx, x3, y3, fw, FRAME_HEIGHT, 3);
         ctx.fill();
         ctx.globalAlpha = 1;
         if (isHovered) {
           ctx.strokeStyle = "#ffffff";
           ctx.lineWidth = 1.5;
-          this.roundRect(ctx, x2, y3, fw, FRAME_HEIGHT, 3);
+          this.roundRect(ctx, x3, y3, fw, FRAME_HEIGHT, 3);
           ctx.stroke();
         } else if (isHighlighted) {
           ctx.strokeStyle = "#fbbf24";
           ctx.lineWidth = 2;
-          this.roundRect(ctx, x2, y3, fw, FRAME_HEIGHT, 3);
+          this.roundRect(ctx, x3, y3, fw, FRAME_HEIGHT, 3);
           ctx.stroke();
         } else if (hasSearch && isMatch) {
           ctx.strokeStyle = "#ffffff";
           ctx.lineWidth = 1;
           ctx.globalAlpha = 0.5;
-          this.roundRect(ctx, x2, y3, fw, FRAME_HEIGHT, 3);
+          this.roundRect(ctx, x3, y3, fw, FRAME_HEIGHT, 3);
           ctx.stroke();
           ctx.globalAlpha = 1;
         }
@@ -3625,26 +7000,26 @@
           const durationWidth = ctx.measureText(duration).width;
           if (maxTextWidth > durationWidth + 20) {
             const nameMaxWidth = maxTextWidth - durationWidth - 8;
-            ctx.fillText(this.truncateText(ctx, label, nameMaxWidth), x2 + 4, y3 + FRAME_HEIGHT / 2);
+            ctx.fillText(this.truncateText(ctx, label, nameMaxWidth), x3 + 4, y3 + FRAME_HEIGHT / 2);
             ctx.fillStyle = isHovered ? textColor : textMuted;
-            ctx.fillText(duration, x2 + fw - durationWidth - 4, y3 + FRAME_HEIGHT / 2);
+            ctx.fillText(duration, x3 + fw - durationWidth - 4, y3 + FRAME_HEIGHT / 2);
           } else {
-            ctx.fillText(this.truncateText(ctx, label, maxTextWidth), x2 + 4, y3 + FRAME_HEIGHT / 2);
+            ctx.fillText(this.truncateText(ctx, label, maxTextWidth), x3 + 4, y3 + FRAME_HEIGHT / 2);
           }
         }
       }
     }
-    roundRect(ctx, x2, y3, w3, h3, r3) {
+    roundRect(ctx, x3, y3, w3, h3, r3) {
       ctx.beginPath();
-      ctx.moveTo(x2 + r3, y3);
-      ctx.lineTo(x2 + w3 - r3, y3);
-      ctx.quadraticCurveTo(x2 + w3, y3, x2 + w3, y3 + r3);
-      ctx.lineTo(x2 + w3, y3 + h3 - r3);
-      ctx.quadraticCurveTo(x2 + w3, y3 + h3, x2 + w3 - r3, y3 + h3);
-      ctx.lineTo(x2 + r3, y3 + h3);
-      ctx.quadraticCurveTo(x2, y3 + h3, x2, y3 + h3 - r3);
-      ctx.lineTo(x2, y3 + r3);
-      ctx.quadraticCurveTo(x2, y3, x2 + r3, y3);
+      ctx.moveTo(x3 + r3, y3);
+      ctx.lineTo(x3 + w3 - r3, y3);
+      ctx.quadraticCurveTo(x3 + w3, y3, x3 + w3, y3 + r3);
+      ctx.lineTo(x3 + w3, y3 + h3 - r3);
+      ctx.quadraticCurveTo(x3 + w3, y3 + h3, x3 + w3 - r3, y3 + h3);
+      ctx.lineTo(x3 + r3, y3 + h3);
+      ctx.quadraticCurveTo(x3, y3 + h3, x3, y3 + h3 - r3);
+      ctx.lineTo(x3, y3 + r3);
+      ctx.quadraticCurveTo(x3, y3, x3 + r3, y3);
       ctx.closePath();
     }
     truncateText(ctx, text, maxWidth) {
@@ -3714,7 +7089,7 @@
       this.el.className = "profiler-flamegraph__tooltip";
       container.appendChild(this.el);
     }
-    show(frame, x2, y3) {
+    show(frame, x3, y3) {
       const node = frame.node;
       const category = node.category;
       const color = CATEGORY_COLORS2[category] || "#a78bfa";
@@ -3796,10 +7171,10 @@
           this.el.appendChild(payloadDiv);
         }
       }
-      let left = x2 + 12;
+      let left = x3 + 12;
       let top = y3 - 8;
       const tipRect = this.el.getBoundingClientRect();
-      if (left + tipRect.width > window.innerWidth) left = x2 - tipRect.width - 12;
+      if (left + tipRect.width > window.innerWidth) left = x3 - tipRect.width - 12;
       if (top + tipRect.height > window.innerHeight) top = y3 - tipRect.height - 8;
       if (top < 0) top = 4;
       this.el.style.left = `${left}px`;
@@ -3904,14 +7279,7 @@
     const [fnMaxFramesUpdating, setFnMaxFramesUpdating] = d2(false);
     const [fnModeUpdating, setFnModeUpdating] = d2(false);
     const [fnClockUpdating, setFnClockUpdating] = d2(false);
-    const patchFunctionProfiling = async (patch) => {
-      const res = await fetch("/_profiler/api/function_profiling", {
-        method: "PATCH",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(patch)
-      });
-      return res.json();
-    };
+    const { mutateAsync: patchFunctionProfiling } = useUpdateFunctionProfiling();
     const toggleFunctionProfiling = async () => {
       setFnToggling(true);
       try {
@@ -3967,9 +7335,9 @@
       breadcrumbsRef.current = breadcrumbs;
       container.insertBefore(breadcrumbs["el"], canvas);
       const renderer = new FlameGraphRenderer(canvas, data.root_events, {
-        onHover: (frame, x2, y3) => {
+        onHover: (frame, x3, y3) => {
           if (frame) {
-            tooltip.show(frame, x2, y3);
+            tooltip.show(frame, x3, y3);
           } else {
             tooltip.hide();
           }
@@ -4533,9 +7901,9 @@
       });
       container.insertBefore(breadcrumbs["el"], canvas);
       const renderer = new FlameGraphRenderer(canvas, rootCalls, {
-        onHover: (frame, x2, y3) => {
+        onHover: (frame, x3, y3) => {
           if (frame) {
-            tooltip.show(frame, x2, y3);
+            tooltip.show(frame, x3, y3);
             onHoverNameRef.current?.(frame.node.name);
           } else {
             tooltip.hide();
@@ -5360,14 +8728,14 @@
   // app/assets/typescript/profiler/components/dashboard/ProfileDashboard.tsx
   function ProfileDashboard({ profile, initialTab, embedded }) {
     const cd = profile.collectors_data || {};
-    const hasAjax = cd["ajax"]?.total_requests > 0;
-    const hasHttp = cd["http"]?.total_requests > 0;
-    const hasException = !!cd["exception"]?.exception_class;
-    const hasLogs = (cd["logs"]?.count ?? 0) > 0;
-    const hasRoutes = (cd["routes"]?.total ?? 0) > 0;
-    const hasI18n = (cd["i18n"]?.total ?? 0) > 0;
+    const hasAjax = (cd.ajax?.total_requests ?? 0) > 0;
+    const hasHttp = (cd.http?.total_requests ?? 0) > 0;
+    const hasException = !!cd.exception?.exception_class;
+    const hasLogs = (cd.logs?.count ?? 0) > 0;
+    const hasRoutes = (cd.routes?.total ?? 0) > 0;
+    const hasI18n = (cd.i18n?.total ?? 0) > 0;
     const hasJobs = (profile.child_jobs?.length ?? 0) > 0;
-    const hasMailers = (cd["mailer"]?.total ?? 0) > 0;
+    const hasMailers = (cd.mailer?.total ?? 0) > 0;
     const [activeTab, setActiveTab] = d2(hasException ? "exception" : initialTab);
     const handleTabClick = (tab) => (e3) => {
       e3.preventDefault();
@@ -5443,21 +8811,21 @@
           /* @__PURE__ */ u3("a", { href: "#", class: tabClass("env"), onClick: handleTabClick("env"), children: "Env" })
         ] }),
         /* @__PURE__ */ u3("div", { class: "profiler-p-4 tab-content active", children: [
-          activeTab === "exception" && /* @__PURE__ */ u3(ExceptionTab, { exceptionData: cd["exception"] }),
+          activeTab === "exception" && /* @__PURE__ */ u3(ExceptionTab, { exceptionData: cd.exception }),
           activeTab === "request" && /* @__PURE__ */ u3(RequestTab, { profile }),
-          activeTab === "dump" && /* @__PURE__ */ u3(DumpsTab, { dumpData: cd["dump"] }),
-          activeTab === "database" && /* @__PURE__ */ u3(DatabaseTab, { dbData: cd["database"], token: profile.token }),
-          activeTab === "ajax" && /* @__PURE__ */ u3(AjaxTab, { ajaxData: cd["ajax"] }),
-          activeTab === "http" && /* @__PURE__ */ u3(HttpTab, { httpData: cd["http"] }),
-          activeTab === "timeline" && /* @__PURE__ */ u3(FlameGraphTab, { flamegraphData: cd["flamegraph"], perfData: cd["performance"], functionProfileData: cd["function_profile"] }),
-          activeTab === "views" && /* @__PURE__ */ u3(ViewsTab, { viewData: cd["view"] }),
-          activeTab === "cache" && /* @__PURE__ */ u3(CacheTab, { cacheData: cd["cache"] }),
-          activeTab === "logs" && /* @__PURE__ */ u3(LogsTab, { logData: cd["logs"] }),
-          activeTab === "routes" && /* @__PURE__ */ u3(RoutesTab, { routesData: cd["routes"] }),
-          activeTab === "i18n" && /* @__PURE__ */ u3(I18nTab, { i18nData: cd["i18n"] }),
+          activeTab === "dump" && /* @__PURE__ */ u3(DumpsTab, { dumpData: cd.dump }),
+          activeTab === "database" && /* @__PURE__ */ u3(DatabaseTab, { dbData: cd.database, token: profile.token }),
+          activeTab === "ajax" && /* @__PURE__ */ u3(AjaxTab, { ajaxData: cd.ajax }),
+          activeTab === "http" && /* @__PURE__ */ u3(HttpTab, { httpData: cd.http }),
+          activeTab === "timeline" && /* @__PURE__ */ u3(FlameGraphTab, { flamegraphData: cd.flamegraph, perfData: cd.performance, functionProfileData: cd.function_profile }),
+          activeTab === "views" && /* @__PURE__ */ u3(ViewsTab, { viewData: cd.view }),
+          activeTab === "cache" && /* @__PURE__ */ u3(CacheTab, { cacheData: cd.cache }),
+          activeTab === "logs" && /* @__PURE__ */ u3(LogsTab, { logData: cd.logs }),
+          activeTab === "routes" && /* @__PURE__ */ u3(RoutesTab, { routesData: cd.routes }),
+          activeTab === "i18n" && /* @__PURE__ */ u3(I18nTab, { i18nData: cd.i18n }),
           activeTab === "jobs" && /* @__PURE__ */ u3(JobsTab, { jobs: profile.child_jobs }),
-          activeTab === "mailer" && /* @__PURE__ */ u3(MailerTab, { mailerData: cd["mailer"] }),
-          activeTab === "env" && /* @__PURE__ */ u3(EnvTab, { envData: cd["env"], readOnly: true })
+          activeTab === "mailer" && /* @__PURE__ */ u3(MailerTab, { mailerData: cd.mailer }),
+          activeTab === "env" && /* @__PURE__ */ u3(EnvTab, { envData: cd.env, readOnly: true })
         ] })
       ] }),
       !embedded && /* @__PURE__ */ u3("div", { class: "profiler-mt-6", children: /* @__PURE__ */ u3("a", { href: "/_profiler", style: "color: var(--profiler-accent);", children: "\u2190 Back to profiles" }) })
@@ -5926,10 +9294,10 @@
     const scale = (width - 100) / timeRange;
     events.forEach((event, index) => {
       const y3 = index * 40 + 20;
-      const x2 = (event.started_at - minTime) * scale + 50;
+      const x3 = (event.started_at - minTime) * scale + 50;
       const eventWidth = event.duration * scale;
       const rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-      rect.setAttribute("x", x2.toString());
+      rect.setAttribute("x", x3.toString());
       rect.setAttribute("y", y3.toString());
       rect.setAttribute("width", Math.max(eventWidth, 2).toString());
       rect.setAttribute("height", "20");
@@ -6135,10 +9503,16 @@ Duration: ${event.duration.toFixed(2)}ms`;
   }
 
   // app/assets/typescript/profiler/main.tsx
+  var queryClient = new QueryClient({
+    defaultOptions: { queries: { staleTime: 3e4, retry: 1 } }
+  });
   document.addEventListener("DOMContentLoaded", () => {
     const indexEl = document.getElementById("profiler-index");
     if (indexEl) {
-      J(/* @__PURE__ */ u3(ProfileList, {}), indexEl);
+      J(
+        /* @__PURE__ */ u3(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ u3(ProfileList, {}) }),
+        indexEl
+      );
     }
     const showEl = document.getElementById("profiler-show");
     if (showEl) {