@mcp-elements/core 0.1.0

package/dist/index.js

@@ -0,0 +1,887 @@
+// src/utils/cn.ts
+function cn(...inputs) {
+  return inputs.filter(Boolean).join(" ");
+}
+
+// src/utils/dom.ts
+function getFocusableElements(container) {
+  const elements = container.querySelectorAll(
+    'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])'
+  );
+  return Array.from(elements);
+}
+function trapFocus(container, event) {
+  const focusable = getFocusableElements(container);
+  if (focusable.length === 0) return;
+  const first = focusable[0];
+  const last = focusable[focusable.length - 1];
+  if (event.key === "Tab") {
+    if (event.shiftKey) {
+      if (document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      }
+    } else {
+      if (document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    }
+  }
+}
+function createClickOutsideHandler(element, callback) {
+  const handler = (event) => {
+    if (!element.contains(event.target)) {
+      callback();
+    }
+  };
+  document.addEventListener("mousedown", handler);
+  return () => document.removeEventListener("mousedown", handler);
+}
+function lockScroll() {
+  const scrollY = window.scrollY;
+  const body = document.body;
+  body.style.position = "fixed";
+  body.style.top = `-${scrollY}px`;
+  body.style.width = "100%";
+  body.style.overflow = "hidden";
+  return () => {
+    body.style.position = "";
+    body.style.top = "";
+    body.style.width = "";
+    body.style.overflow = "";
+    window.scrollTo(0, scrollY);
+  };
+}
+
+// src/utils/keyboard.ts
+var Keys = {
+  Enter: "Enter",
+  Space: " ",
+  Escape: "Escape",
+  ArrowUp: "ArrowUp",
+  ArrowDown: "ArrowDown",
+  ArrowLeft: "ArrowLeft",
+  ArrowRight: "ArrowRight",
+  Home: "Home",
+  End: "End",
+  Tab: "Tab"
+};
+function getNextIndex(current, total, direction, loop = true) {
+  if (direction === "next") {
+    const next = current + 1;
+    return next >= total ? loop ? 0 : current : next;
+  }
+  const prev = current - 1;
+  return prev < 0 ? loop ? total - 1 : current : prev;
+}
+function handleArrowNavigation(event, currentIndex, totalItems, orientation, onIndexChange, loop = true) {
+  const nextKeys = orientation === "horizontal" ? [Keys.ArrowRight] : orientation === "vertical" ? [Keys.ArrowDown] : [Keys.ArrowRight, Keys.ArrowDown];
+  const prevKeys = orientation === "horizontal" ? [Keys.ArrowLeft] : orientation === "vertical" ? [Keys.ArrowUp] : [Keys.ArrowLeft, Keys.ArrowUp];
+  if (nextKeys.includes(event.key)) {
+    event.preventDefault();
+    onIndexChange(getNextIndex(currentIndex, totalItems, "next", loop));
+  } else if (prevKeys.includes(event.key)) {
+    event.preventDefault();
+    onIndexChange(getNextIndex(currentIndex, totalItems, "prev", loop));
+  } else if (event.key === Keys.Home) {
+    event.preventDefault();
+    onIndexChange(0);
+  } else if (event.key === Keys.End) {
+    event.preventDefault();
+    onIndexChange(totalItems - 1);
+  }
+}
+
+// src/dialog.ts
+var dialogCounter = 0;
+function createDialog(config = {}) {
+  const { modal = true, onOpenChange } = config;
+  const id = `mcpe-dialog-${++dialogCounter}`;
+  return {
+    id,
+    getTriggerProps: (isOpen) => ({
+      "aria-haspopup": "dialog",
+      "aria-expanded": isOpen,
+      onClick: () => onOpenChange?.(!isOpen)
+    }),
+    getContentProps: (isOpen) => ({
+      role: "dialog",
+      "aria-modal": modal,
+      "aria-labelledby": `${id}-title`,
+      "aria-describedby": `${id}-description`,
+      hidden: !isOpen ? true : void 0,
+      onKeyDown: (e) => {
+        if (e.key === "Escape") onOpenChange?.(false);
+      }
+    }),
+    getOverlayProps: () => ({
+      "aria-hidden": true,
+      onClick: () => onOpenChange?.(false)
+    }),
+    getCloseProps: () => ({
+      "aria-label": "Close",
+      onClick: () => onOpenChange?.(false)
+    })
+  };
+}
+
+// src/tabs.ts
+function createTabs(items, config = {}) {
+  const { onValueChange } = config;
+  return {
+    getListProps: () => ({
+      role: "tablist"
+    }),
+    getTriggerProps: (value, activeValue) => {
+      const index = items.findIndex((item2) => item2.value === value);
+      const isActive = value === activeValue;
+      const item = items[index];
+      return {
+        role: "tab",
+        "aria-selected": isActive,
+        "aria-controls": `tabpanel-${value}`,
+        id: `tab-${value}`,
+        tabIndex: isActive ? 0 : -1,
+        disabled: item?.disabled || false,
+        onClick: () => {
+          if (!item?.disabled) onValueChange?.(value);
+        },
+        onKeyDown: (e) => {
+          const enabledItems = items.filter((i) => !i.disabled);
+          const currentEnabledIndex = enabledItems.findIndex((i) => i.value === value);
+          handleArrowNavigation(
+            e,
+            currentEnabledIndex,
+            enabledItems.length,
+            "horizontal",
+            (newIndex) => {
+              const newItem = enabledItems[newIndex];
+              onValueChange?.(newItem.value);
+            }
+          );
+        }
+      };
+    },
+    getPanelProps: (value, activeValue) => ({
+      role: "tabpanel",
+      id: `tabpanel-${value}`,
+      "aria-labelledby": `tab-${value}`,
+      hidden: value !== activeValue || void 0,
+      tabIndex: 0
+    })
+  };
+}
+
+// src/accordion.ts
+function createAccordion(items, config = {}) {
+  const { type = "single", collapsible = false, onValueChange } = config;
+  function toggle(value, expandedValues) {
+    const isExpanded = expandedValues.includes(value);
+    if (type === "single") {
+      if (isExpanded && collapsible) {
+        onValueChange?.([]);
+      } else if (!isExpanded) {
+        onValueChange?.([value]);
+      }
+    } else {
+      if (isExpanded) {
+        onValueChange?.(expandedValues.filter((v) => v !== value));
+      } else {
+        onValueChange?.([...expandedValues, value]);
+      }
+    }
+  }
+  return {
+    getItemProps: (value) => ({
+      "data-value": value
+    }),
+    getTriggerProps: (value, expandedValues) => {
+      const isExpanded = expandedValues.includes(value);
+      const item = items.find((i) => i.value === value);
+      return {
+        "aria-expanded": isExpanded,
+        "aria-controls": `accordion-content-${value}`,
+        id: `accordion-trigger-${value}`,
+        disabled: item?.disabled || false,
+        onClick: () => {
+          if (!item?.disabled) toggle(value, expandedValues);
+        },
+        onKeyDown: (e) => {
+          const enabledItems = items.filter((i) => !i.disabled);
+          const currentEnabledIndex = enabledItems.findIndex((i) => i.value === value);
+          if (e.key === Keys.ArrowDown) {
+            e.preventDefault();
+            const next = currentEnabledIndex + 1;
+            if (next < enabledItems.length) {
+              const el = document.getElementById(`accordion-trigger-${enabledItems[next].value}`);
+              el?.focus();
+            }
+          } else if (e.key === Keys.ArrowUp) {
+            e.preventDefault();
+            const prev = currentEnabledIndex - 1;
+            if (prev >= 0) {
+              const el = document.getElementById(`accordion-trigger-${enabledItems[prev].value}`);
+              el?.focus();
+            }
+          } else if (e.key === Keys.Home) {
+            e.preventDefault();
+            const el = document.getElementById(`accordion-trigger-${enabledItems[0].value}`);
+            el?.focus();
+          } else if (e.key === Keys.End) {
+            e.preventDefault();
+            const el = document.getElementById(`accordion-trigger-${enabledItems[enabledItems.length - 1].value}`);
+            el?.focus();
+          }
+        }
+      };
+    },
+    getContentProps: (value, expandedValues) => {
+      const isExpanded = expandedValues.includes(value);
+      return {
+        role: "region",
+        id: `accordion-content-${value}`,
+        "aria-labelledby": `accordion-trigger-${value}`,
+        hidden: !isExpanded ? true : void 0
+      };
+    }
+  };
+}
+
+// src/select.ts
+function createSelect(options, config = {}) {
+  const { onValueChange, onOpenChange } = config;
+  return {
+    getTriggerProps: (isOpen, selectedValue, highlightedIndex) => {
+      const selectedOption = options.find((o) => o.value === selectedValue);
+      const highlightedOption = highlightedIndex != null ? options[highlightedIndex] : void 0;
+      return {
+        role: "combobox",
+        "aria-expanded": isOpen,
+        "aria-haspopup": "listbox",
+        "aria-label": selectedOption?.label || "Select an option",
+        "aria-activedescendant": isOpen && highlightedOption ? `select-option-${highlightedOption.value}` : void 0,
+        onClick: () => onOpenChange?.(!isOpen),
+        onKeyDown: (e) => {
+          if (e.key === Keys.Enter || e.key === Keys.Space) {
+            e.preventDefault();
+            onOpenChange?.(!isOpen);
+          } else if (e.key === Keys.ArrowDown) {
+            e.preventDefault();
+            onOpenChange?.(true);
+          }
+        }
+      };
+    },
+    getListProps: () => ({
+      role: "listbox"
+    }),
+    getOptionProps: (option, isHighlighted, selectedValue, _highlightedIndex) => ({
+      role: "option",
+      "aria-selected": option.value === selectedValue,
+      "aria-disabled": option.disabled || void 0,
+      "data-highlighted": isHighlighted || void 0,
+      id: `select-option-${option.value}`,
+      onClick: () => {
+        if (!option.disabled) {
+          onValueChange?.(option.value);
+          onOpenChange?.(false);
+        }
+      }
+    }),
+    getContentProps: (isOpen) => ({
+      hidden: !isOpen ? true : void 0
+    }),
+    handleKeyDown: (e, isOpen, highlightedIndex, onHighlightChange) => {
+      if (!isOpen) return;
+      const enabledOptions = options.filter((o) => !o.disabled);
+      if (e.key === Keys.ArrowDown) {
+        e.preventDefault();
+        const next = getNextIndex(highlightedIndex, enabledOptions.length, "next");
+        onHighlightChange(next);
+      } else if (e.key === Keys.ArrowUp) {
+        e.preventDefault();
+        const prev = getNextIndex(highlightedIndex, enabledOptions.length, "prev");
+        onHighlightChange(prev);
+      } else if (e.key === Keys.Enter || e.key === Keys.Space) {
+        e.preventDefault();
+        const option = enabledOptions[highlightedIndex];
+        if (option) {
+          onValueChange?.(option.value);
+          onOpenChange?.(false);
+        }
+      } else if (e.key === Keys.Escape) {
+        e.preventDefault();
+        onOpenChange?.(false);
+      } else if (e.key === Keys.Home) {
+        e.preventDefault();
+        onHighlightChange(0);
+      } else if (e.key === Keys.End) {
+        e.preventDefault();
+        onHighlightChange(enabledOptions.length - 1);
+      }
+    }
+  };
+}
+
+// src/tooltip.ts
+var tooltipCounter = 0;
+function createTooltip(config = {}) {
+  const { delay = 700, onOpenChange } = config;
+  const id = `mcpe-tooltip-${++tooltipCounter}`;
+  let timeoutId = null;
+  function clearDelay() {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  }
+  function openWithDelay() {
+    clearDelay();
+    timeoutId = setTimeout(() => {
+      onOpenChange?.(true);
+    }, delay);
+  }
+  function close() {
+    clearDelay();
+    onOpenChange?.(false);
+  }
+  return {
+    getTriggerProps: () => ({
+      "aria-describedby": id,
+      onMouseEnter: () => openWithDelay(),
+      onMouseLeave: () => close(),
+      onFocus: () => openWithDelay(),
+      onBlur: () => close()
+    }),
+    getContentProps: (isOpen) => ({
+      id,
+      role: "tooltip",
+      hidden: !isOpen ? true : void 0
+    }),
+    destroy: () => clearDelay()
+  };
+}
+
+// src/popover.ts
+function createPopover(config = {}) {
+  const { onOpenChange } = config;
+  return {
+    getTriggerProps: (isOpen) => ({
+      "aria-haspopup": true,
+      "aria-expanded": isOpen,
+      onClick: () => onOpenChange?.(!isOpen)
+    }),
+    getContentProps: (isOpen) => ({
+      role: "dialog",
+      hidden: !isOpen || void 0,
+      onKeyDown: (e) => {
+        if (e.key === "Escape") onOpenChange?.(false);
+      }
+    })
+  };
+}
+
+// src/toast.ts
+var toastCounter = 0;
+function createToastManager(config = {}) {
+  const { duration: defaultDuration = 5e3 } = config;
+  const listeners = /* @__PURE__ */ new Set();
+  let state = { toasts: [] };
+  function notify() {
+    for (const listener of listeners) {
+      listener(state);
+    }
+  }
+  function addToast(toast2) {
+    const id = `toast-${++toastCounter}`;
+    const newToast = { id, ...toast2 };
+    state = { toasts: [...state.toasts, newToast] };
+    notify();
+    const dur = toast2.duration ?? defaultDuration;
+    if (dur > 0) {
+      setTimeout(() => removeToast(id), dur);
+    }
+    return id;
+  }
+  function removeToast(id) {
+    state = { toasts: state.toasts.filter((t) => t.id !== id) };
+    notify();
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  return {
+    addToast,
+    removeToast,
+    subscribe,
+    getState: () => state
+  };
+}
+var defaultManager = createToastManager();
+var toast = {
+  default: (title, description) => defaultManager.addToast({ title, description, variant: "default" }),
+  success: (title, description) => defaultManager.addToast({ title, description, variant: "success" }),
+  destructive: (title, description) => defaultManager.addToast({ title, description, variant: "destructive" }),
+  custom: (t) => defaultManager.addToast(t),
+  dismiss: (id) => defaultManager.removeToast(id),
+  subscribe: defaultManager.subscribe,
+  getState: defaultManager.getState
+};
+
+// src/drawer.ts
+function createDrawer(config = {}) {
+  const { side = "right", onOpenChange } = config;
+  return {
+    getOverlayProps: () => ({
+      "aria-hidden": true,
+      onClick: () => onOpenChange?.(false)
+    }),
+    getContentProps: (isOpen) => ({
+      role: "dialog",
+      "aria-modal": true,
+      hidden: !isOpen ? true : void 0,
+      onKeyDown: (e) => {
+        if (e.key === "Escape") onOpenChange?.(false);
+      }
+    }),
+    getCloseProps: () => ({
+      "aria-label": "Close",
+      onClick: () => onOpenChange?.(false)
+    }),
+    side
+  };
+}
+
+// src/dropdown-menu.ts
+function createDropdownMenu(items, config = {}) {
+  const { onOpenChange } = config;
+  const actionItems = items.filter((i) => i.type !== "separator" && i.type !== "label" && !i.disabled);
+  return {
+    getTriggerProps: (isOpen) => ({
+      "aria-haspopup": "menu",
+      "aria-expanded": isOpen,
+      onClick: () => onOpenChange?.(!isOpen)
+    }),
+    getContentProps: (isOpen) => ({
+      role: "menu",
+      hidden: !isOpen || void 0
+    }),
+    getItemProps: (item, isHighlighted) => ({
+      role: "menuitem",
+      "aria-disabled": item.disabled || void 0,
+      "data-highlighted": isHighlighted || void 0,
+      tabIndex: -1,
+      onClick: () => {
+        if (!item.disabled && item.type !== "separator" && item.type !== "label") {
+          item.onSelect?.();
+          onOpenChange?.(false);
+        }
+      }
+    }),
+    handleKeyDown: (e, isOpen, highlightedIndex, onHighlightChange) => {
+      if (!isOpen) return;
+      if (e.key === Keys.ArrowDown) {
+        e.preventDefault();
+        onHighlightChange(getNextIndex(highlightedIndex, actionItems.length, "next"));
+      } else if (e.key === Keys.ArrowUp) {
+        e.preventDefault();
+        onHighlightChange(getNextIndex(highlightedIndex, actionItems.length, "prev"));
+      } else if (e.key === Keys.Enter || e.key === Keys.Space) {
+        e.preventDefault();
+        const item = actionItems[highlightedIndex];
+        if (item) {
+          item.onSelect?.();
+          onOpenChange?.(false);
+        }
+      } else if (e.key === Keys.Escape) {
+        e.preventDefault();
+        onOpenChange?.(false);
+      } else if (e.key === Keys.Home) {
+        e.preventDefault();
+        onHighlightChange(0);
+      } else if (e.key === Keys.End) {
+        e.preventDefault();
+        onHighlightChange(actionItems.length - 1);
+      }
+    }
+  };
+}
+
+// src/switch.ts
+function createSwitch(config = {}) {
+  const { onCheckedChange } = config;
+  return {
+    getSwitchProps: (checked, disabled = false) => ({
+      role: "switch",
+      "aria-checked": checked,
+      "aria-disabled": disabled || void 0,
+      tabIndex: disabled ? -1 : 0,
+      onClick: () => {
+        if (!disabled) onCheckedChange?.(!checked);
+      },
+      onKeyDown: (e) => {
+        if (disabled) return;
+        if (e.key === " " || e.key === "Enter") {
+          e.preventDefault();
+          onCheckedChange?.(!checked);
+        }
+      }
+    })
+  };
+}
+
+// src/mcp/scope.ts
+function parseScope(raw) {
+  const trimmed = raw.trim();
+  const colonIdx = trimmed.indexOf(":");
+  if (colonIdx === -1) {
+    return { raw, resource: trimmed, permissions: ["access"] };
+  }
+  const resource = trimmed.slice(0, colonIdx);
+  const permsStr = trimmed.slice(colonIdx + 1);
+  const permissions = permsStr.split(",").map((p) => p.trim()).filter(Boolean);
+  return { raw, resource, permissions: permissions.length > 0 ? permissions : ["access"] };
+}
+function parseScopes(scopeString) {
+  return scopeString.split(/\s+/).filter(Boolean).map(parseScope);
+}
+
+// src/mcp/tool-state.ts
+var VALID_TRANSITIONS = {
+  idle: ["pending"],
+  pending: ["running", "cancelled"],
+  running: ["done", "error", "cancelled"],
+  done: ["idle"],
+  error: ["idle"],
+  cancelled: ["idle"]
+};
+function createToolState() {
+  let snapshot = { status: "idle" };
+  const listeners = /* @__PURE__ */ new Set();
+  function transition(to, patch = {}) {
+    const allowed = VALID_TRANSITIONS[snapshot.status];
+    if (!allowed.includes(to)) {
+      throw new Error(`Invalid tool-state transition: ${snapshot.status} \u2192 ${to}`);
+    }
+    snapshot = { ...snapshot, ...patch, status: to };
+    let firstError;
+    for (const fn of listeners) {
+      try {
+        fn(snapshot);
+      } catch (e) {
+        if (firstError === void 0) firstError = e;
+      }
+    }
+    if (firstError !== void 0) throw firstError;
+  }
+  return {
+    get status() {
+      return snapshot.status;
+    },
+    get tool() {
+      return snapshot.tool;
+    },
+    get args() {
+      return snapshot.args;
+    },
+    get result() {
+      return snapshot.result;
+    },
+    get error() {
+      return snapshot.error;
+    },
+    get startedAt() {
+      return snapshot.startedAt;
+    },
+    get endedAt() {
+      return snapshot.endedAt;
+    },
+    start({ tool, args }) {
+      transition("pending", { tool, args, startedAt: Date.now() });
+    },
+    markRunning() {
+      transition("running");
+    },
+    markDone(result) {
+      transition("done", { result, endedAt: Date.now() });
+    },
+    markError(error) {
+      transition("error", { error, endedAt: Date.now() });
+    },
+    cancel() {
+      transition("cancelled", { endedAt: Date.now() });
+    },
+    reset() {
+      if (snapshot.status === "idle") return;
+      snapshot = { status: "idle" };
+      let firstError;
+      for (const fn of listeners) {
+        try {
+          fn(snapshot);
+        } catch (e) {
+          if (firstError === void 0) firstError = e;
+        }
+      }
+      if (firstError !== void 0) throw firstError;
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    }
+  };
+}
+
+// src/mcp/schema-form.ts
+function schemaToFields(schema) {
+  if (schema.type !== "object" || !schema.properties) return [];
+  const required = new Set(schema.required ?? []);
+  const fields = [];
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    fields.push(fieldFromProperty(key, propSchema, required.has(key)));
+  }
+  return fields;
+}
+function fieldFromProperty(key, schema, required) {
+  const base = {
+    key,
+    label: schema.title ?? key,
+    help: schema.description,
+    required,
+    defaultValue: schema.default
+  };
+  if (schema.enum && schema.enum.length > 0) {
+    return {
+      ...base,
+      kind: "select",
+      options: schema.enum.map((v) => ({ value: String(v), label: String(v) }))
+    };
+  }
+  switch (schema.type) {
+    case "string": {
+      if (schema.format === "email") return { ...base, kind: "email" };
+      if (schema.format === "uri" || schema.format === "url") return { ...base, kind: "url" };
+      if (schema.format === "date" || schema.format === "date-time") return { ...base, kind: "date" };
+      if ((schema.maxLength ?? 0) > 200) {
+        return {
+          ...base,
+          kind: "textarea",
+          minLength: schema.minLength,
+          maxLength: schema.maxLength,
+          pattern: schema.pattern
+        };
+      }
+      return {
+        ...base,
+        kind: "text",
+        minLength: schema.minLength,
+        maxLength: schema.maxLength,
+        pattern: schema.pattern
+      };
+    }
+    case "number":
+    case "integer":
+      return { ...base, kind: "number", min: schema.minimum, max: schema.maximum };
+    case "boolean":
+      return { ...base, kind: "switch" };
+    case "array":
+      if (schema.items?.type === "string") return { ...base, kind: "multiselect" };
+      return { ...base, kind: "unknown" };
+    case "null":
+      return { ...base, kind: "unknown" };
+    default:
+      return { ...base, kind: "unknown" };
+  }
+}
+
+// src/mcp/oauth.ts
+function randomBytes(n) {
+  const arr = new Uint8Array(n);
+  globalThis.crypto.getRandomValues(arr);
+  return arr;
+}
+function base64urlEncode(bytes) {
+  let s = "";
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function generatePkcePair() {
+  const verifierBytes = randomBytes(64);
+  const codeVerifier = base64urlEncode(verifierBytes);
+  const verifierBuf = new TextEncoder().encode(codeVerifier);
+  const hashBuf = await globalThis.crypto.subtle.digest("SHA-256", verifierBuf);
+  const codeChallenge = base64urlEncode(new Uint8Array(hashBuf));
+  return { codeVerifier, codeChallenge, codeChallengeMethod: "S256" };
+}
+function buildAuthUrl(input) {
+  const u = new URL(input.authorizationEndpoint);
+  u.searchParams.set("response_type", "code");
+  u.searchParams.set("client_id", input.clientId);
+  u.searchParams.set("redirect_uri", input.redirectUri);
+  u.searchParams.set("scope", input.scope);
+  u.searchParams.set("code_challenge", input.codeChallenge);
+  u.searchParams.set("code_challenge_method", "S256");
+  u.searchParams.set("state", input.state);
+  if (input.resource) u.searchParams.set("resource", input.resource);
+  return u.toString();
+}
+function buildTokenExchangeBody(input) {
+  const body = new URLSearchParams();
+  body.set("grant_type", "authorization_code");
+  body.set("client_id", input.clientId);
+  body.set("code", input.code);
+  body.set("redirect_uri", input.redirectUri);
+  body.set("code_verifier", input.codeVerifier);
+  return body.toString();
+}
+function buildTokenRefreshBody(input) {
+  const body = new URLSearchParams();
+  body.set("grant_type", "refresh_token");
+  body.set("client_id", input.clientId);
+  body.set("refresh_token", input.refreshToken);
+  if (input.scope) body.set("scope", input.scope);
+  return body.toString();
+}
+var OAUTH_TRANSITIONS = {
+  idle: ["authorizing"],
+  authorizing: ["authorized", "denied", "error"],
+  authorized: ["idle"],
+  denied: ["idle"],
+  error: ["idle"]
+};
+function createOAuthFlow() {
+  let snap = { status: "idle" };
+  const listeners = /* @__PURE__ */ new Set();
+  function notify() {
+    let firstError;
+    for (const fn of listeners) {
+      try {
+        fn(snap);
+      } catch (e) {
+        if (firstError === void 0) firstError = e;
+      }
+    }
+    if (firstError !== void 0) throw firstError;
+  }
+  function transition(to, patch = {}) {
+    const allowed = OAUTH_TRANSITIONS[snap.status];
+    if (!allowed.includes(to)) {
+      throw new Error(`Invalid oauth transition: ${snap.status} \u2192 ${to}`);
+    }
+    snap = { ...snap, ...patch, status: to };
+    notify();
+  }
+  return {
+    get status() {
+      return snap.status;
+    },
+    get verifier() {
+      return snap.verifier;
+    },
+    get state() {
+      return snap.state;
+    },
+    get tokens() {
+      return snap.tokens;
+    },
+    get error() {
+      return snap.error;
+    },
+    start({ verifier, state }) {
+      transition("authorizing", { verifier, state });
+    },
+    markAuthorized(tokens) {
+      transition("authorized", { tokens });
+    },
+    markDenied(code, message) {
+      transition("denied", { error: { code, message } });
+    },
+    markError(error) {
+      transition("error", { error: { code: "unknown", message: error.message, originalError: error } });
+    },
+    reset() {
+      if (snap.status === "idle") return;
+      snap = { status: "idle" };
+      notify();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    }
+  };
+}
+
+// src/mcp/app-bridge.ts
+function encodeEnvelope(env) {
+  return { id: env.id, type: env.type, payload: env.payload };
+}
+function decodeEnvelope(raw) {
+  if (raw === null || Array.isArray(raw) || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o.id !== "string") return null;
+  if (typeof o.type !== "string") return null;
+  return { id: o.id, type: o.type, payload: o.payload };
+}
+function createAppBridge(config) {
+  const listeners = /* @__PURE__ */ new Set();
+  function dispatch(env) {
+    let firstError;
+    for (const fn of listeners) {
+      try {
+        fn(env);
+      } catch (e) {
+        if (firstError === void 0) firstError = e;
+      }
+    }
+    if (firstError !== void 0) throw firstError;
+  }
+  return {
+    send(env) {
+      config.postMessage(encodeEnvelope(env));
+    },
+    receive(raw) {
+      const env = decodeEnvelope(raw);
+      if (!env) return;
+      dispatch(env);
+    },
+    onMessage(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    }
+  };
+}
+export {
+  Keys,
+  buildAuthUrl,
+  buildTokenExchangeBody,
+  buildTokenRefreshBody,
+  cn,
+  createAccordion,
+  createAppBridge,
+  createClickOutsideHandler,
+  createDialog,
+  createDrawer,
+  createDropdownMenu,
+  createOAuthFlow,
+  createPopover,
+  createSelect,
+  createSwitch,
+  createTabs,
+  createToastManager,
+  createToolState,
+  createTooltip,
+  decodeEnvelope,
+  encodeEnvelope,
+  generatePkcePair,
+  getFocusableElements,
+  getNextIndex,
+  handleArrowNavigation,
+  lockScroll,
+  parseScope,
+  parseScopes,
+  schemaToFields,
+  toast,
+  trapFocus
+};
+//# sourceMappingURL=index.js.map