@mcp-fe/react-tools 0.1.1

package/index.mjs

@@ -0,0 +1,2354 @@
+var ke = { exports: {} }, g = {};
+var Ye;
+function Ze() {
+  if (Ye) return g;
+  Ye = 1;
+  var v = /* @__PURE__ */ Symbol.for("react.transitional.element"), n = /* @__PURE__ */ Symbol.for("react.portal"), s = /* @__PURE__ */ Symbol.for("react.fragment"), a = /* @__PURE__ */ Symbol.for("react.strict_mode"), u = /* @__PURE__ */ Symbol.for("react.profiler"), d = /* @__PURE__ */ Symbol.for("react.consumer"), y = /* @__PURE__ */ Symbol.for("react.context"), b = /* @__PURE__ */ Symbol.for("react.forward_ref"), O = /* @__PURE__ */ Symbol.for("react.suspense"), I = /* @__PURE__ */ Symbol.for("react.memo"), m = /* @__PURE__ */ Symbol.for("react.lazy"), k = /* @__PURE__ */ Symbol.for("react.activity"), L = Symbol.iterator;
+  function $(t) {
+    return t === null || typeof t != "object" ? null : (t = L && t[L] || t["@@iterator"], typeof t == "function" ? t : null);
+  }
+  var U = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, D = Object.assign, F = {};
+  function H(t, o, l) {
+    this.props = t, this.context = o, this.refs = F, this.updater = l || U;
+  }
+  H.prototype.isReactComponent = {}, H.prototype.setState = function(t, o) {
+    if (typeof t != "object" && typeof t != "function" && t != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, t, o, "setState");
+  }, H.prototype.forceUpdate = function(t) {
+    this.updater.enqueueForceUpdate(this, t, "forceUpdate");
+  };
+  function N() {
+  }
+  N.prototype = H.prototype;
+  function G(t, o, l) {
+    this.props = t, this.context = o, this.refs = F, this.updater = l || U;
+  }
+  var X = G.prototype = new N();
+  X.constructor = G, D(X, H.prototype), X.isPureReactComponent = !0;
+  var x = Array.isArray;
+  function se() {
+  }
+  var W = { H: null, A: null, T: null, S: null }, ue = Object.prototype.hasOwnProperty;
+  function z(t, o, l) {
+    var f = l.ref;
+    return {
+      $$typeof: v,
+      type: t,
+      key: o,
+      ref: f !== void 0 ? f : null,
+      props: l
+    };
+  }
+  function te(t, o) {
+    return z(t.type, o, t.props);
+  }
+  function ie(t) {
+    return typeof t == "object" && t !== null && t.$$typeof === v;
+  }
+  function A(t) {
+    var o = { "=": "=0", ":": "=2" };
+    return "$" + t.replace(/[=:]/g, function(l) {
+      return o[l];
+    });
+  }
+  var re = /\/+/g;
+  function V(t, o) {
+    return typeof t == "object" && t !== null && t.key != null ? A("" + t.key) : o.toString(36);
+  }
+  function Q(t) {
+    switch (t.status) {
+      case "fulfilled":
+        return t.value;
+      case "rejected":
+        throw t.reason;
+      default:
+        switch (typeof t.status == "string" ? t.then(se, se) : (t.status = "pending", t.then(
+          function(o) {
+            t.status === "pending" && (t.status = "fulfilled", t.value = o);
+          },
+          function(o) {
+            t.status === "pending" && (t.status = "rejected", t.reason = o);
+          }
+        )), t.status) {
+          case "fulfilled":
+            return t.value;
+          case "rejected":
+            throw t.reason;
+        }
+    }
+    throw t;
+  }
+  function q(t, o, l, f, _) {
+    var S = typeof t;
+    (S === "undefined" || S === "boolean") && (t = null);
+    var p = !1;
+    if (t === null) p = !0;
+    else
+      switch (S) {
+        case "bigint":
+        case "string":
+        case "number":
+          p = !0;
+          break;
+        case "object":
+          switch (t.$$typeof) {
+            case v:
+            case n:
+              p = !0;
+              break;
+            case m:
+              return p = t._init, q(
+                p(t._payload),
+                o,
+                l,
+                f,
+                _
+              );
+          }
+      }
+    if (p)
+      return _ = _(t), p = f === "" ? "." + V(t, 0) : f, x(_) ? (l = "", p != null && (l = p.replace(re, "$&/") + "/"), q(_, o, l, "", function(ee) {
+        return ee;
+      })) : _ != null && (ie(_) && (_ = te(
+        _,
+        l + (_.key == null || t && t.key === _.key ? "" : ("" + _.key).replace(
+          re,
+          "$&/"
+        ) + "/") + p
+      )), o.push(_)), 1;
+    p = 0;
+    var Y = f === "" ? "." : f + ":";
+    if (x(t))
+      for (var j = 0; j < t.length; j++)
+        f = t[j], S = Y + V(f, j), p += q(
+          f,
+          o,
+          l,
+          S,
+          _
+        );
+    else if (j = $(t), typeof j == "function")
+      for (t = j.call(t), j = 0; !(f = t.next()).done; )
+        f = f.value, S = Y + V(f, j++), p += q(
+          f,
+          o,
+          l,
+          S,
+          _
+        );
+    else if (S === "object") {
+      if (typeof t.then == "function")
+        return q(
+          Q(t),
+          o,
+          l,
+          f,
+          _
+        );
+      throw o = String(t), Error(
+        "Objects are not valid as a React child (found: " + (o === "[object Object]" ? "object with keys {" + Object.keys(t).join(", ") + "}" : o) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return p;
+  }
+  function K(t, o, l) {
+    if (t == null) return t;
+    var f = [], _ = 0;
+    return q(t, f, "", "", function(S) {
+      return o.call(l, S, _++);
+    }), f;
+  }
+  function ne(t) {
+    if (t._status === -1) {
+      var o = t._result;
+      o = o(), o.then(
+        function(l) {
+          (t._status === 0 || t._status === -1) && (t._status = 1, t._result = l);
+        },
+        function(l) {
+          (t._status === 0 || t._status === -1) && (t._status = 2, t._result = l);
+        }
+      ), t._status === -1 && (t._status = 0, t._result = o);
+    }
+    if (t._status === 1) return t._result.default;
+    throw t._result;
+  }
+  var Z = typeof reportError == "function" ? reportError : function(t) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var o = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof t == "object" && t !== null && typeof t.message == "string" ? String(t.message) : String(t),
+        error: t
+      });
+      if (!window.dispatchEvent(o)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", t);
+      return;
+    }
+    console.error(t);
+  }, ae = {
+    map: K,
+    forEach: function(t, o, l) {
+      K(
+        t,
+        function() {
+          o.apply(this, arguments);
+        },
+        l
+      );
+    },
+    count: function(t) {
+      var o = 0;
+      return K(t, function() {
+        o++;
+      }), o;
+    },
+    toArray: function(t) {
+      return K(t, function(o) {
+        return o;
+      }) || [];
+    },
+    only: function(t) {
+      if (!ie(t))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return t;
+    }
+  };
+  return g.Activity = k, g.Children = ae, g.Component = H, g.Fragment = s, g.Profiler = u, g.PureComponent = G, g.StrictMode = a, g.Suspense = O, g.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = W, g.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(t) {
+      return W.H.useMemoCache(t);
+    }
+  }, g.cache = function(t) {
+    return function() {
+      return t.apply(null, arguments);
+    };
+  }, g.cacheSignal = function() {
+    return null;
+  }, g.cloneElement = function(t, o, l) {
+    if (t == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + t + "."
+      );
+    var f = D({}, t.props), _ = t.key;
+    if (o != null)
+      for (S in o.key !== void 0 && (_ = "" + o.key), o)
+        !ue.call(o, S) || S === "key" || S === "__self" || S === "__source" || S === "ref" && o.ref === void 0 || (f[S] = o[S]);
+    var S = arguments.length - 2;
+    if (S === 1) f.children = l;
+    else if (1 < S) {
+      for (var p = Array(S), Y = 0; Y < S; Y++)
+        p[Y] = arguments[Y + 2];
+      f.children = p;
+    }
+    return z(t.type, _, f);
+  }, g.createContext = function(t) {
+    return t = {
+      $$typeof: y,
+      _currentValue: t,
+      _currentValue2: t,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, t.Provider = t, t.Consumer = {
+      $$typeof: d,
+      _context: t
+    }, t;
+  }, g.createElement = function(t, o, l) {
+    var f, _ = {}, S = null;
+    if (o != null)
+      for (f in o.key !== void 0 && (S = "" + o.key), o)
+        ue.call(o, f) && f !== "key" && f !== "__self" && f !== "__source" && (_[f] = o[f]);
+    var p = arguments.length - 2;
+    if (p === 1) _.children = l;
+    else if (1 < p) {
+      for (var Y = Array(p), j = 0; j < p; j++)
+        Y[j] = arguments[j + 2];
+      _.children = Y;
+    }
+    if (t && t.defaultProps)
+      for (f in p = t.defaultProps, p)
+        _[f] === void 0 && (_[f] = p[f]);
+    return z(t, S, _);
+  }, g.createRef = function() {
+    return { current: null };
+  }, g.forwardRef = function(t) {
+    return { $$typeof: b, render: t };
+  }, g.isValidElement = ie, g.lazy = function(t) {
+    return {
+      $$typeof: m,
+      _payload: { _status: -1, _result: t },
+      _init: ne
+    };
+  }, g.memo = function(t, o) {
+    return {
+      $$typeof: I,
+      type: t,
+      compare: o === void 0 ? null : o
+    };
+  }, g.startTransition = function(t) {
+    var o = W.T, l = {};
+    W.T = l;
+    try {
+      var f = t(), _ = W.S;
+      _ !== null && _(l, f), typeof f == "object" && f !== null && typeof f.then == "function" && f.then(se, Z);
+    } catch (S) {
+      Z(S);
+    } finally {
+      o !== null && l.types !== null && (o.types = l.types), W.T = o;
+    }
+  }, g.unstable_useCacheRefresh = function() {
+    return W.H.useCacheRefresh();
+  }, g.use = function(t) {
+    return W.H.use(t);
+  }, g.useActionState = function(t, o, l) {
+    return W.H.useActionState(t, o, l);
+  }, g.useCallback = function(t, o) {
+    return W.H.useCallback(t, o);
+  }, g.useContext = function(t) {
+    return W.H.useContext(t);
+  }, g.useDebugValue = function() {
+  }, g.useDeferredValue = function(t, o) {
+    return W.H.useDeferredValue(t, o);
+  }, g.useEffect = function(t, o) {
+    return W.H.useEffect(t, o);
+  }, g.useEffectEvent = function(t) {
+    return W.H.useEffectEvent(t);
+  }, g.useId = function() {
+    return W.H.useId();
+  }, g.useImperativeHandle = function(t, o, l) {
+    return W.H.useImperativeHandle(t, o, l);
+  }, g.useInsertionEffect = function(t, o) {
+    return W.H.useInsertionEffect(t, o);
+  }, g.useLayoutEffect = function(t, o) {
+    return W.H.useLayoutEffect(t, o);
+  }, g.useMemo = function(t, o) {
+    return W.H.useMemo(t, o);
+  }, g.useOptimistic = function(t, o) {
+    return W.H.useOptimistic(t, o);
+  }, g.useReducer = function(t, o, l) {
+    return W.H.useReducer(t, o, l);
+  }, g.useRef = function(t) {
+    return W.H.useRef(t);
+  }, g.useState = function(t) {
+    return W.H.useState(t);
+  }, g.useSyncExternalStore = function(t, o, l) {
+    return W.H.useSyncExternalStore(
+      t,
+      o,
+      l
+    );
+  }, g.useTransition = function() {
+    return W.H.useTransition();
+  }, g.version = "19.2.3", g;
+}
+var he = { exports: {} };
+he.exports;
+var He;
+function et() {
+  return He || (He = 1, (function(v, n) {
+    process.env.NODE_ENV !== "production" && (function() {
+      function s(e, r) {
+        Object.defineProperty(d.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              r[0],
+              r[1]
+            );
+          }
+        });
+      }
+      function a(e) {
+        return e === null || typeof e != "object" ? null : (e = Ce && e[Ce] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function u(e, r) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var i = e + "." + r;
+        Se[i] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          r,
+          e
+        ), Se[i] = !0);
+      }
+      function d(e, r, i) {
+        this.props = e, this.context = r, this.refs = me, this.updater = i || be;
+      }
+      function y() {
+      }
+      function b(e, r, i) {
+        this.props = e, this.context = r, this.refs = me, this.updater = i || be;
+      }
+      function O() {
+      }
+      function I(e) {
+        return "" + e;
+      }
+      function m(e) {
+        try {
+          I(e);
+          var r = !1;
+        } catch {
+          r = !0;
+        }
+        if (r) {
+          r = console;
+          var i = r.error, c = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return i.call(
+            r,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            c
+          ), I(e);
+        }
+      }
+      function k(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === Qe ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case t:
+            return "Fragment";
+          case l:
+            return "Profiler";
+          case o:
+            return "StrictMode";
+          case p:
+            return "Suspense";
+          case Y:
+            return "SuspenseList";
+          case Re:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case ae:
+              return "Portal";
+            case _:
+              return e.displayName || "Context";
+            case f:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case S:
+              var r = e.render;
+              return e = e.displayName, e || (e = r.displayName || r.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case j:
+              return r = e.displayName || null, r !== null ? r : k(e.type) || "Memo";
+            case ee:
+              r = e._payload, e = e._init;
+              try {
+                return k(e(r));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function L(e) {
+        if (e === t) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === ee)
+          return "<...>";
+        try {
+          var r = k(e);
+          return r ? "<" + r + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function $() {
+        var e = w.A;
+        return e === null ? null : e.getOwner();
+      }
+      function U() {
+        return Error("react-stack-top-frame");
+      }
+      function D(e) {
+        if (pe.call(e, "key")) {
+          var r = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (r && r.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function F(e, r) {
+        function i() {
+          Oe || (Oe = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            r
+          ));
+        }
+        i.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: i,
+          configurable: !0
+        });
+      }
+      function H() {
+        var e = k(this.type);
+        return Ne[e] || (Ne[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function N(e, r, i, c, h, R) {
+        var T = i.ref;
+        return e = {
+          $$typeof: Z,
+          type: e,
+          key: r,
+          props: i,
+          _owner: c
+        }, (T !== void 0 ? T : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: H
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: h
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: R
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function G(e, r) {
+        return r = N(
+          e.type,
+          r,
+          e.props,
+          e._owner,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (r._store.validated = e._store.validated), r;
+      }
+      function X(e) {
+        x(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === ee && (e._payload.status === "fulfilled" ? x(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+      }
+      function x(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === Z;
+      }
+      function se(e) {
+        var r = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(i) {
+          return r[i];
+        });
+      }
+      function W(e, r) {
+        return typeof e == "object" && e !== null && e.key != null ? (m(e.key), se("" + e.key)) : r.toString(36);
+      }
+      function ue(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(O, O) : (e.status = "pending", e.then(
+              function(r) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = r);
+              },
+              function(r) {
+                e.status === "pending" && (e.status = "rejected", e.reason = r);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function z(e, r, i, c, h) {
+        var R = typeof e;
+        (R === "undefined" || R === "boolean") && (e = null);
+        var T = !1;
+        if (e === null) T = !0;
+        else
+          switch (R) {
+            case "bigint":
+            case "string":
+            case "number":
+              T = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case Z:
+                case ae:
+                  T = !0;
+                  break;
+                case ee:
+                  return T = e._init, z(
+                    T(e._payload),
+                    r,
+                    i,
+                    c,
+                    h
+                  );
+              }
+          }
+        if (T) {
+          T = e, h = h(T);
+          var P = c === "" ? "." + W(T, 0) : c;
+          return Ae(h) ? (i = "", P != null && (i = P.replace(Ie, "$&/") + "/"), z(h, r, i, "", function(oe) {
+            return oe;
+          })) : h != null && (x(h) && (h.key != null && (T && T.key === h.key || m(h.key)), i = G(
+            h,
+            i + (h.key == null || T && T.key === h.key ? "" : ("" + h.key).replace(
+              Ie,
+              "$&/"
+            ) + "/") + P
+          ), c !== "" && T != null && x(T) && T.key == null && T._store && !T._store.validated && (i._store.validated = 2), h = i), r.push(h)), 1;
+        }
+        if (T = 0, P = c === "" ? "." : c + ":", Ae(e))
+          for (var C = 0; C < e.length; C++)
+            c = e[C], R = P + W(c, C), T += z(
+              c,
+              r,
+              i,
+              R,
+              h
+            );
+        else if (C = a(e), typeof C == "function")
+          for (C === e.entries && (je || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), je = !0), e = C.call(e), C = 0; !(c = e.next()).done; )
+            c = c.value, R = P + W(c, C++), T += z(
+              c,
+              r,
+              i,
+              R,
+              h
+            );
+        else if (R === "object") {
+          if (typeof e.then == "function")
+            return z(
+              ue(e),
+              r,
+              i,
+              c,
+              h
+            );
+          throw r = String(e), Error(
+            "Objects are not valid as a React child (found: " + (r === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : r) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return T;
+      }
+      function te(e, r, i) {
+        if (e == null) return e;
+        var c = [], h = 0;
+        return z(e, c, "", "", function(R) {
+          return r.call(i, R, h++);
+        }), c;
+      }
+      function ie(e) {
+        if (e._status === -1) {
+          var r = e._ioInfo;
+          r != null && (r.start = r.end = performance.now()), r = e._result;
+          var i = r();
+          if (i.then(
+            function(h) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 1, e._result = h;
+                var R = e._ioInfo;
+                R != null && (R.end = performance.now()), i.status === void 0 && (i.status = "fulfilled", i.value = h);
+              }
+            },
+            function(h) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 2, e._result = h;
+                var R = e._ioInfo;
+                R != null && (R.end = performance.now()), i.status === void 0 && (i.status = "rejected", i.reason = h);
+              }
+            }
+          ), r = e._ioInfo, r != null) {
+            r.value = i;
+            var c = i.displayName;
+            typeof c == "string" && (r.name = c);
+          }
+          e._status === -1 && (e._status = 0, e._result = i);
+        }
+        if (e._status === 1)
+          return r = e._result, r === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            r
+          ), "default" in r || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            r
+          ), r.default;
+        throw e._result;
+      }
+      function A() {
+        var e = w.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function re() {
+        w.asyncTransitions--;
+      }
+      function V(e) {
+        if (ge === null)
+          try {
+            var r = ("require" + Math.random()).slice(0, 7);
+            ge = (v && v[r]).call(
+              v,
+              "timers"
+            ).setImmediate;
+          } catch {
+            ge = function(c) {
+              Le === !1 && (Le = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var h = new MessageChannel();
+              h.port1.onmessage = c, h.port2.postMessage(void 0);
+            };
+          }
+        return ge(e);
+      }
+      function Q(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function q(e, r) {
+        r !== ve - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), ve = r;
+      }
+      function K(e, r, i) {
+        var c = w.actQueue;
+        if (c !== null)
+          if (c.length !== 0)
+            try {
+              ne(c), V(function() {
+                return K(e, r, i);
+              });
+              return;
+            } catch (h) {
+              w.thrownErrors.push(h);
+            }
+          else w.actQueue = null;
+        0 < w.thrownErrors.length ? (c = Q(w.thrownErrors), w.thrownErrors.length = 0, i(c)) : r(e);
+      }
+      function ne(e) {
+        if (!Te) {
+          Te = !0;
+          var r = 0;
+          try {
+            for (; r < e.length; r++) {
+              var i = e[r];
+              do {
+                w.didUsePromise = !1;
+                var c = i(!1);
+                if (c !== null) {
+                  if (w.didUsePromise) {
+                    e[r] = i, e.splice(0, r);
+                    return;
+                  }
+                  i = c;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (h) {
+            e.splice(0, r + 1), w.thrownErrors.push(h);
+          } finally {
+            Te = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var Z = /* @__PURE__ */ Symbol.for("react.transitional.element"), ae = /* @__PURE__ */ Symbol.for("react.portal"), t = /* @__PURE__ */ Symbol.for("react.fragment"), o = /* @__PURE__ */ Symbol.for("react.strict_mode"), l = /* @__PURE__ */ Symbol.for("react.profiler"), f = /* @__PURE__ */ Symbol.for("react.consumer"), _ = /* @__PURE__ */ Symbol.for("react.context"), S = /* @__PURE__ */ Symbol.for("react.forward_ref"), p = /* @__PURE__ */ Symbol.for("react.suspense"), Y = /* @__PURE__ */ Symbol.for("react.suspense_list"), j = /* @__PURE__ */ Symbol.for("react.memo"), ee = /* @__PURE__ */ Symbol.for("react.lazy"), Re = /* @__PURE__ */ Symbol.for("react.activity"), Ce = Symbol.iterator, Se = {}, be = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          u(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          u(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          u(e, "setState");
+        }
+      }, We = Object.assign, me = {};
+      Object.freeze(me), d.prototype.isReactComponent = {}, d.prototype.setState = function(e, r) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, r, "setState");
+      }, d.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var B = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (le in B)
+        B.hasOwnProperty(le) && s(le, B[le]);
+      y.prototype = d.prototype, B = b.prototype = new y(), B.constructor = b, We(B, d.prototype), B.isPureReactComponent = !0;
+      var Ae = Array.isArray, Qe = /* @__PURE__ */ Symbol.for("react.client.reference"), w = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, pe = Object.prototype.hasOwnProperty, Pe = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      B = {
+        react_stack_bottom_frame: function(e) {
+          return e();
+        }
+      };
+      var Oe, Me, Ne = {}, Ke = B.react_stack_bottom_frame.bind(
+        B,
+        U
+      )(), Xe = Pe(L(U)), je = !1, Ie = /\/+/g, Ue = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var r = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(r)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, Le = !1, ge = null, ve = 0, ye = !1, Te = !1, De = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : V;
+      B = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return A().useMemoCache(e);
+        }
+      });
+      var le = {
+        map: te,
+        forEach: function(e, r, i) {
+          te(
+            e,
+            function() {
+              r.apply(this, arguments);
+            },
+            i
+          );
+        },
+        count: function(e) {
+          var r = 0;
+          return te(e, function() {
+            r++;
+          }), r;
+        },
+        toArray: function(e) {
+          return te(e, function(r) {
+            return r;
+          }) || [];
+        },
+        only: function(e) {
+          if (!x(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      };
+      n.Activity = Re, n.Children = le, n.Component = d, n.Fragment = t, n.Profiler = l, n.PureComponent = b, n.StrictMode = o, n.Suspense = p, n.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = w, n.__COMPILER_RUNTIME = B, n.act = function(e) {
+        var r = w.actQueue, i = ve;
+        ve++;
+        var c = w.actQueue = r !== null ? r : [], h = !1;
+        try {
+          var R = e();
+        } catch (C) {
+          w.thrownErrors.push(C);
+        }
+        if (0 < w.thrownErrors.length)
+          throw q(r, i), e = Q(w.thrownErrors), w.thrownErrors.length = 0, e;
+        if (R !== null && typeof R == "object" && typeof R.then == "function") {
+          var T = R;
+          return De(function() {
+            h || ye || (ye = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(C, oe) {
+              h = !0, T.then(
+                function(ce) {
+                  if (q(r, i), i === 0) {
+                    try {
+                      ne(c), V(function() {
+                        return K(
+                          ce,
+                          C,
+                          oe
+                        );
+                      });
+                    } catch (Je) {
+                      w.thrownErrors.push(Je);
+                    }
+                    if (0 < w.thrownErrors.length) {
+                      var Ve = Q(
+                        w.thrownErrors
+                      );
+                      w.thrownErrors.length = 0, oe(Ve);
+                    }
+                  } else C(ce);
+                },
+                function(ce) {
+                  q(r, i), 0 < w.thrownErrors.length && (ce = Q(
+                    w.thrownErrors
+                  ), w.thrownErrors.length = 0), oe(ce);
+                }
+              );
+            }
+          };
+        }
+        var P = R;
+        if (q(r, i), i === 0 && (ne(c), c.length !== 0 && De(function() {
+          h || ye || (ye = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), w.actQueue = null), 0 < w.thrownErrors.length)
+          throw e = Q(w.thrownErrors), w.thrownErrors.length = 0, e;
+        return {
+          then: function(C, oe) {
+            h = !0, i === 0 ? (w.actQueue = c, V(function() {
+              return K(
+                P,
+                C,
+                oe
+              );
+            })) : C(P);
+          }
+        };
+      }, n.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, n.cacheSignal = function() {
+        return null;
+      }, n.captureOwnerStack = function() {
+        var e = w.getCurrentStack;
+        return e === null ? null : e();
+      }, n.cloneElement = function(e, r, i) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var c = We({}, e.props), h = e.key, R = e._owner;
+        if (r != null) {
+          var T;
+          e: {
+            if (pe.call(r, "ref") && (T = Object.getOwnPropertyDescriptor(
+              r,
+              "ref"
+            ).get) && T.isReactWarning) {
+              T = !1;
+              break e;
+            }
+            T = r.ref !== void 0;
+          }
+          T && (R = $()), D(r) && (m(r.key), h = "" + r.key);
+          for (P in r)
+            !pe.call(r, P) || P === "key" || P === "__self" || P === "__source" || P === "ref" && r.ref === void 0 || (c[P] = r[P]);
+        }
+        var P = arguments.length - 2;
+        if (P === 1) c.children = i;
+        else if (1 < P) {
+          T = Array(P);
+          for (var C = 0; C < P; C++)
+            T[C] = arguments[C + 2];
+          c.children = T;
+        }
+        for (c = N(
+          e.type,
+          h,
+          c,
+          R,
+          e._debugStack,
+          e._debugTask
+        ), h = 2; h < arguments.length; h++)
+          X(arguments[h]);
+        return c;
+      }, n.createContext = function(e) {
+        return e = {
+          $$typeof: _,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: f,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, n.createElement = function(e, r, i) {
+        for (var c = 2; c < arguments.length; c++)
+          X(arguments[c]);
+        c = {};
+        var h = null;
+        if (r != null)
+          for (C in Me || !("__self" in r) || "key" in r || (Me = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), D(r) && (m(r.key), h = "" + r.key), r)
+            pe.call(r, C) && C !== "key" && C !== "__self" && C !== "__source" && (c[C] = r[C]);
+        var R = arguments.length - 2;
+        if (R === 1) c.children = i;
+        else if (1 < R) {
+          for (var T = Array(R), P = 0; P < R; P++)
+            T[P] = arguments[P + 2];
+          Object.freeze && Object.freeze(T), c.children = T;
+        }
+        if (e && e.defaultProps)
+          for (C in R = e.defaultProps, R)
+            c[C] === void 0 && (c[C] = R[C]);
+        h && F(
+          c,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var C = 1e4 > w.recentlyCreatedOwnerStacks++;
+        return N(
+          e,
+          h,
+          c,
+          $(),
+          C ? Error("react-stack-top-frame") : Ke,
+          C ? Pe(L(e)) : Xe
+        );
+      }, n.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, n.forwardRef = function(e) {
+        e != null && e.$$typeof === j ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var r = { $$typeof: S, render: e }, i;
+        return Object.defineProperty(r, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return i;
+          },
+          set: function(c) {
+            i = c, e.name || e.displayName || (Object.defineProperty(e, "name", { value: c }), e.displayName = c);
+          }
+        }), r;
+      }, n.isValidElement = x, n.lazy = function(e) {
+        e = { _status: -1, _result: e };
+        var r = {
+          $$typeof: ee,
+          _payload: e,
+          _init: ie
+        }, i = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        return e._ioInfo = i, r._debugInfo = [{ awaited: i }], r;
+      }, n.memo = function(e, r) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), r = {
+          $$typeof: j,
+          type: e,
+          compare: r === void 0 ? null : r
+        };
+        var i;
+        return Object.defineProperty(r, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return i;
+          },
+          set: function(c) {
+            i = c, e.name || e.displayName || (Object.defineProperty(e, "name", { value: c }), e.displayName = c);
+          }
+        }), r;
+      }, n.startTransition = function(e) {
+        var r = w.T, i = {};
+        i._updatedFibers = /* @__PURE__ */ new Set(), w.T = i;
+        try {
+          var c = e(), h = w.S;
+          h !== null && h(i, c), typeof c == "object" && c !== null && typeof c.then == "function" && (w.asyncTransitions++, c.then(re, re), c.then(O, Ue));
+        } catch (R) {
+          Ue(R);
+        } finally {
+          r === null && i._updatedFibers && (e = i._updatedFibers.size, i._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), r !== null && i.types !== null && (r.types !== null && r.types !== i.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), r.types = i.types), w.T = r;
+        }
+      }, n.unstable_useCacheRefresh = function() {
+        return A().useCacheRefresh();
+      }, n.use = function(e) {
+        return A().use(e);
+      }, n.useActionState = function(e, r, i) {
+        return A().useActionState(
+          e,
+          r,
+          i
+        );
+      }, n.useCallback = function(e, r) {
+        return A().useCallback(e, r);
+      }, n.useContext = function(e) {
+        var r = A();
+        return e.$$typeof === f && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), r.useContext(e);
+      }, n.useDebugValue = function(e, r) {
+        return A().useDebugValue(e, r);
+      }, n.useDeferredValue = function(e, r) {
+        return A().useDeferredValue(e, r);
+      }, n.useEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), A().useEffect(e, r);
+      }, n.useEffectEvent = function(e) {
+        return A().useEffectEvent(e);
+      }, n.useId = function() {
+        return A().useId();
+      }, n.useImperativeHandle = function(e, r, i) {
+        return A().useImperativeHandle(e, r, i);
+      }, n.useInsertionEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), A().useInsertionEffect(e, r);
+      }, n.useLayoutEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), A().useLayoutEffect(e, r);
+      }, n.useMemo = function(e, r) {
+        return A().useMemo(e, r);
+      }, n.useOptimistic = function(e, r) {
+        return A().useOptimistic(e, r);
+      }, n.useReducer = function(e, r, i) {
+        return A().useReducer(e, r, i);
+      }, n.useRef = function(e) {
+        return A().useRef(e);
+      }, n.useState = function(e) {
+        return A().useState(e);
+      }, n.useSyncExternalStore = function(e, r, i) {
+        return A().useSyncExternalStore(
+          e,
+          r,
+          i
+        );
+      }, n.useTransition = function() {
+        return A().useTransition();
+      }, n.version = "19.2.3", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  })(he, he.exports)), he.exports;
+}
+var xe;
+function Ge() {
+  return xe || (xe = 1, process.env.NODE_ENV === "production" ? ke.exports = Ze() : ke.exports = et()), ke.exports;
+}
+var M = Ge();
+const tt = typeof process < "u" && process.env?.NODE_ENV === "production", ze = typeof process < "u" && process.env?.MCP_DEBUG, _e = ze === "true" || !tt && ze !== "false", E = {
+  log: (...v) => {
+    _e && console.log(...v);
+  },
+  debug: (...v) => {
+    _e && console.debug(...v);
+  },
+  info: (...v) => {
+    console.info(...v);
+  },
+  error: (...v) => {
+    console.error(...v);
+  },
+  warn: (...v) => {
+    _e && console.warn(...v);
+  }
+};
+class rt {
+  // Configurable worker script URLs (defaults kept for backward compatibility)
+  sharedWorkerUrl = "/mcp-shared-worker.js";
+  serviceWorkerUrl = "/mcp-service-worker.js";
+  // Backend websocket URL to pass into the worker(s)
+  backendWsUrl = "ws://localhost:3001";
+  serviceWorkerRegistration = null;
+  sharedWorker = null;
+  sharedWorkerPort = null;
+  workerType = null;
+  pendingAuthToken = null;
+  // connection status subscribers
+  connectionStatusCallbacks = /* @__PURE__ */ new Set();
+  // Mutex/promise to prevent concurrent init runs
+  initPromise = null;
+  // Initialization state
+  isInitialized = !1;
+  initResolvers = [];
+  // Queue for operations that need to wait for initialization
+  pendingRegistrations = [];
+  // Map to store tool handlers in main thread
+  toolHandlers = /* @__PURE__ */ new Map();
+  // Tool registry for tracking registrations and reference counting
+  toolRegistry = /* @__PURE__ */ new Map();
+  // Subscribers for tool changes (for React hooks reactivity)
+  toolChangeListeners = /* @__PURE__ */ new Map();
+  // Initialize and choose worker implementation (prefer SharedWorker)
+  // Accept either a ServiceWorkerRegistration OR WorkerInitOptions to configure URLs
+  async init(n) {
+    E.log("[WorkerClient] init() called", {
+      hasOptions: !!n,
+      currentWorkerType: this.workerType,
+      initInProgress: !!this.initPromise,
+      timestamp: Date.now()
+    });
+    let s;
+    const a = n;
+    if (a && typeof a.scope == "string")
+      s = n, E.log("[WorkerClient] Using explicit ServiceWorker registration");
+    else if (n) {
+      const u = n;
+      E.log("[WorkerClient] Using WorkerClientInitOptions:", u), u.sharedWorkerUrl && (this.sharedWorkerUrl = u.sharedWorkerUrl), u.serviceWorkerUrl && (this.serviceWorkerUrl = u.serviceWorkerUrl), u.backendWsUrl && (this.backendWsUrl = u.backendWsUrl);
+    }
+    return this.initPromise ? this.initPromise.then(async () => {
+      s && this.workerType !== "service" && await this.init(s);
+    }) : (this.initPromise = (async () => {
+      try {
+        if (s) {
+          this.serviceWorkerRegistration = s, this.workerType = "service", E.info(
+            "[WorkerClient] Using ServiceWorker (explicit registration)"
+          );
+          try {
+            const d = {
+              type: "INIT",
+              backendUrl: this.backendWsUrl
+            };
+            this.pendingAuthToken && (d.token = this.pendingAuthToken), this.serviceWorkerRegistration.active ? this.serviceWorkerRegistration.active.postMessage(d) : "serviceWorker" in navigator && navigator.serviceWorker.controller && navigator.serviceWorker.controller.postMessage(d);
+          } catch {
+          }
+          return;
+        }
+        if (await this.initSharedWorker()) {
+          this.markAsInitialized();
+          return;
+        }
+        await this.initServiceWorkerFallback(), this.markAsInitialized();
+      } finally {
+        this.initPromise = null;
+      }
+    })(), this.initPromise);
+  }
+  /**
+   * Mark worker as initialized and process pending registrations
+   * @private
+   */
+  markAsInitialized() {
+    this.isInitialized = !0, E.log(
+      "[WorkerClient] Worker initialized, processing pending operations"
+    ), this.initResolvers.forEach((s) => s()), this.initResolvers = [];
+    const n = [...this.pendingRegistrations];
+    this.pendingRegistrations = [], n.forEach(
+      async ({ name: s, description: a, inputSchema: u, handler: d, resolve: y, reject: b }) => {
+        try {
+          await this.registerToolInternal(
+            s,
+            a,
+            u,
+            d
+          ), y();
+        } catch (O) {
+          b(O instanceof Error ? O : new Error(String(O)));
+        }
+      }
+    );
+  }
+  /**
+   * Wait for worker initialization
+   * @returns Promise that resolves when worker is initialized
+   */
+  async waitForInit() {
+    if (this.isInitialized)
+      return Promise.resolve();
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    return new Promise((n) => {
+      this.initResolvers.push(n);
+    });
+  }
+  /**
+   * Check if worker is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
+  async initSharedWorker() {
+    if (typeof SharedWorker > "u")
+      return Promise.resolve(!1);
+    try {
+      this.sharedWorker = new SharedWorker(this.sharedWorkerUrl, {
+        type: "module"
+      }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), await new Promise((s, a) => {
+        let u = !1;
+        const d = setTimeout(() => {
+          if (!u) {
+            const b = this.sharedWorkerPort;
+            b && (b.onmessage = null), a(new Error("SharedWorker initialization timeout"));
+          }
+        }, 2e3), y = this.sharedWorkerPort;
+        if (!y)
+          return clearTimeout(d), a(new Error("SharedWorker port not available"));
+        y.onmessage = (b) => {
+          try {
+            const O = b.data;
+            O && O.type === "CONNECTION_STATUS" && (clearTimeout(d), u = !0, this.workerType = "shared", y.onmessage = null, s(!0));
+          } catch {
+          }
+        };
+      });
+      const n = this.sharedWorkerPort;
+      if (n) {
+        try {
+          const s = {
+            type: "INIT",
+            backendUrl: this.backendWsUrl
+          };
+          this.pendingAuthToken && (s.token = this.pendingAuthToken), n.postMessage(s), this.pendingAuthToken = null;
+        } catch (s) {
+          E.warn(
+            "[WorkerClient] Failed to send INIT to SharedWorker port:",
+            s
+          );
+        }
+        n.onmessage = (s) => {
+          try {
+            const a = s.data;
+            if (a && a.type === "CONNECTION_STATUS") {
+              const u = !!a.connected;
+              this.connectionStatusCallbacks.forEach((d) => {
+                try {
+                  d(u);
+                } catch {
+                }
+              });
+            } else a && a.type === "CALL_TOOL" && this.handleToolCall(a.toolName, a.args, a.callId).catch(
+              (u) => {
+                E.error(
+                  "[WorkerClient] Failed to handle tool call:",
+                  u
+                );
+              }
+            );
+          } catch {
+          }
+        };
+      }
+      return E.info("[WorkerClient] Using SharedWorker"), !0;
+    } catch (n) {
+      return E.warn(
+        "[WorkerClient] SharedWorker not available, falling back to ServiceWorker:",
+        n
+      ), !1;
+    }
+  }
+  async initServiceWorkerFallback() {
+    if ("serviceWorker" in navigator)
+      try {
+        const n = await navigator.serviceWorker.getRegistration();
+        if (n) {
+          this.serviceWorkerRegistration = n, this.workerType = "service", E.info(
+            "[WorkerClient] Using existing ServiceWorker registration"
+          );
+          return;
+        }
+        this.serviceWorkerRegistration = await navigator.serviceWorker.register(
+          this.serviceWorkerUrl
+        ), this.workerType = "service", "serviceWorker" in navigator && navigator.serviceWorker.addEventListener(
+          "message",
+          (s) => {
+            try {
+              const a = s.data;
+              a && a.type === "CALL_TOOL" && this.handleToolCall(
+                a.toolName,
+                a.args,
+                a.callId
+              ).catch((u) => {
+                E.error(
+                  "[WorkerClient] Failed to handle tool call:",
+                  u
+                );
+              });
+            } catch (a) {
+              E.error(
+                "[WorkerClient] Error processing ServiceWorker message:",
+                a
+              );
+            }
+          }
+        ), E.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
+        try {
+          const s = {
+            type: "INIT",
+            backendUrl: this.backendWsUrl
+          };
+          this.pendingAuthToken && (s.token = this.pendingAuthToken), this.serviceWorkerRegistration.active ? this.serviceWorkerRegistration.active.postMessage(s) : "serviceWorker" in navigator && navigator.serviceWorker.controller && navigator.serviceWorker.controller.postMessage(s), this.pendingAuthToken = null;
+        } catch {
+        }
+      } catch (n) {
+        throw E.error("[WorkerClient] Failed to register ServiceWorker:", n), n;
+      }
+    else
+      throw new Error("Neither SharedWorker nor ServiceWorker is supported");
+  }
+  // Low-level request that expects a reply via MessageChannel
+  async request(n, s, a = 5e3) {
+    if (E.log("[WorkerClient] Request started:", {
+      type: n,
+      payload: s,
+      timeoutMs: a,
+      workerType: this.workerType,
+      hasSharedWorkerPort: !!this.sharedWorkerPort,
+      hasServiceWorkerReg: !!this.serviceWorkerRegistration
+    }), this.workerType === "shared" && this.sharedWorkerPort)
+      return new Promise((u, d) => {
+        const y = new MessageChannel(), b = Math.random().toString(36).substring(7), O = Date.now(), I = setTimeout(() => {
+          const m = Date.now() - O;
+          E.error("[WorkerClient] Request timeout:", {
+            type: n,
+            requestId: b,
+            elapsed: m,
+            timeoutMs: a
+          }), y.port1.onmessage = null, d(new Error("Request timeout"));
+        }, a);
+        y.port1.onmessage = (m) => {
+          try {
+            const k = Date.now() - O;
+            E.log("[WorkerClient] Request response received:", {
+              type: n,
+              requestId: b,
+              elapsed: k,
+              success: m.data?.success
+            }), clearTimeout(I), m.data && m.data.success ? u(m.data) : m.data && m.data.success === !1 ? d(new Error(m.data.error || "Worker error")) : u(m.data);
+          } catch (k) {
+            clearTimeout(I), y.port1.onmessage = null, d(
+              k instanceof Error ? k : new Error(String(k))
+            );
+          }
+        };
+        try {
+          const m = this.sharedWorkerPort;
+          if (!m)
+            return clearTimeout(I), E.error("[WorkerClient] SharedWorker port not available"), d(new Error("SharedWorker port not available"));
+          E.log("[WorkerClient] Posting message to SharedWorker:", {
+            type: n,
+            requestId: b
+          }), m.postMessage({ type: n, ...s || {} }, [y.port2]);
+        } catch (m) {
+          clearTimeout(I), E.error("[WorkerClient] Failed to post message:", m), d(m instanceof Error ? m : new Error(String(m)));
+        }
+      });
+    if (this.workerType === "service" && this.serviceWorkerRegistration) {
+      const u = this.serviceWorkerRegistration;
+      if (!u) throw new Error("Service worker registration missing");
+      if (!u.active && (E.log("[WorkerClient] ServiceWorker not active, waiting..."), await navigator.serviceWorker.ready, !u.active))
+        throw new Error("Service worker not active");
+      return new Promise((d, y) => {
+        const b = new MessageChannel(), O = Math.random().toString(36).substring(7), I = Date.now(), m = setTimeout(() => {
+          const k = Date.now() - I;
+          E.error("[WorkerClient] ServiceWorker request timeout:", {
+            type: n,
+            requestId: O,
+            elapsed: k,
+            timeoutMs: a
+          }), b.port1.onmessage = null, y(new Error("Request timeout"));
+        }, a);
+        b.port1.onmessage = (k) => {
+          try {
+            const L = Date.now() - I;
+            E.log("[WorkerClient] ServiceWorker response received:", {
+              type: n,
+              requestId: O,
+              elapsed: L,
+              success: k.data?.success
+            }), clearTimeout(m), k.data && k.data.success ? d(k.data) : k.data && k.data.success === !1 ? y(new Error(k.data.error || "Worker error")) : d(k.data);
+          } catch (L) {
+            clearTimeout(m), b.port1.onmessage = null, y(
+              L instanceof Error ? L : new Error(String(L))
+            );
+          }
+        };
+        try {
+          const k = u.active;
+          if (!k)
+            return clearTimeout(m), E.error(
+              "[WorkerClient] ServiceWorker active instance not available"
+            ), y(
+              new Error("Service worker active instance not available")
+            );
+          E.log("[WorkerClient] Posting message to ServiceWorker:", {
+            type: n,
+            requestId: O
+          }), k.postMessage({ type: n, ...s || {} }, [b.port2]);
+        } catch (k) {
+          clearTimeout(m), E.error(
+            "[WorkerClient] Failed to post message to ServiceWorker:",
+            k
+          ), y(k instanceof Error ? k : new Error(String(k)));
+        }
+      });
+    }
+    throw new Error("No worker registered");
+  }
+  // Fire-and-forget postMessage (no response expected)
+  async post(n, s) {
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
+      try {
+        this.sharedWorkerPort.postMessage({ type: n, ...s || {} });
+      } catch (a) {
+        E.error("[WorkerClient] Failed to post to SharedWorker:", a);
+      }
+      return;
+    }
+    if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
+      try {
+        this.serviceWorkerRegistration.active.postMessage({
+          type: n,
+          ...s || {}
+        });
+      } catch (a) {
+        E.error(
+          "[WorkerClient] Failed to post to ServiceWorker (active):",
+          a
+        );
+      }
+      return;
+    }
+    if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+      try {
+        navigator.serviceWorker.controller.postMessage({
+          type: n,
+          ...s || {}
+        });
+      } catch (a) {
+        E.error(
+          "[WorkerClient] Failed to post to ServiceWorker.controller:",
+          a
+        );
+      }
+      return;
+    }
+    if (n === "SET_AUTH_TOKEN" && s) {
+      const a = s.token;
+      typeof a == "string" && (this.pendingAuthToken = a);
+    }
+  }
+  sendAuthTokenToServiceWorker(n) {
+    if (this.serviceWorkerRegistration?.active)
+      try {
+        this.serviceWorkerRegistration.active.postMessage({
+          type: "SET_AUTH_TOKEN",
+          token: n
+        });
+      } catch (s) {
+        console.error(
+          "[WorkerClient] Failed to send auth token to ServiceWorker:",
+          s
+        );
+      }
+    else if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
+      try {
+        navigator.serviceWorker.controller.postMessage({
+          type: "SET_AUTH_TOKEN",
+          token: n
+        });
+      } catch (s) {
+        console.error(
+          "[WorkerClient] Failed to send auth token to ServiceWorker.controller:",
+          s
+        );
+      }
+    else
+      this.pendingAuthToken = n;
+  }
+  // Subscription API for consumers to listen for connection status updates
+  onConnectionStatus(n) {
+    this.connectionStatusCallbacks.add(n);
+  }
+  offConnectionStatus(n) {
+    this.connectionStatusCallbacks.delete(n);
+  }
+  async getConnectionStatus() {
+    try {
+      const n = await this.request(
+        "GET_CONNECTION_STATUS",
+        void 0,
+        2e3
+      );
+      return n && typeof n == "object" && "connected" in n ? !!n.connected : !!n?.connected;
+    } catch {
+      return !1;
+    }
+  }
+  setAuthToken(n) {
+    if (this.pendingAuthToken = n, this.workerType === "shared" && this.sharedWorkerPort)
+      try {
+        this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: n }), this.pendingAuthToken = null;
+      } catch (s) {
+        E.error(
+          "[WorkerClient] Failed to set auth token on SharedWorker:",
+          s
+        );
+      }
+    else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(n), this.pendingAuthToken = null);
+  }
+  /**
+   * Register a custom MCP tool dynamically
+   *
+   * The handler function runs in the MAIN THREAD (browser context), not in the worker.
+   * This means you have full access to:
+   * - React context, hooks, Redux store
+   * - DOM API, window, localStorage
+   * - All your imports and dependencies
+   * - Closures and external variables
+   *
+   * The worker acts as a proxy - it receives MCP tool calls and forwards them
+   * to your handler via MessageChannel.
+   *
+   * @param name - Tool name
+   * @param description - Tool description
+   * @param inputSchema - JSON Schema for tool inputs
+   * @param handler - Async function that handles the tool execution (runs in main thread)
+   * @returns Promise that resolves when tool is registered
+   *
+   * @example With full access to imports and context:
+   * ```typescript
+   * import { z } from 'zod';
+   * import { useMyStore } from './store';
+   *
+   * const store = useMyStore();
+   *
+   * await client.registerTool(
+   *   'validate_user',
+   *   'Validate user data',
+   *   { type: 'object', properties: { username: { type: 'string' } } },
+   *   async (args: any) => {
+   *     // Full access to everything!
+   *     const schema = z.object({ username: z.string().min(3) });
+   *     const validated = schema.parse(args);
+   *
+   *     // Can access store, context, etc.
+   *     const currentUser = store.getState().user;
+   *
+   *     return {
+   *       content: [{
+   *         type: 'text',
+   *         text: JSON.stringify({ validated, currentUser })
+   *       }]
+   *     };
+   *   }
+   * );
+   * ```
+   */
+  async registerTool(n, s, a, u) {
+    return this.isInitialized ? this.registerToolInternal(n, s, a, u) : (E.log(
+      `[WorkerClient] Queueing tool registration '${n}' (worker not initialized yet)`
+    ), new Promise((d, y) => {
+      this.pendingRegistrations.push({
+        name: n,
+        description: s,
+        inputSchema: a,
+        handler: u,
+        resolve: d,
+        reject: y
+      });
+    }));
+  }
+  /**
+   * Internal method to register tool (assumes worker is initialized)
+   * @private
+   */
+  async registerToolInternal(n, s, a, u) {
+    const d = this.toolRegistry.get(n);
+    if (d) {
+      d.refCount++, E.log(
+        `[WorkerClient] Incremented ref count for '${n}': ${d.refCount}`
+      ), this.toolHandlers.set(n, u), this.notifyToolChange(n);
+      return;
+    }
+    this.toolHandlers.set(n, u), await this.request("REGISTER_TOOL", {
+      name: n,
+      description: s,
+      inputSchema: a,
+      handlerType: "proxy"
+      // Tell worker this is a proxy handler
+    }), this.toolRegistry.set(n, {
+      refCount: 1,
+      description: s,
+      inputSchema: a,
+      isRegistered: !0
+    }), E.log(
+      `[WorkerClient] Registered tool '${n}' with main-thread handler`
+    ), this.notifyToolChange(n);
+  }
+  /**
+   * Unregister a previously registered MCP tool
+   * @param name - Tool name to unregister
+   * @returns Promise that resolves to true if tool was found and removed
+   */
+  async unregisterTool(n) {
+    const s = this.toolRegistry.get(n);
+    if (!s)
+      return E.warn(`[WorkerClient] Cannot unregister '${n}': not found`), !1;
+    if (s.refCount--, E.log(
+      `[WorkerClient] Decremented ref count for '${n}': ${s.refCount}`
+    ), s.refCount <= 0) {
+      this.toolHandlers.delete(n);
+      const a = await this.request(
+        "UNREGISTER_TOOL",
+        { name: n }
+      );
+      return this.toolRegistry.delete(n), E.log(`[WorkerClient] Unregistered tool '${n}'`), this.notifyToolChange(n), a?.success ?? !1;
+    }
+    return this.notifyToolChange(n), !0;
+  }
+  /**
+   * Subscribe to tool changes for a specific tool
+   * Returns unsubscribe function
+   */
+  onToolChange(n, s) {
+    this.toolChangeListeners.has(n) || this.toolChangeListeners.set(n, /* @__PURE__ */ new Set());
+    const a = this.toolChangeListeners.get(n);
+    a.add(s);
+    const u = this.toolRegistry.get(n);
+    return s(u ? {
+      refCount: u.refCount,
+      isRegistered: u.isRegistered
+    } : null), () => {
+      a.delete(s), a.size === 0 && this.toolChangeListeners.delete(n);
+    };
+  }
+  /**
+   * Notify all listeners about tool changes
+   * @private
+   */
+  notifyToolChange(n) {
+    const s = this.toolChangeListeners.get(n);
+    if (!s || s.size === 0) return;
+    const a = this.toolRegistry.get(n), u = a ? {
+      refCount: a.refCount,
+      isRegistered: a.isRegistered
+    } : null;
+    s.forEach((d) => {
+      try {
+        d(u);
+      } catch (y) {
+        E.error("[WorkerClient] Error in tool change listener:", y);
+      }
+    });
+  }
+  /**
+   * Get tool info from registry
+   */
+  getToolInfo(n) {
+    const s = this.toolRegistry.get(n);
+    return s ? {
+      refCount: s.refCount,
+      isRegistered: s.isRegistered
+    } : null;
+  }
+  /**
+   * Get all registered tool names
+   */
+  getRegisteredTools() {
+    return Array.from(this.toolRegistry.keys()).filter(
+      (n) => this.toolRegistry.get(n)?.isRegistered
+    );
+  }
+  /**
+   * Check if a tool is registered
+   */
+  isToolRegistered(n) {
+    return this.toolRegistry.get(n)?.isRegistered ?? !1;
+  }
+  /**
+   * Handle tool call from worker - execute handler in main thread and return result
+   * @private
+   */
+  async handleToolCall(n, s, a) {
+    E.log(`[WorkerClient] Handling tool call: ${n}`, {
+      callId: a,
+      args: s
+    });
+    try {
+      const u = this.toolHandlers.get(n);
+      if (!u)
+        throw new Error(`Tool handler not found: ${n}`);
+      const d = await u(s);
+      this.sendToolCallResult(a, { success: !0, result: d });
+    } catch (u) {
+      E.error(`[WorkerClient] Tool call failed: ${n}`, u), this.sendToolCallResult(a, {
+        success: !1,
+        error: u instanceof Error ? u.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Send tool call result back to worker
+   * @private
+   */
+  sendToolCallResult(n, s) {
+    const a = {
+      type: "TOOL_CALL_RESULT",
+      callId: n,
+      success: s.success,
+      result: s.result,
+      error: s.error
+    };
+    if (this.workerType === "shared" && this.sharedWorkerPort)
+      try {
+        this.sharedWorkerPort.postMessage(a);
+      } catch (u) {
+        E.error(
+          "[WorkerClient] Failed to send result to SharedWorker:",
+          u
+        );
+      }
+    else if (this.workerType === "service" && this.serviceWorkerRegistration?.active)
+      try {
+        this.serviceWorkerRegistration.active.postMessage(a);
+      } catch (u) {
+        E.error(
+          "[WorkerClient] Failed to send result to ServiceWorker:",
+          u
+        );
+      }
+  }
+}
+const J = new rt();
+function Be(v) {
+  const {
+    name: n,
+    description: s,
+    inputSchema: a,
+    handler: u,
+    autoRegister: d = !0,
+    autoUnregister: y = !0
+  } = v, [b, O] = M.useState(null), I = M.useRef(u), m = M.useRef(n), k = M.useRef(s), L = M.useRef(a), $ = M.useRef(!0), U = M.useRef(!1);
+  M.useEffect(() => {
+    I.current = u, m.current = n, k.current = s, L.current = a;
+  }, [u, n, s, a]);
+  const D = M.useCallback(async (N) => I.current(N), []), F = M.useCallback(async () => {
+    const N = m.current, G = k.current, X = L.current;
+    try {
+      await J.registerTool(
+        N,
+        G,
+        X,
+        D
+      ), U.current = !0, console.log(`[useMCPTool] Registered tool '${N}'`);
+    } catch (x) {
+      throw console.error(
+        `[useMCPTool] Failed to register tool '${N}':`,
+        x
+      ), x;
+    }
+  }, [D]), H = M.useCallback(async () => {
+    const N = m.current;
+    try {
+      await J.unregisterTool(N), U.current = !1, console.log(`[useMCPTool] Unregistered tool '${N}'`);
+    } catch (G) {
+      console.error(
+        `[useMCPTool] Failed to unregister tool '${N}':`,
+        G
+      );
+    }
+  }, []);
+  return M.useEffect(() => J.onToolChange(n, (G) => {
+    O(G);
+  }), [n]), M.useEffect(() => (d && F().catch((N) => {
+    console.error(
+      `[useMCPTool] Auto-register failed for '${n}':`,
+      N
+    );
+  }), () => {
+    $.current = !1, y && U.current && H().catch((N) => {
+      console.error(
+        `[useMCPTool] Auto-unregister failed for '${n}':`,
+        N
+      );
+    });
+  }), [n]), {
+    isRegistered: b?.isRegistered ?? !1,
+    refCount: b?.refCount ?? 0,
+    register: F,
+    unregister: H
+  };
+}
+function at(v) {
+  return J.isToolRegistered(v);
+}
+function ut() {
+  return J.getRegisteredTools();
+}
+function ct(v) {
+  return J.getToolInfo(v);
+}
+function lt(v, n, s, a) {
+  const u = M.useCallback(async () => {
+    const d = await s();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(d, null, 2)
+        }
+      ]
+    };
+  }, [s]);
+  return Be({
+    name: v,
+    description: n,
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    handler: u,
+    ...a
+  });
+}
+function ft(v, n, s, a, u) {
+  const d = M.useCallback(
+    async (y) => {
+      const b = await a(y);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(b, null, 2)
+          }
+        ]
+      };
+    },
+    [a]
+  );
+  return Be({
+    name: v,
+    description: n,
+    inputSchema: {
+      type: "object",
+      properties: s,
+      ...u?.required && { required: u.required }
+    },
+    handler: d,
+    autoRegister: u?.autoRegister,
+    autoUnregister: u?.autoUnregister
+  });
+}
+var Ee = { exports: {} }, fe = {};
+var qe;
+function nt() {
+  if (qe) return fe;
+  qe = 1;
+  var v = /* @__PURE__ */ Symbol.for("react.transitional.element"), n = /* @__PURE__ */ Symbol.for("react.fragment");
+  function s(a, u, d) {
+    var y = null;
+    if (d !== void 0 && (y = "" + d), u.key !== void 0 && (y = "" + u.key), "key" in u) {
+      d = {};
+      for (var b in u)
+        b !== "key" && (d[b] = u[b]);
+    } else d = u;
+    return u = d.ref, {
+      $$typeof: v,
+      type: a,
+      key: y,
+      ref: u !== void 0 ? u : null,
+      props: d
+    };
+  }
+  return fe.Fragment = n, fe.jsx = s, fe.jsxs = s, fe;
+}
+var de = {};
+var $e;
+function ot() {
+  return $e || ($e = 1, process.env.NODE_ENV !== "production" && (function() {
+    function v(t) {
+      if (t == null) return null;
+      if (typeof t == "function")
+        return t.$$typeof === ie ? null : t.displayName || t.name || null;
+      if (typeof t == "string") return t;
+      switch (t) {
+        case F:
+          return "Fragment";
+        case N:
+          return "Profiler";
+        case H:
+          return "StrictMode";
+        case se:
+          return "Suspense";
+        case W:
+          return "SuspenseList";
+        case te:
+          return "Activity";
+      }
+      if (typeof t == "object")
+        switch (typeof t.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), t.$$typeof) {
+          case D:
+            return "Portal";
+          case X:
+            return t.displayName || "Context";
+          case G:
+            return (t._context.displayName || "Context") + ".Consumer";
+          case x:
+            var o = t.render;
+            return t = t.displayName, t || (t = o.displayName || o.name || "", t = t !== "" ? "ForwardRef(" + t + ")" : "ForwardRef"), t;
+          case ue:
+            return o = t.displayName || null, o !== null ? o : v(t.type) || "Memo";
+          case z:
+            o = t._payload, t = t._init;
+            try {
+              return v(t(o));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function n(t) {
+      return "" + t;
+    }
+    function s(t) {
+      try {
+        n(t);
+        var o = !1;
+      } catch {
+        o = !0;
+      }
+      if (o) {
+        o = console;
+        var l = o.error, f = typeof Symbol == "function" && Symbol.toStringTag && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return l.call(
+          o,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          f
+        ), n(t);
+      }
+    }
+    function a(t) {
+      if (t === F) return "<>";
+      if (typeof t == "object" && t !== null && t.$$typeof === z)
+        return "<...>";
+      try {
+        var o = v(t);
+        return o ? "<" + o + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function u() {
+      var t = A.A;
+      return t === null ? null : t.getOwner();
+    }
+    function d() {
+      return Error("react-stack-top-frame");
+    }
+    function y(t) {
+      if (re.call(t, "key")) {
+        var o = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (o && o.isReactWarning) return !1;
+      }
+      return t.key !== void 0;
+    }
+    function b(t, o) {
+      function l() {
+        q || (q = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          o
+        ));
+      }
+      l.isReactWarning = !0, Object.defineProperty(t, "key", {
+        get: l,
+        configurable: !0
+      });
+    }
+    function O() {
+      var t = v(this.type);
+      return K[t] || (K[t] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), t = this.props.ref, t !== void 0 ? t : null;
+    }
+    function I(t, o, l, f, _, S) {
+      var p = l.ref;
+      return t = {
+        $$typeof: U,
+        type: t,
+        key: o,
+        props: l,
+        _owner: f
+      }, (p !== void 0 ? p : null) !== null ? Object.defineProperty(t, "ref", {
+        enumerable: !1,
+        get: O
+      }) : Object.defineProperty(t, "ref", { enumerable: !1, value: null }), t._store = {}, Object.defineProperty(t._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(t, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(t, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: _
+      }), Object.defineProperty(t, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: S
+      }), Object.freeze && (Object.freeze(t.props), Object.freeze(t)), t;
+    }
+    function m(t, o, l, f, _, S) {
+      var p = o.children;
+      if (p !== void 0)
+        if (f)
+          if (V(p)) {
+            for (f = 0; f < p.length; f++)
+              k(p[f]);
+            Object.freeze && Object.freeze(p);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else k(p);
+      if (re.call(o, "key")) {
+        p = v(t);
+        var Y = Object.keys(o).filter(function(ee) {
+          return ee !== "key";
+        });
+        f = 0 < Y.length ? "{key: someKey, " + Y.join(": ..., ") + ": ...}" : "{key: someKey}", ae[p + f] || (Y = 0 < Y.length ? "{" + Y.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          f,
+          p,
+          Y,
+          p
+        ), ae[p + f] = !0);
+      }
+      if (p = null, l !== void 0 && (s(l), p = "" + l), y(o) && (s(o.key), p = "" + o.key), "key" in o) {
+        l = {};
+        for (var j in o)
+          j !== "key" && (l[j] = o[j]);
+      } else l = o;
+      return p && b(
+        l,
+        typeof t == "function" ? t.displayName || t.name || "Unknown" : t
+      ), I(
+        t,
+        p,
+        l,
+        u(),
+        _,
+        S
+      );
+    }
+    function k(t) {
+      L(t) ? t._store && (t._store.validated = 1) : typeof t == "object" && t !== null && t.$$typeof === z && (t._payload.status === "fulfilled" ? L(t._payload.value) && t._payload.value._store && (t._payload.value._store.validated = 1) : t._store && (t._store.validated = 1));
+    }
+    function L(t) {
+      return typeof t == "object" && t !== null && t.$$typeof === U;
+    }
+    var $ = Ge(), U = /* @__PURE__ */ Symbol.for("react.transitional.element"), D = /* @__PURE__ */ Symbol.for("react.portal"), F = /* @__PURE__ */ Symbol.for("react.fragment"), H = /* @__PURE__ */ Symbol.for("react.strict_mode"), N = /* @__PURE__ */ Symbol.for("react.profiler"), G = /* @__PURE__ */ Symbol.for("react.consumer"), X = /* @__PURE__ */ Symbol.for("react.context"), x = /* @__PURE__ */ Symbol.for("react.forward_ref"), se = /* @__PURE__ */ Symbol.for("react.suspense"), W = /* @__PURE__ */ Symbol.for("react.suspense_list"), ue = /* @__PURE__ */ Symbol.for("react.memo"), z = /* @__PURE__ */ Symbol.for("react.lazy"), te = /* @__PURE__ */ Symbol.for("react.activity"), ie = /* @__PURE__ */ Symbol.for("react.client.reference"), A = $.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, re = Object.prototype.hasOwnProperty, V = Array.isArray, Q = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    $ = {
+      react_stack_bottom_frame: function(t) {
+        return t();
+      }
+    };
+    var q, K = {}, ne = $.react_stack_bottom_frame.bind(
+      $,
+      d
+    )(), Z = Q(a(d)), ae = {};
+    de.Fragment = F, de.jsx = function(t, o, l) {
+      var f = 1e4 > A.recentlyCreatedOwnerStacks++;
+      return m(
+        t,
+        o,
+        l,
+        !1,
+        f ? Error("react-stack-top-frame") : ne,
+        f ? Q(a(t)) : Z
+      );
+    }, de.jsxs = function(t, o, l) {
+      var f = 1e4 > A.recentlyCreatedOwnerStacks++;
+      return m(
+        t,
+        o,
+        l,
+        !0,
+        f ? Error("react-stack-top-frame") : ne,
+        f ? Q(a(t)) : Z
+      );
+    };
+  })()), de;
+}
+var Fe;
+function st() {
+  return Fe || (Fe = 1, process.env.NODE_ENV === "production" ? Ee.exports = nt() : Ee.exports = ot()), Ee.exports;
+}
+var it = st();
+const we = M.createContext(null);
+function dt({
+  children: v,
+  autoInit: n = !0,
+  backendWsUrl: s = "ws://localhost:3001",
+  initOptions: a,
+  onInitialized: u,
+  onInitError: d
+}) {
+  const [y, b] = M.useState(!1), [O, I] = M.useState(!1), [m] = M.useState([]), k = M.useCallback(
+    async (U) => {
+      if (y) {
+        console.log("[MCPToolsProvider] Already initialized");
+        return;
+      }
+      try {
+        const D = U || a || { backendWsUrl: s };
+        console.log("[MCPToolsProvider] Initializing worker client...", D), await J.init(D), b(!0);
+        const F = await J.getConnectionStatus();
+        I(F), J.onConnectionStatus((H) => {
+          I(H);
+        }), console.log("[MCPToolsProvider] Worker client initialized"), u?.();
+      } catch (D) {
+        throw console.error("[MCPToolsProvider] Initialization failed:", D), d?.(
+          D instanceof Error ? D : new Error(String(D))
+        ), D;
+      }
+    },
+    [y, a, s, u, d]
+  ), L = M.useCallback(async () => {
+    const U = await J.getConnectionStatus();
+    return I(U), U;
+  }, []);
+  M.useEffect(() => {
+    n && k().catch((U) => {
+      console.error("[MCPToolsProvider] Auto-init failed:", U);
+    });
+  }, [n, k]), M.useEffect(() => {
+    if (!y) return;
+    const U = setInterval(() => {
+    }, 5e3);
+    return () => clearInterval(U);
+  }, [y]);
+  const $ = {
+    isInitialized: y,
+    isConnected: O,
+    registeredTools: m,
+    initialize: k,
+    getConnectionStatus: L
+  };
+  return /* @__PURE__ */ it.jsx(we.Provider, { value: $, children: v });
+}
+function ht(v = !1) {
+  const n = M.useContext(we);
+  if (!n && v)
+    throw new Error(
+      "useMCPToolsContext must be used within MCPToolsProvider. Either wrap your component tree with <MCPToolsProvider> or set strict=false."
+    );
+  return n || {
+    isInitialized: !1,
+    isConnected: !1,
+    registeredTools: [],
+    initialize: async () => {
+      throw new Error("MCPToolsProvider not found");
+    },
+    getConnectionStatus: async () => !1
+  };
+}
+function pt() {
+  return M.useContext(we) !== null;
+}
+export {
+  dt as MCPToolsProvider,
+  ut as getRegisteredTools,
+  ct as getToolInfo,
+  at as isToolRegistered,
+  pt as useHasMCPProvider,
+  ft as useMCPAction,
+  lt as useMCPGetter,
+  Be as useMCPTool,
+  ht as useMCPToolsContext
+};