@lovett/ui 0.0.11 → 0.2.0

package/dist/chunk-RBYWGBQ2.js

@@ -0,0 +1,2752 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { forwardRef, useState, createContext, isValidElement, cloneElement, useRef, useEffect, useMemo, lazy, useContext, useCallback, useLayoutEffect, useId, Suspense, Component } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { EyeOff, Eye, Check, Copy, PencilLine, Type, Bold, Italic, Code, Link, List, CornerDownRight, X, Image, FileText, Paperclip, Search, Play, ImageOff, Info } from 'lucide-react';
+import { createPortal } from 'react-dom';
+import { PrismLight } from 'react-syntax-highlighter';
+import { oneLight, vscDarkPlus } from 'react-syntax-highlighter/dist/esm/styles/prism';
+import bash from 'react-syntax-highlighter/dist/esm/languages/prism/bash';
+import css from 'react-syntax-highlighter/dist/esm/languages/prism/css';
+import diff from 'react-syntax-highlighter/dist/esm/languages/prism/diff';
+import javascript from 'react-syntax-highlighter/dist/esm/languages/prism/javascript';
+import json from 'react-syntax-highlighter/dist/esm/languages/prism/json';
+import jsx3 from 'react-syntax-highlighter/dist/esm/languages/prism/jsx';
+import markdown from 'react-syntax-highlighter/dist/esm/languages/prism/markdown';
+import markup from 'react-syntax-highlighter/dist/esm/languages/prism/markup';
+import python from 'react-syntax-highlighter/dist/esm/languages/prism/python';
+import sql from 'react-syntax-highlighter/dist/esm/languages/prism/sql';
+import tsx from 'react-syntax-highlighter/dist/esm/languages/prism/tsx';
+import typescript from 'react-syntax-highlighter/dist/esm/languages/prism/typescript';
+import yaml from 'react-syntax-highlighter/dist/esm/languages/prism/yaml';
+import ReactMarkdown, { defaultUrlTransform } from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+var VARIANT_CLASS = {
+  primary: "btn-primary",
+  secondary: "btn-secondary",
+  outline: "btn-outline",
+  ghost: "btn-ghost",
+  destructive: "btn-destructive",
+  "destructive-soft": "btn-destructive-soft",
+  icon: "btn-icon",
+  toolbar: "btn-toolbar"
+};
+var SIZE_CLASS = {
+  sm: "size-sm",
+  md: "",
+  lg: "size-lg"
+};
+var Button = forwardRef(function Button2({
+  variant = "primary",
+  size = "md",
+  shape = "default",
+  loading,
+  leadingIcon,
+  trailingIcon,
+  disabled,
+  className,
+  children,
+  type = "button",
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      ref,
+      type,
+      disabled: disabled || loading,
+      className: cn(
+        "btn",
+        VARIANT_CLASS[variant],
+        SIZE_CLASS[size],
+        shape === "circle" && variant === "icon" && "is-circle",
+        loading && "is-loading",
+        className
+      ),
+      ...rest,
+      children: [
+        leadingIcon,
+        children,
+        trailingIcon
+      ]
+    }
+  );
+});
+var SIZE_CLASS2 = {
+  sm: "size-sm",
+  md: "",
+  lg: "size-lg"
+};
+var Input = forwardRef(function Input2({
+  inputSize = "md",
+  error,
+  leadingAffix,
+  trailingAffix,
+  shellClassName,
+  className,
+  disabled,
+  type,
+  showPasswordToggle,
+  numeric,
+  ...rest
+}, ref) {
+  const [revealed, setRevealed] = useState(false);
+  const isPasswordToggle = showPasswordToggle === true && type === "password" && !trailingAffix;
+  const resolvedType = isPasswordToggle && revealed ? "text" : type;
+  const resolvedTrailingAffix = isPasswordToggle ? /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => setRevealed((v) => !v),
+      "aria-label": revealed ? "Hide password" : "Show password",
+      "aria-pressed": revealed,
+      className: "affix action",
+      tabIndex: -1,
+      children: revealed ? /* @__PURE__ */ jsx(EyeOff, { className: "h-4 w-4", "aria-hidden": true }) : /* @__PURE__ */ jsx(Eye, { className: "h-4 w-4", "aria-hidden": true })
+    }
+  ) : trailingAffix;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "input-shell",
+        SIZE_CLASS2[inputSize],
+        numeric && "is-numeric",
+        leadingAffix && "has-leading",
+        resolvedTrailingAffix && "has-trailing",
+        error && "is-error",
+        disabled && "is-disabled",
+        shellClassName
+      ),
+      children: [
+        leadingAffix && /* @__PURE__ */ jsx("span", { className: "affix", children: leadingAffix }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref,
+            type: resolvedType,
+            disabled,
+            className,
+            ...rest
+          }
+        ),
+        resolvedTrailingAffix && /* @__PURE__ */ jsx("span", { className: "affix", children: resolvedTrailingAffix })
+      ]
+    }
+  );
+});
+var stack = [];
+var listening = false;
+function onDocumentKeyDown(event) {
+  if (event.key !== "Escape") return;
+  const top = stack[stack.length - 1];
+  if (!top) return;
+  event.stopPropagation();
+  top.onEscape(event);
+}
+function pushLayer(record) {
+  stack.push(record);
+  if (!listening) {
+    document.addEventListener("keydown", onDocumentKeyDown);
+    listening = true;
+  }
+  return () => {
+    const at = stack.lastIndexOf(record);
+    if (at !== -1) stack.splice(at, 1);
+    if (stack.length === 0 && listening) {
+      document.removeEventListener("keydown", onDocumentKeyDown);
+      listening = false;
+    }
+  };
+}
+function useLayer(options) {
+  const { enabled, kind, elementRef, onEscape } = options;
+  const onEscapeRef = useRef(onEscape);
+  useEffect(() => {
+    onEscapeRef.current = onEscape;
+  });
+  const kindRef = useRef(kind);
+  kindRef.current = kind;
+  const recordRef = useRef(null);
+  useEffect(() => {
+    if (!enabled) return;
+    const record = {
+      kind: kindRef.current,
+      element: () => elementRef?.current ?? null,
+      onEscape: (event) => onEscapeRef.current(event)
+    };
+    recordRef.current = record;
+    const pop = pushLayer(record);
+    return () => {
+      pop();
+      if (recordRef.current === record) recordRef.current = null;
+    };
+  }, [enabled, elementRef]);
+  useEffect(() => {
+    const record = recordRef.current;
+    if (record !== null) record.kind = kind;
+  }, [kind]);
+  return useMemo(
+    () => ({
+      isTop: () => {
+        const record = recordRef.current;
+        return record !== null && stack[stack.length - 1] === record;
+      },
+      isTopOfKind: () => {
+        const record = recordRef.current;
+        if (!record) return false;
+        for (let i = stack.length - 1; i >= 0; i--) {
+          const layer = stack[i];
+          if (layer === record) return true;
+          if (layer?.kind === record.kind) return false;
+        }
+        return false;
+      },
+      containsInLayerAbove: (node) => {
+        const record = recordRef.current;
+        if (!record) return false;
+        const at = stack.indexOf(record);
+        if (at === -1) return false;
+        for (let i = at + 1; i < stack.length; i++) {
+          if (stack[i]?.element()?.contains(node)) return true;
+        }
+        return false;
+      }
+    }),
+    []
+  );
+}
+function useEscapeKey(onEscape, options = {}) {
+  const { enabled = true, kind = "popover" } = options;
+  return useLayer({ enabled, kind, onEscape });
+}
+var OPPOSITE = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+function isVertical(side) {
+  return side === "top" || side === "bottom";
+}
+function clampNumber(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+function computeAnchoredPosition(anchor, floating, viewport, options = {}) {
+  const {
+    side: preferred = "bottom",
+    align = "start",
+    offset = 6,
+    alignOffset = 0,
+    flip = true,
+    clampToViewport = true,
+    gutter = 8
+  } = options;
+  const anchorRight = anchor.left + anchor.width;
+  const anchorBottom = anchor.top + anchor.height;
+  const room = {
+    top: anchor.top - gutter,
+    bottom: viewport.height - anchorBottom - gutter,
+    left: anchor.left - gutter,
+    right: viewport.width - anchorRight - gutter
+  };
+  const needed = (side2) => (isVertical(side2) ? floating.height : floating.width) + offset;
+  let side = preferred;
+  if (flip && room[preferred] < needed(preferred)) {
+    const opposite = OPPOSITE[preferred];
+    if (room[opposite] >= needed(opposite) || room[opposite] > room[preferred]) {
+      side = opposite;
+    }
+  }
+  let left;
+  let top;
+  if (isVertical(side)) {
+    top = side === "bottom" ? anchorBottom + offset : anchor.top - floating.height - offset;
+    switch (align) {
+      case "start":
+        left = anchor.left + alignOffset;
+        break;
+      case "center":
+        left = anchor.left + anchor.width / 2 - floating.width / 2 + alignOffset;
+        break;
+      case "end":
+        left = anchorRight - floating.width - alignOffset;
+        break;
+    }
+  } else {
+    left = side === "right" ? anchorRight + offset : anchor.left - floating.width - offset;
+    switch (align) {
+      case "start":
+        top = anchor.top + alignOffset;
+        break;
+      case "center":
+        top = anchor.top + anchor.height / 2 - floating.height / 2 + alignOffset;
+        break;
+      case "end":
+        top = anchorBottom - floating.height - alignOffset;
+        break;
+    }
+  }
+  if (clampToViewport) {
+    left = clampNumber(left, gutter, viewport.width - floating.width - gutter);
+    top = clampNumber(top, gutter, viewport.height - floating.height - gutter);
+  }
+  return {
+    left: Math.round(left),
+    top: Math.round(top),
+    placement: { side, align }
+  };
+}
+var PARKED_STYLE = {
+  position: "fixed",
+  // Parked far off-screen, not at (0, 0): if a renderer paints the
+  // unpositioned frame despite `visibility: hidden`, nothing flashes at the
+  // viewport's top-left corner.
+  left: -99999,
+  top: -99999,
+  visibility: "hidden",
+  opacity: 0,
+  pointerEvents: "none"
+};
+function viewportSize() {
+  const root = document.documentElement;
+  return {
+    width: root.clientWidth || window.innerWidth,
+    height: root.clientHeight || window.innerHeight
+  };
+}
+function samePosition(a, b) {
+  return a !== null && a.left === b.left && a.top === b.top && a.placement.side === b.placement.side && a.placement.align === b.placement.align;
+}
+function useAnchoredPosition(options) {
+  const {
+    anchorRef,
+    anchorRect = null,
+    enabled = true,
+    side = "bottom",
+    align = "start",
+    offset = 6,
+    alignOffset = 0,
+    flip = true,
+    clampToViewport = true,
+    gutter = 8
+  } = options;
+  const floatingRef = useRef(null);
+  const [floating, setFloating] = useState(null);
+  const ref = useCallback((node) => {
+    floatingRef.current = node;
+    setFloating(node);
+  }, []);
+  const [position, setPosition] = useState(null);
+  const anchorRectRef = useRef(anchorRect);
+  useLayoutEffect(() => {
+    anchorRectRef.current = anchorRect;
+  });
+  const rectKey = anchorRect ? `${anchorRect.left}|${anchorRect.top}|${anchorRect.width}|${anchorRect.height}` : "";
+  const measure = useCallback(() => {
+    const node = floatingRef.current;
+    if (!node) return;
+    const rect = anchorRectRef.current ?? anchorRef?.current?.getBoundingClientRect() ?? null;
+    if (!rect) return;
+    const next = computeAnchoredPosition(
+      rect,
+      { width: node.offsetWidth, height: node.offsetHeight },
+      viewportSize(),
+      { side, align, offset, alignOffset, flip, clampToViewport, gutter }
+    );
+    setPosition((prev) => samePosition(prev, next) ? prev : next);
+  }, [anchorRef, side, align, offset, alignOffset, flip, clampToViewport, gutter]);
+  useLayoutEffect(() => {
+    if (!enabled || !floating) {
+      setPosition((prev) => prev === null ? prev : null);
+      return;
+    }
+    measure();
+    window.addEventListener("resize", measure);
+    window.addEventListener("scroll", measure, true);
+    let observer = null;
+    if (typeof ResizeObserver !== "undefined") {
+      observer = new ResizeObserver(() => measure());
+      observer.observe(floating);
+      const anchorEl = anchorRef?.current;
+      if (anchorEl) observer.observe(anchorEl);
+    }
+    return () => {
+      window.removeEventListener("resize", measure);
+      window.removeEventListener("scroll", measure, true);
+      observer?.disconnect();
+    };
+  }, [enabled, floating, measure, anchorRef, rectKey]);
+  const positioned = position !== null;
+  const style = positioned ? { position: "fixed", left: position.left, top: position.top } : PARKED_STYLE;
+  return {
+    ref,
+    floatingRef,
+    style,
+    placement: position?.placement ?? null,
+    positioned,
+    update: measure
+  };
+}
+function useOutsideClick(targets, onOutside, options = {}) {
+  const { enabled = true, layer } = options;
+  const targetsRef = useRef(targets);
+  const handlerRef = useRef(onOutside);
+  useEffect(() => {
+    targetsRef.current = targets;
+    handlerRef.current = onOutside;
+  });
+  useEffect(() => {
+    if (!enabled) return;
+    const onPointerDown = (event) => {
+      const target = event.target;
+      if (!(target instanceof Node)) return;
+      for (const candidate of targetsRef.current) {
+        const el = candidate instanceof Node ? candidate : candidate?.current;
+        if (el?.contains(target)) return;
+      }
+      if (layer?.containsInLayerAbove(target)) return;
+      handlerRef.current(event);
+    };
+    document.addEventListener("pointerdown", onPointerDown);
+    return () => document.removeEventListener("pointerdown", onPointerDown);
+  }, [enabled, layer]);
+}
+
+// src/lib/refs.ts
+function assignRef(ref, node) {
+  if (!ref) return;
+  if (typeof ref === "function") {
+    ref(node);
+    return;
+  }
+  ref.current = node;
+}
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) assignRef(ref, node);
+  };
+}
+
+// src/lib/focus.ts
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "area[href]",
+  "button:not([disabled])",
+  'input:not([disabled]):not([type="hidden"])',
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "iframe",
+  "summary",
+  '[contenteditable="true"]',
+  "[tabindex]"
+].join(",");
+function tabbablesWithin(root) {
+  return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+    (el) => el.tabIndex >= 0 && !el.hasAttribute("inert") && el.getAttribute("aria-hidden") !== "true" && !el.closest("[hidden]") && // `inert` is INHERITED by the subtree in a browser, so a control inside
+    // an inert ancestor cannot take focus — a trap that hands it focus
+    // anyway simply stops moving. The detail surface collapses a pane by
+    // making it inert rather than unmounting it (its scroll and its drafts
+    // have to survive), which is the case that made this ancestor check
+    // load-bearing rather than tidy.
+    !el.closest("[inert]")
+  );
+}
+function handleTabTrap(event, container) {
+  if (event.key !== "Tab" || !container) return;
+  const tabbables = tabbablesWithin(container);
+  if (tabbables.length < 2) return;
+  const first = tabbables[0];
+  const last = tabbables[tabbables.length - 1];
+  if (!first || !last) return;
+  const active = document.activeElement;
+  if (event.shiftKey && (active === first || !container.contains(active))) {
+    event.preventDefault();
+    last.focus();
+    return;
+  }
+  if (!event.shiftKey && active === last) {
+    event.preventDefault();
+    first.focus();
+  }
+}
+var POPOVER_SURFACE_STYLE = {
+  background: "rgb(var(--popover))",
+  color: "rgb(var(--popover-foreground))",
+  border: "1px solid rgb(var(--border))",
+  boxShadow: "var(--shadow-lg)"
+};
+var PopoverCtx = createContext(null);
+function usePopoverCtx(consumer) {
+  const ctx = useContext(PopoverCtx);
+  if (!ctx) {
+    throw new Error(
+      `${consumer} must be rendered inside <Popover>. Wrap your trigger + content with the Popover root component.`
+    );
+  }
+  return ctx;
+}
+function PopoverRoot({
+  open: controlledOpen,
+  defaultOpen,
+  onOpenChange,
+  anchorRect = null,
+  children
+}) {
+  const [uncontrolledOpen, setUncontrolledOpen] = useState(Boolean(defaultOpen));
+  const isControlled = controlledOpen !== void 0;
+  const open = isControlled ? Boolean(controlledOpen) : uncontrolledOpen;
+  const triggerRef = useRef(null);
+  const interactedOutsideRef = useRef(false);
+  const generatedId = useId();
+  const contentId = `popover-${generatedId.replace(/:/g, "")}`;
+  const setOpen = useCallback(
+    (next) => {
+      if (!isControlled) setUncontrolledOpen(next);
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  const value = useMemo(
+    () => ({ open, setOpen, triggerRef, contentId, anchorRect, interactedOutsideRef }),
+    [open, setOpen, contentId, anchorRect]
+  );
+  return /* @__PURE__ */ jsx(PopoverCtx.Provider, { value, children });
+}
+var PopoverTrigger = forwardRef(
+  function PopoverTrigger2({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const { open, setOpen, triggerRef, contentId } = usePopoverCtx("Popover.Trigger");
+    const ariaProps = {
+      "aria-haspopup": "dialog",
+      "aria-expanded": open,
+      "aria-controls": open ? contentId : void 0,
+      "data-state": open ? "open" : "closed"
+    };
+    if (asChild) {
+      if (!isValidElement(children)) {
+        throw new Error("Popover.Trigger with `asChild` expects exactly one element child.");
+      }
+      const child = children;
+      const childOnClick = child.props.onClick;
+      return cloneElement(child, {
+        ...rest,
+        ...ariaProps,
+        ref: composeRefs(child.props.ref, forwardedRef, triggerRef),
+        onClick: (event) => {
+          childOnClick?.(event);
+          onClick?.(event);
+          if (!event.defaultPrevented) setOpen(!open);
+        }
+      });
+    }
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref: composeRefs(forwardedRef, triggerRef),
+        type: "button",
+        ...ariaProps,
+        onClick: (event) => {
+          onClick?.(event);
+          if (!event.defaultPrevented) setOpen(!open);
+        },
+        ...rest,
+        children
+      }
+    );
+  }
+);
+var PopoverContent = forwardRef(
+  function PopoverContent2({
+    children,
+    side = "bottom",
+    align = "start",
+    offset = 6,
+    alignOffset = 0,
+    flip = true,
+    clampToViewport = true,
+    role = "dialog",
+    unstyled,
+    className,
+    style,
+    ...rest
+  }, forwardedRef) {
+    const { open, setOpen, triggerRef, contentId, anchorRect, interactedOutsideRef } = usePopoverCtx("Popover.Content");
+    const contentRef = useRef(null);
+    const {
+      ref: positionRef,
+      style: positionStyle,
+      placement,
+      positioned
+    } = useAnchoredPosition({
+      anchorRef: triggerRef,
+      anchorRect,
+      side,
+      align,
+      offset,
+      alignOffset,
+      flip,
+      clampToViewport,
+      enabled: open
+    });
+    const layer = useLayer({
+      enabled: open,
+      kind: "popover",
+      elementRef: contentRef,
+      onEscape: () => setOpen(false)
+    });
+    useOutsideClick(
+      [triggerRef, contentRef],
+      () => {
+        interactedOutsideRef.current = true;
+        setOpen(false);
+      },
+      { enabled: open, layer }
+    );
+    useEffect(() => {
+      if (!open || !positioned) return;
+      const node = contentRef.current;
+      if (!node) return;
+      interactedOutsideRef.current = false;
+      const trigger = triggerRef.current;
+      const previous = document.activeElement instanceof HTMLElement && document.activeElement !== document.body ? document.activeElement : null;
+      const initial = node.querySelector("[data-autofocus]") ?? tabbablesWithin(node)[0] ?? node;
+      initial.focus();
+      return () => {
+        if (interactedOutsideRef.current) return;
+        const active = document.activeElement;
+        if (active !== null && active !== document.body && !node.contains(active)) return;
+        const target = trigger ?? previous;
+        if (target?.isConnected) target.focus();
+      };
+    }, [open, positioned, triggerRef, interactedOutsideRef]);
+    const ref = useMemo(
+      () => composeRefs(forwardedRef, contentRef, positionRef),
+      [forwardedRef, positionRef]
+    );
+    if (!open || typeof document === "undefined") return null;
+    return createPortal(
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref,
+          id: contentId,
+          role: role === "none" ? void 0 : role,
+          tabIndex: -1,
+          "data-slot": "popover-content",
+          "data-state": "open",
+          "data-side": placement?.side,
+          "data-align": placement?.align,
+          "data-positioned": positioned ? "true" : "false",
+          className: cn(
+            "fixed z-[100] outline-none",
+            !unstyled && "rounded-[var(--radius-lg)] p-3",
+            positioned && "ds-enter-pop",
+            className
+          ),
+          style: {
+            ...positionStyle,
+            ...unstyled ? void 0 : POPOVER_SURFACE_STYLE,
+            ...style
+          },
+          ...rest,
+          children
+        }
+      ),
+      document.body
+    );
+  }
+);
+var Popover = Object.assign(PopoverRoot, {
+  Trigger: PopoverTrigger,
+  Content: PopoverContent
+});
+function useDataTheme() {
+  const read = () => {
+    if (typeof document === "undefined") return "dark";
+    const attr = document.documentElement.getAttribute("data-theme");
+    return attr === "light" ? "light" : "dark";
+  };
+  const [theme, setTheme] = useState(read);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const observer = new MutationObserver(() => setTheme(read()));
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["data-theme"]
+    });
+    return () => observer.disconnect();
+  }, []);
+  return theme;
+}
+var LANGUAGES = {
+  bash,
+  shell: bash,
+  sh: bash,
+  css,
+  diff,
+  javascript,
+  js: javascript,
+  json,
+  jsx: jsx3,
+  markdown,
+  md: markdown,
+  html: markup,
+  xml: markup,
+  python,
+  py: python,
+  sql,
+  tsx,
+  typescript,
+  ts: typescript,
+  yaml,
+  yml: yaml
+};
+for (const [name, lang] of Object.entries(LANGUAGES)) {
+  PrismLight.registerLanguage(name, lang);
+}
+var LANGUAGE_LABELS = {
+  bash: "bash",
+  sh: "shell",
+  css: "css",
+  diff: "diff",
+  html: "html",
+  javascript: "javascript",
+  js: "javascript",
+  json: "json",
+  jsx: "jsx",
+  markdown: "markdown",
+  md: "markdown",
+  python: "python",
+  py: "python",
+  shell: "shell",
+  sql: "sql",
+  tsx: "tsx",
+  ts: "typescript",
+  typescript: "typescript",
+  xml: "xml",
+  yaml: "yaml",
+  yml: "yaml"
+};
+function CodeBlock({ language, children }) {
+  const [copied, setCopied] = useState(false);
+  const theme = useDataTheme();
+  const syntaxStyle = theme === "light" ? oneLight : vscDarkPlus;
+  const lang = (language ?? "").toLowerCase();
+  const supported = lang in LANGUAGES;
+  const label = (LANGUAGE_LABELS[lang] ?? lang) || "plaintext";
+  const source = String(children).replace(/\n$/, "");
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(source);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    } catch {
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "my-4 overflow-hidden text-sm",
+      style: {
+        background: "rgb(var(--bg-elevated))",
+        border: "1px solid rgb(var(--border))",
+        borderRadius: "var(--radius-md)"
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "flex items-center justify-between px-3 py-1.5 text-xs",
+            style: {
+              background: "rgb(var(--muted))",
+              borderBottom: "1px solid rgb(var(--border))",
+              color: "rgb(var(--muted-foreground))"
+            },
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "font-mono lowercase", children: label }),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: handleCopy,
+                  className: cn(
+                    "flex items-center gap-1 rounded-md px-2 py-1 text-xs transition-colors",
+                    !copied && "hover:text-[rgb(var(--foreground))]"
+                  ),
+                  style: copied ? { color: "rgb(var(--success))" } : void 0,
+                  "aria-label": copied ? "Copied" : "Copy code",
+                  children: copied ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(Check, { className: "h-3.5 w-3.5" }),
+                    " Copied"
+                  ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(Copy, { className: "h-3.5 w-3.5" }),
+                    " Copy"
+                  ] })
+                }
+              )
+            ]
+          }
+        ),
+        supported ? /* @__PURE__ */ jsx(
+          PrismLight,
+          {
+            language: lang,
+            style: syntaxStyle,
+            customStyle: {
+              margin: 0,
+              padding: "0.875rem 1rem",
+              background: "transparent",
+              fontSize: "0.8125rem",
+              lineHeight: 1.6
+            },
+            codeTagProps: {
+              style: { fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace" }
+            },
+            children: source
+          }
+        ) : /* @__PURE__ */ jsx(
+          "pre",
+          {
+            className: "overflow-x-auto px-4 py-3.5 font-mono text-[0.8125rem] leading-relaxed",
+            style: { color: "rgb(var(--foreground))" },
+            children: source
+          }
+        )
+      ]
+    }
+  );
+}
+var PreContext = createContext(false);
+function MarkdownPre({ children }) {
+  return /* @__PURE__ */ jsx(PreContext.Provider, { value: true, children });
+}
+function MarkdownCode({ className, children }) {
+  const inPre = useContext(PreContext);
+  const block = inPre || Boolean(className);
+  if (!block) {
+    return /* @__PURE__ */ jsx(
+      "code",
+      {
+        className: "rounded px-1.5 py-0.5 font-mono text-[0.85em]",
+        style: {
+          background: "rgb(var(--muted))",
+          color: "rgb(var(--foreground))",
+          borderRadius: "var(--radius-xs)"
+        },
+        children
+      }
+    );
+  }
+  const match = className === void 0 ? null : /language-([\w-]+)/.exec(className);
+  const language = match?.[1];
+  return /* @__PURE__ */ jsx(CodeBlock, { ...language !== void 0 ? { language } : {}, children: sourceOf(children) });
+}
+function sourceOf(children) {
+  if (typeof children === "string") return children;
+  if (typeof children === "number") return String(children);
+  if (children === void 0 || children === null || typeof children === "boolean") return "";
+  return String(children);
+}
+
+// src/lib/remark-underline.ts
+var PLUS = 43;
+var SPACE = 32;
+var SEQUENCE_TEMPORARY = "underlineSequenceTemporary";
+var SEQUENCE = "underlineSequence";
+var UNDERLINE = "underline";
+var UNDERLINE_TEXT = "underlineText";
+var CHARACTER_ESCAPE = "characterEscape";
+var DATA = "data";
+var SPLICE_CHUNK = 1e4;
+var UNICODE_WHITESPACE = /\s/;
+var UNICODE_PUNCTUATION = /\p{P}|\p{S}/u;
+var GROUP_WHITESPACE = 1;
+var GROUP_PUNCTUATION = 2;
+function classifyCharacter(code) {
+  if (code === null || code < 0 || code === SPACE) return GROUP_WHITESPACE;
+  const character = String.fromCharCode(code);
+  if (UNICODE_WHITESPACE.test(character)) return GROUP_WHITESPACE;
+  if (UNICODE_PUNCTUATION.test(character)) return GROUP_PUNCTUATION;
+  return void 0;
+}
+function spliceChunked(list, start, remove, items) {
+  const end = list.length;
+  let at = start < 0 ? -start > end ? 0 : end + start : start > end ? end : start;
+  const count = remove > 0 ? remove : 0;
+  if (items.length < SPLICE_CHUNK) {
+    list.splice(at, count, ...items);
+    return;
+  }
+  if (count > 0) list.splice(at, count);
+  let from = 0;
+  while (from < items.length) {
+    list.splice(at, 0, ...items.slice(from, from + SPLICE_CHUNK));
+    from += SPLICE_CHUNK;
+    at += SPLICE_CHUNK;
+  }
+}
+function resolveAll(constructs, events, context) {
+  const called = [];
+  let result = events;
+  for (const construct of constructs) {
+    const resolve = construct.resolveAll;
+    if (resolve !== void 0 && !called.includes(resolve)) {
+      result = resolve(result, context);
+      called.push(resolve);
+    }
+  }
+  return result;
+}
+function tokenizeUnderline(effects, ok, nok) {
+  const previous = this.previous;
+  const events = this.events;
+  let size = 0;
+  return start;
+  function start(code) {
+    if (previous === PLUS && events[events.length - 1]?.[1].type !== CHARACTER_ESCAPE) {
+      return nok(code);
+    }
+    effects.enter(SEQUENCE_TEMPORARY);
+    return more(code);
+  }
+  function more(code) {
+    if (code === PLUS) {
+      if (size > 1) return nok(code);
+      effects.consume(code);
+      size++;
+      return more;
+    }
+    if (size < 2) return nok(code);
+    const token = effects.exit(SEQUENCE_TEMPORARY);
+    const before = classifyCharacter(previous);
+    const after = classifyCharacter(code);
+    token._open = after === void 0 || after === GROUP_PUNCTUATION && before !== void 0;
+    token._close = before === void 0 || before === GROUP_PUNCTUATION && after !== void 0;
+    return ok(code);
+  }
+}
+function resolveAllUnderline(events, context) {
+  let index = -1;
+  while (++index < events.length) {
+    const closer = events[index];
+    if (closer === void 0 || closer[0] !== "enter" || closer[1].type !== SEQUENCE_TEMPORARY || closer[1]._close !== true) {
+      continue;
+    }
+    let open = index;
+    while (open--) {
+      const opener = events[open];
+      if (opener === void 0 || opener[0] !== "exit" || opener[1].type !== SEQUENCE_TEMPORARY || opener[1]._open !== true || // Sizes must match — always two here, kept for parity with the model.
+      closer[1].end.offset - closer[1].start.offset !== opener[1].end.offset - opener[1].start.offset) {
+        continue;
+      }
+      closer[1].type = SEQUENCE;
+      opener[1].type = SEQUENCE;
+      const underline = {
+        type: UNDERLINE,
+        start: { ...opener[1].start },
+        end: { ...closer[1].end }
+      };
+      const text = {
+        type: UNDERLINE_TEXT,
+        start: { ...opener[1].end },
+        end: { ...closer[1].start }
+      };
+      const next = [
+        ["enter", underline, context],
+        ["enter", opener[1], context],
+        ["exit", opener[1], context],
+        ["enter", text, context]
+      ];
+      const insideSpan = context.parser.constructs.insideSpan.null;
+      if (insideSpan !== void 0) {
+        spliceChunked(
+          next,
+          next.length,
+          0,
+          resolveAll(insideSpan, events.slice(open + 1, index), context)
+        );
+      }
+      spliceChunked(next, next.length, 0, [
+        ["exit", text, context],
+        ["enter", closer[1], context],
+        ["exit", closer[1], context],
+        ["exit", underline, context]
+      ]);
+      spliceChunked(events, open - 1, index - open + 3, next);
+      index = open + next.length - 2;
+      break;
+    }
+  }
+  for (const event of events) {
+    if (event[1].type === SEQUENCE_TEMPORARY) event[1].type = DATA;
+  }
+  return events;
+}
+function underlineSyntax() {
+  const construct = {
+    name: "underline",
+    tokenize: tokenizeUnderline,
+    resolveAll: resolveAllUnderline
+  };
+  return {
+    text: { [PLUS]: construct },
+    insideSpan: { null: [construct] },
+    attentionMarkers: { null: [PLUS] }
+  };
+}
+function enterUnderline(token) {
+  this.enter({ type: UNDERLINE, children: [], data: { hName: "u" } }, token);
+}
+function exitUnderline(token) {
+  this.exit(token);
+}
+function underlineFromMarkdown() {
+  return {
+    // A soft line break inside `++a\nb++` is kept as text, like `delete`.
+    canContainEols: [UNDERLINE],
+    enter: { [UNDERLINE]: enterUnderline },
+    exit: { [UNDERLINE]: exitUnderline }
+  };
+}
+function remarkUnderline() {
+  const data = this.data();
+  const micromark = data.micromarkExtensions ?? (data.micromarkExtensions = []);
+  const fromMarkdown = data.fromMarkdownExtensions ?? (data.fromMarkdownExtensions = []);
+  micromark.push(underlineSyntax());
+  fromMarkdown.push(underlineFromMarkdown());
+}
+var MARKDOWN_COMPONENTS = {
+  h1: ({ children }) => /* @__PURE__ */ jsx(
+    "h1",
+    {
+      className: "mt-6 mb-3 text-xl font-bold first:mt-0",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  h2: ({ children }) => /* @__PURE__ */ jsx(
+    "h2",
+    {
+      className: "mt-5 mb-2 text-lg font-bold first:mt-0",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  h3: ({ children }) => /* @__PURE__ */ jsx(
+    "h3",
+    {
+      className: "mt-4 mb-2 text-base font-semibold first:mt-0",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  p: ({ children }) => /* @__PURE__ */ jsx(
+    "p",
+    {
+      className: "mb-4 leading-relaxed last:mb-0",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  // list-outside + left padding so wrapped lines indent under the text (not the
+  // marker). Bullets use text-tertiary; ordered markers use --accent + bold so
+  // the numbering reads as deliberate hierarchy rather than browser-default grey.
+  ul: ({ children }) => /* @__PURE__ */ jsx(
+    "ul",
+    {
+      className: "mb-4 list-disc list-outside space-y-2 pl-6",
+      style: { color: "rgb(var(--text-tertiary))" },
+      children
+    }
+  ),
+  ol: ({ children }) => /* @__PURE__ */ jsx(
+    "ol",
+    {
+      className: "mb-4 list-decimal list-outside space-y-2 pl-6 marker:font-semibold",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  li: ({ children }) => /* @__PURE__ */ jsx(
+    "li",
+    {
+      className: "pl-1 leading-relaxed",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  strong: ({ children }) => /* @__PURE__ */ jsx("strong", { className: "font-semibold", style: { color: "rgb(var(--foreground))" }, children }),
+  em: ({ children }) => /* @__PURE__ */ jsx("em", { className: "italic", style: { color: "rgb(var(--foreground))" }, children }),
+  // code: inline chip or code block (CodeBlock via MarkdownCode). pre renders
+  // no element — CodeBlock owns its container — but it is what tells the code
+  // inside it that it is a block, language or not (see PreContext).
+  code: MarkdownCode,
+  pre: MarkdownPre,
+  blockquote: ({ children }) => /* @__PURE__ */ jsx(
+    "blockquote",
+    {
+      className: "my-4 border-l-4 py-1 pl-4 italic",
+      style: {
+        borderColor: "rgb(var(--accent))",
+        color: "rgb(var(--muted-foreground))"
+      },
+      children
+    }
+  ),
+  hr: () => /* @__PURE__ */ jsx("hr", { className: "my-6", style: { borderColor: "rgb(var(--border))" } }),
+  a: ({ href, children }) => /* @__PURE__ */ jsx(
+    "a",
+    {
+      href,
+      className: "hover:underline",
+      style: { color: "rgb(var(--accent))" },
+      target: "_blank",
+      rel: "noopener noreferrer",
+      children
+    }
+  ),
+  // GFM additions — tables, task lists, strikethrough.
+  table: ({ children }) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "my-4 overflow-x-auto",
+      style: {
+        borderRadius: "var(--radius-md)",
+        border: "1px solid rgb(var(--border))"
+      },
+      children: /* @__PURE__ */ jsx("table", { className: "w-full border-collapse text-sm", children })
+    }
+  ),
+  thead: ({ children }) => /* @__PURE__ */ jsx(
+    "thead",
+    {
+      style: {
+        background: "rgb(var(--muted))",
+        color: "rgb(var(--muted-foreground))"
+      },
+      children
+    }
+  ),
+  tbody: ({ children }) => /* @__PURE__ */ jsx("tbody", { children }),
+  tr: ({ children }) => /* @__PURE__ */ jsx(
+    "tr",
+    {
+      className: "first:border-t-0",
+      style: { borderTop: "1px solid rgb(var(--border))" },
+      children
+    }
+  ),
+  th: ({ children }) => /* @__PURE__ */ jsx("th", { className: "px-3 py-2 text-left font-medium", children }),
+  td: ({ children }) => /* @__PURE__ */ jsx(
+    "td",
+    {
+      className: "px-3 py-2 align-top",
+      style: { color: "rgb(var(--foreground))" },
+      children
+    }
+  ),
+  del: ({ children }) => /* @__PURE__ */ jsx("del", { className: "line-through", style: { color: "rgb(var(--muted-foreground))" }, children }),
+  // Underline — `++text++` via remarkUnderline (ADR-148 D13). The line is a
+  // step softer than the ink so it reads as a deliberate underline, not a link.
+  u: ({ children }) => /* @__PURE__ */ jsx(
+    "u",
+    {
+      className: "underline-offset-2",
+      style: {
+        color: "rgb(var(--foreground))",
+        textDecorationColor: "rgb(var(--text-tertiary))"
+      },
+      children
+    }
+  ),
+  // Task-list checkboxes rendered by remark-gfm for "- [ ] ..." / "- [x] ...".
+  input: (props) => props.type === "checkbox" ? /* @__PURE__ */ jsx(
+    "input",
+    {
+      ...props,
+      disabled: true,
+      className: "mr-1.5 -translate-y-px",
+      style: { accentColor: "rgb(var(--accent))" }
+    }
+  ) : /* @__PURE__ */ jsx("input", { ...props })
+};
+var REMARK_PLUGINS = [remarkGfm, remarkUnderline];
+function MarkdownRenderer({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(
+    ReactMarkdown,
+    {
+      components: MARKDOWN_COMPONENTS,
+      remarkPlugins: REMARK_PLUGINS,
+      children
+    }
+  ) });
+}
+function Kbd({ children, size = "md", tone = "neutral" }) {
+  const onAccent = tone === "on-accent";
+  const style = {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    gap: "0.125rem",
+    // On an accent fill the INK stays at full strength and the container does
+    // the quieting. Fading the text instead is the tempting move and it is
+    // wrong: white at 85% over --accent measures 4.33:1, under AA, while full
+    // white is 5.64:1. The translucent fill also lightens the local ground, so
+    // it raises the text's contrast rather than lowering it.
+    background: onAccent ? "rgb(var(--accent-foreground) / 0.16)" : "rgb(var(--surface-overlay-soft))",
+    border: `1px solid ${onAccent ? "rgb(var(--accent-foreground) / 0.4)" : "rgb(var(--border))"}`,
+    color: onAccent ? "rgb(var(--accent-foreground))" : "rgb(var(--text-tertiary))",
+    fontFamily: "var(--font-mono)",
+    fontSize: size === "sm" ? "10.5px" : "11.5px",
+    padding: size === "sm" ? "1px 6px" : "2px 8px",
+    borderRadius: "var(--radius-xs)",
+    lineHeight: 1
+  };
+  return /* @__PURE__ */ jsx("kbd", { style, children });
+}
+var MENTION_SCHEMES = ["user", "task_item", "task_board"];
+var MENTION_PATTERN = new RegExp(`^(${MENTION_SCHEMES.join("|")}):(.+)$`);
+function isMentionScheme(value) {
+  return MENTION_SCHEMES.some((scheme) => scheme === value);
+}
+function parseMentionHref(href) {
+  if (href === void 0) return null;
+  const match = MENTION_PATTERN.exec(href);
+  if (match === null) return null;
+  const type = match[1];
+  const id = match[2];
+  if (type === void 0 || id === void 0) return null;
+  if (!isMentionScheme(type)) return null;
+  return { type, id };
+}
+function urlTransform(value) {
+  return parseMentionHref(value) === null ? defaultUrlTransform(value) : value;
+}
+function CommentBody({ bodyMd, onSelectMention, className }) {
+  const components = {
+    ...MARKDOWN_COMPONENTS,
+    // Paragraph spacing inside a comment is tighter than the document default
+    // the shared map assumes — a comment is a remark, not an article.
+    p: ({ children }) => /* @__PURE__ */ jsx("p", { className: "mb-[var(--space-2)] leading-[1.55] last:mb-0", style: { color: "rgb(var(--foreground))" }, children }),
+    // Images are outside the composer's subset — ADR-148 D3: "images-by-markdown
+    // out; ADR-151 owns attachments" — but `![alt](url)` is still typeable. It
+    // renders as its alt text and nothing else: no `<img>`, so no request to a
+    // user-supplied URL and no empty-`src` element when the transform strips a
+    // dangerous one. ADR-151: this is the entry to revisit when attachments land.
+    img: ({ alt }) => alt === void 0 || alt === "" ? null : /* @__PURE__ */ jsx("span", { children: alt }),
+    a: ({ href, children }) => {
+      const mention = parseMentionHref(href);
+      if (mention === null) {
+        return /* @__PURE__ */ jsx(
+          "a",
+          {
+            href,
+            className: "underline-offset-2 hover:underline",
+            style: { color: "rgb(var(--accent-ink))" },
+            target: "_blank",
+            rel: "noopener noreferrer",
+            children
+          }
+        );
+      }
+      const interactive = onSelectMention !== void 0;
+      const Tag = interactive ? "button" : "span";
+      return /* @__PURE__ */ jsx(
+        Tag,
+        {
+          ...interactive ? { type: "button", onClick: () => {
+            onSelectMention(mention);
+          } } : {},
+          className: cn(
+            "inline-flex items-center align-baseline text-[12.5px] font-semibold",
+            "transition-[background-color,border-color] duration-[var(--dur-fast)] ease-[var(--ease-out)]",
+            "motion-reduce:transition-none",
+            "border border-[rgb(var(--border))] bg-[rgb(var(--surface-inset))] text-[rgb(var(--accent-ink))]",
+            interactive && "hover:border-[rgb(var(--accent))] hover:bg-[rgb(var(--surface-hover))] focus-visible:outline-none focus-visible:[box-shadow:var(--ring-focus)]"
+          ),
+          style: {
+            borderRadius: "var(--radius-sm)",
+            paddingInline: "var(--space-1)"
+          },
+          children
+        }
+      );
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn("text-[13px]", className),
+      style: { color: "rgb(var(--foreground))" },
+      children: /* @__PURE__ */ jsx(
+        ReactMarkdown,
+        {
+          components,
+          remarkPlugins: REMARK_PLUGINS,
+          urlTransform,
+          children: bodyMd
+        }
+      )
+    }
+  );
+}
+function ComposerFooter({
+  toolbar,
+  mode,
+  onModeChange,
+  modeDisabled = false,
+  meta,
+  actions
+}) {
+  const showSwitcher = onModeChange !== void 0 && mode !== void 0;
+  const next = mode === "rich" ? "plain" : "rich";
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "ds-composer-footer flex min-w-0 flex-nowrap items-center gap-[var(--space-1)]",
+      style: { padding: "0 var(--space-2) var(--space-2)" },
+      children: [
+        showSwitcher ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "icon",
+              size: "sm",
+              className: "shrink-0",
+              "aria-label": `Switch to the ${next} editor`,
+              title: `Switch to the ${next} editor`,
+              disabled: modeDisabled,
+              onMouseDown: (event) => {
+                event.preventDefault();
+              },
+              onClick: () => {
+                onModeChange(next);
+              },
+              children: mode === "rich" ? /* @__PURE__ */ jsx(PencilLine, { size: 12, strokeWidth: 1.75, "aria-hidden": "true" }) : /* @__PURE__ */ jsx(Type, { size: 12, strokeWidth: 1.75, "aria-hidden": "true" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "shrink-0",
+              style: {
+                inlineSize: "1px",
+                blockSize: "var(--space-4)",
+                marginInline: "var(--space-1)",
+                background: "rgb(var(--border))"
+              }
+            }
+          )
+        ] }) : null,
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "flex min-w-0 flex-1 items-center gap-[var(--space-1)]",
+              "overflow-x-auto overscroll-x-contain",
+              // A scrollbar in a 24px-tall control strip is louder than the
+              // controls; the row is short enough to drag or shift-wheel.
+              "[scrollbar-width:none] [&::-webkit-scrollbar]:hidden"
+            ),
+            children: toolbar
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "ds-composer-meta contents", children: meta }),
+        actions
+      ]
+    }
+  );
+}
+
+// src/thread/markdown-format.ts
+var WRAPPERS = {
+  bold: "**",
+  italic: "_",
+  code: "`"
+};
+var LIST_PREFIX = "- ";
+var LINK_PLACEHOLDER = "url";
+function clamp(n, min, max) {
+  return Math.min(Math.max(n, min), max);
+}
+function applyWrapper(value, start, end, marker) {
+  const selected = value.slice(start, end);
+  const width = marker.length;
+  if (selected.length >= width * 2 && selected.startsWith(marker) && selected.endsWith(marker)) {
+    const inner = selected.slice(width, selected.length - width);
+    return {
+      value: value.slice(0, start) + inner + value.slice(end),
+      selectionStart: start,
+      selectionEnd: start + inner.length
+    };
+  }
+  if (start >= width && value.slice(start - width, start) === marker && value.slice(end, end + width) === marker) {
+    return {
+      value: value.slice(0, start - width) + selected + value.slice(end + width),
+      selectionStart: start - width,
+      selectionEnd: start - width + selected.length
+    };
+  }
+  return {
+    value: value.slice(0, start) + marker + selected + marker + value.slice(end),
+    selectionStart: start + width,
+    selectionEnd: end + width
+  };
+}
+function applyLink(value, start, end) {
+  const selected = value.slice(start, end);
+  const inserted = `[${selected}](${LINK_PLACEHOLDER})`;
+  const next = value.slice(0, start) + inserted + value.slice(end);
+  if (selected === "") {
+    return { value: next, selectionStart: start + 1, selectionEnd: start + 1 };
+  }
+  const urlStart = start + selected.length + 3;
+  return {
+    value: next,
+    selectionStart: urlStart,
+    selectionEnd: urlStart + LINK_PLACEHOLDER.length
+  };
+}
+function applyList(value, start, end) {
+  const lineStart = value.lastIndexOf("\n", Math.max(start - 1, 0)) + 1;
+  const nextBreak = value.indexOf("\n", end);
+  const lineEnd = nextBreak === -1 ? value.length : nextBreak;
+  const block = value.slice(lineStart, lineEnd);
+  const lines = block.split("\n");
+  const meaningful = lines.filter((line) => line.trim() !== "");
+  const allPrefixed = meaningful.length > 0 && meaningful.every((line) => line.startsWith(LIST_PREFIX));
+  const next = lines.map((line) => {
+    if (allPrefixed) return line.startsWith(LIST_PREFIX) ? line.slice(LIST_PREFIX.length) : line;
+    return line.trim() === "" ? line : LIST_PREFIX + line;
+  }).join("\n");
+  return {
+    value: value.slice(0, lineStart) + next + value.slice(lineEnd),
+    selectionStart: lineStart,
+    selectionEnd: lineStart + next.length
+  };
+}
+function applyMarkdownFormat(value, selectionStart, selectionEnd, format) {
+  const start = clamp(Math.min(selectionStart, selectionEnd), 0, value.length);
+  const end = clamp(Math.max(selectionStart, selectionEnd), 0, value.length);
+  switch (format) {
+    case "bold":
+      return applyWrapper(value, start, end, WRAPPERS.bold);
+    case "italic":
+      return applyWrapper(value, start, end, WRAPPERS.italic);
+    case "code":
+      return applyWrapper(value, start, end, WRAPPERS.code);
+    case "link":
+      return applyLink(value, start, end);
+    case "list":
+      return applyList(value, start, end);
+  }
+}
+var SEND_KEYCAP = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.userAgent) ? "\u2318\u21B5" : "Ctrl \u21B5";
+var TOOLBAR = [
+  { format: "bold", label: "Bold", icon: Bold, shortcut: "b" },
+  { format: "italic", label: "Italic", icon: Italic, shortcut: "i" },
+  { format: "code", label: "Code", icon: Code },
+  { format: "link", label: "Link", icon: Link, shortcut: "k" },
+  { format: "list", label: "Bulleted list", icon: List }
+];
+function ThreadComposer({
+  value,
+  onChange,
+  onSubmit,
+  onCancel,
+  placeholder = "Add a comment\u2026",
+  submitLabel = "Comment",
+  cancelLabel = "Cancel",
+  sending = false,
+  disabled = false,
+  replyingTo,
+  avatar,
+  rows = 3,
+  autoFocus = false,
+  toolbar = true,
+  maxLength,
+  mode,
+  onModeChange,
+  label,
+  className
+}) {
+  const textareaRef = useRef(null);
+  const pendingSelection = useRef(null);
+  useLayoutEffect(() => {
+    const selection = pendingSelection.current;
+    const element = textareaRef.current;
+    if (selection === null || element === null) return;
+    pendingSelection.current = null;
+    element.focus();
+    element.setSelectionRange(selection.start, selection.end);
+  }, [value]);
+  const format = useCallback(
+    (next) => {
+      const element = textareaRef.current;
+      if (element === null) return;
+      const edit = applyMarkdownFormat(
+        value,
+        element.selectionStart,
+        element.selectionEnd,
+        next
+      );
+      pendingSelection.current = { start: edit.selectionStart, end: edit.selectionEnd };
+      onChange(edit.value);
+    },
+    [onChange, value]
+  );
+  const onKeyDown = useCallback(
+    (event) => {
+      const mod = event.metaKey || event.ctrlKey;
+      if (mod && event.key === "Enter") {
+        event.preventDefault();
+        onSubmit();
+        return;
+      }
+      if (event.key === "Escape" && onCancel !== void 0) {
+        event.preventDefault();
+        onCancel();
+        return;
+      }
+      if (!mod) return;
+      const action = TOOLBAR.find((entry) => entry.shortcut === event.key.toLowerCase());
+      if (action === void 0) return;
+      event.preventDefault();
+      format(action.format);
+    },
+    [format, onCancel, onSubmit]
+  );
+  const canSend = value.trim() !== "" && !sending && !disabled;
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex flex-col gap-[var(--space-1)]", className), children: [
+    replyingTo === void 0 ? null : /* @__PURE__ */ jsxs(
+      "p",
+      {
+        className: "flex items-center gap-[var(--space-1)] text-[12px]",
+        style: { color: "rgb(var(--text-tertiary))" },
+        children: [
+          /* @__PURE__ */ jsx(CornerDownRight, { size: 10, strokeWidth: 1.5, "aria-hidden": "true" }),
+          "Replying to",
+          " ",
+          /* @__PURE__ */ jsx("span", { className: "font-semibold", style: { color: "rgb(var(--text-secondary))" }, children: replyingTo })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-[var(--space-2)]", children: [
+      avatar,
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: cn(
+            "min-w-0 flex-1 overflow-hidden border",
+            "transition-[border-color,box-shadow] duration-[var(--dur-fast)] ease-[var(--ease-out)]",
+            "motion-reduce:transition-none",
+            "focus-within:border-[rgb(var(--accent))] focus-within:[box-shadow:var(--ring-focus)]"
+          ),
+          style: {
+            // Concentric: the host panel declares --thread-inner-radius as its
+            // own radius minus its padding (interface standards §1). Nothing
+            // here eyeballs a corner.
+            borderRadius: "var(--thread-inner-radius, var(--radius-sm))",
+            borderColor: "rgb(var(--border))",
+            background: "rgb(var(--surface-card))"
+          },
+          children: [
+            /* @__PURE__ */ jsx(
+              "textarea",
+              {
+                ref: textareaRef,
+                "aria-label": label,
+                className: "block w-full resize-none bg-transparent outline-none",
+                placeholder,
+                rows,
+                value,
+                disabled,
+                autoFocus,
+                onChange: (event) => {
+                  onChange(event.target.value);
+                },
+                onKeyDown,
+                ...maxLength === void 0 ? {} : { maxLength },
+                style: {
+                  // Optical: vertical is a step tighter than horizontal, because the
+                  // line box already carries space the glyphs do not fill.
+                  padding: "var(--space-2) var(--space-3)",
+                  color: "rgb(var(--foreground))",
+                  fontFamily: "var(--font-sans)",
+                  fontSize: "13px",
+                  lineHeight: 1.55
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ComposerFooter,
+              {
+                ...mode === void 0 ? {} : { mode },
+                ...onModeChange === void 0 ? {} : { onModeChange },
+                modeDisabled: disabled,
+                toolbar: /* @__PURE__ */ jsx(Fragment, { children: toolbar ? TOOLBAR.map((action) => {
+                  const Icon = action.icon;
+                  return /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      variant: "icon",
+                      size: "sm",
+                      "aria-label": action.label,
+                      title: action.label,
+                      disabled: disabled || sending,
+                      onClick: () => {
+                        format(action.format);
+                      },
+                      children: /* @__PURE__ */ jsx(Icon, { size: 12, strokeWidth: 1.75, "aria-hidden": "true" })
+                    },
+                    action.format
+                  );
+                }) : null }),
+                meta: /* @__PURE__ */ jsx(Fragment, { children: maxLength === void 0 ? null : /* @__PURE__ */ jsxs(
+                  "span",
+                  {
+                    className: "tabular-nums text-right",
+                    style: {
+                      minInlineSize: "7ch",
+                      fontSize: "11.5px",
+                      color: value.length > maxLength * 0.9 ? "rgb(var(--warning-ink))" : "rgb(var(--text-tertiary))"
+                    },
+                    children: [
+                      value.length,
+                      "/",
+                      maxLength
+                    ]
+                  }
+                ) }),
+                actions: /* @__PURE__ */ jsxs(Fragment, { children: [
+                  onCancel === void 0 ? null : /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      variant: "secondary",
+                      size: "sm",
+                      onClick: onCancel,
+                      disabled: disabled || sending,
+                      children: cancelLabel
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      variant: "primary",
+                      size: "sm",
+                      onClick: () => {
+                        onSubmit();
+                      },
+                      disabled: !canSend,
+                      "aria-label": sending ? "Sending\u2026" : submitLabel,
+                      trailingIcon: /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "ds-composer-keycap", children: /* @__PURE__ */ jsx(Kbd, { size: "sm", tone: "on-accent", children: SEND_KEYCAP }) }),
+                      children: sending ? "Sending\u2026" : submitLabel
+                    }
+                  )
+                ] })
+              }
+            )
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+var PASTE_ATTACHMENT_THRESHOLD = 2500;
+var GIF_SEARCH_DEBOUNCE_MS = 300;
+var ATTACHMENT_LIMITS = {
+  fileMaxBytes: 25 * 1024 * 1024,
+  commentMaxBytes: 50 * 1024 * 1024,
+  maxPerComment: 10
+};
+var localIdCounter = 0;
+function nextLocalId() {
+  localIdCounter += 1;
+  return `att-local-${String(localIdCounter)}`;
+}
+function pastedTextFilename(index) {
+  return `pasted-text-${String(index)}.txt`;
+}
+function shouldAttachPaste(text) {
+  return text.length >= PASTE_ATTACHMENT_THRESHOLD;
+}
+function kindOf(ticketKind) {
+  if (ticketKind === "image" || ticketKind === "gif") return ticketKind;
+  return "file";
+}
+function previewFor(file) {
+  if (!file.type.startsWith("image/")) return void 0;
+  try {
+    return URL.createObjectURL(file);
+  } catch {
+    return void 0;
+  }
+}
+function useAttachments(options) {
+  const {
+    upload,
+    attachGif,
+    onError,
+    maxPerComment = ATTACHMENT_LIMITS.maxPerComment,
+    maxFileBytes = ATTACHMENT_LIMITS.fileMaxBytes,
+    maxTotalBytes = ATTACHMENT_LIMITS.commentMaxBytes
+  } = options;
+  const [attachments, setAttachments] = useState([]);
+  const listRef = useRef([]);
+  const commit = useCallback(
+    (next) => {
+      const value = next(listRef.current);
+      listRef.current = value;
+      setAttachments(value);
+    },
+    []
+  );
+  const controllers = useRef(/* @__PURE__ */ new Map());
+  const objectUrls = useRef(/* @__PURE__ */ new Set());
+  const pasteCount = useRef(0);
+  const uploadRef = useRef(upload);
+  const errorRef = useRef(onError);
+  uploadRef.current = upload;
+  errorRef.current = onError;
+  const gifRef = useRef(attachGif);
+  gifRef.current = attachGif;
+  useEffect(() => {
+    const urls = objectUrls.current;
+    const inFlight = controllers.current;
+    return () => {
+      for (const url of urls) URL.revokeObjectURL(url);
+      urls.clear();
+      for (const controller of inFlight.values()) controller.abort();
+      inFlight.clear();
+    };
+  }, []);
+  const releasePreview = useCallback((url) => {
+    if (url === void 0 || !objectUrls.current.has(url)) return;
+    objectUrls.current.delete(url);
+    setTimeout(() => {
+      URL.revokeObjectURL(url);
+    }, 0);
+  }, []);
+  const patch = useCallback(
+    (localId, next) => {
+      commit((current) => current.map((a) => a.localId === localId ? { ...a, ...next } : a));
+    },
+    [commit]
+  );
+  const fail = useCallback((message) => {
+    errorRef.current?.(message);
+  }, []);
+  const start = useCallback(
+    (blob, meta) => {
+      const uploader = uploadRef.current;
+      if (uploader === void 0) return;
+      const localId = nextLocalId();
+      const controller = new AbortController();
+      controllers.current.set(localId, controller);
+      if (meta.previewUrl !== void 0) objectUrls.current.add(meta.previewUrl);
+      commit((current) => [
+        ...current,
+        {
+          localId,
+          name: meta.name,
+          sizeBytes: blob.size,
+          kind: meta.kind,
+          state: "uploading",
+          progress: 0,
+          previewUrl: meta.previewUrl,
+          pastedText: meta.pastedText,
+          charCount: meta.charCount
+        }
+      ]);
+      void uploader(blob, {
+        filename: meta.name,
+        signal: controller.signal,
+        onProgress: (fraction) => {
+          patch(localId, { progress: Math.max(0, Math.min(1, fraction)) });
+        }
+      }).then((ticket) => {
+        controllers.current.delete(localId);
+        patch(localId, {
+          state: "ready",
+          progress: 1,
+          ticketId: ticket.id,
+          // The server's own account wins over the local guess: it read the
+          // magic number and we read a filename.
+          name: ticket.name,
+          sizeBytes: ticket.sizeBytes,
+          kind: kindOf(ticket.kind),
+          ...ticket.aspectRatio === null ? {} : { aspectRatio: ticket.aspectRatio }
+        });
+      }).catch((err) => {
+        controllers.current.delete(localId);
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        const message = err instanceof Error && err.message.length > 0 ? err.message : "That file couldn't be attached.";
+        patch(localId, { state: "failed", error: message });
+        fail(message);
+      });
+      return localId;
+    },
+    [commit, fail, patch]
+  );
+  const admits = useCallback(
+    (size, label) => {
+      const current = listRef.current;
+      if (current.length >= maxPerComment) {
+        fail(`You can attach up to ${String(maxPerComment)} files to a comment.`);
+        return false;
+      }
+      if (size > maxFileBytes) {
+        fail(`${label} is too large. Files can be up to 25 MB.`);
+        return false;
+      }
+      const total = current.reduce((sum, a) => sum + a.sizeBytes, 0);
+      if (total + size > maxTotalBytes) {
+        fail("That would put this comment over 50 MB of attachments.");
+        return false;
+      }
+      return true;
+    },
+    [fail, maxFileBytes, maxPerComment, maxTotalBytes]
+  );
+  const addFiles = useCallback(
+    (files) => {
+      if (uploadRef.current === void 0) return;
+      for (const file of files) {
+        if (!admits(file.size, file.name)) continue;
+        const preview = previewFor(file);
+        start(file, {
+          name: file.name,
+          kind: file.type.startsWith("image/") ? "image" : "file",
+          previewUrl: preview
+        });
+      }
+    },
+    [admits, start]
+  );
+  const addPastedText = useCallback(
+    (text) => {
+      if (uploadRef.current === void 0) return false;
+      if (!shouldAttachPaste(text)) return false;
+      pasteCount.current += 1;
+      const name = pastedTextFilename(pasteCount.current);
+      const blob = new Blob([text], { type: "text/plain" });
+      if (!admits(blob.size, "That paste")) {
+        pasteCount.current -= 1;
+        return false;
+      }
+      start(blob, { name, kind: "file", pastedText: text, charCount: text.length });
+      return true;
+    },
+    [admits, start]
+  );
+  const addGif = useCallback(
+    (gif) => {
+      const attach = gifRef.current;
+      if (attach === void 0) return;
+      if (listRef.current.length >= maxPerComment) {
+        fail(`You can attach up to ${String(maxPerComment)} files to a comment.`);
+        return;
+      }
+      const localId = nextLocalId();
+      commit((current) => [
+        ...current,
+        {
+          localId,
+          name: gif.title.length > 0 ? gif.title : "GIF",
+          sizeBytes: 0,
+          kind: "gif",
+          state: "uploading",
+          progress: 0,
+          previewUrl: gif.stillUrl,
+          ...gif.height > 0 ? { aspectRatio: gif.width / gif.height } : {}
+        }
+      ]);
+      void attach(gif.id).then((ticket) => {
+        patch(localId, {
+          state: "ready",
+          progress: 1,
+          ticketId: ticket.id,
+          name: ticket.name,
+          sizeBytes: ticket.sizeBytes,
+          kind: "gif",
+          ...ticket.aspectRatio === null ? {} : { aspectRatio: ticket.aspectRatio }
+        });
+      }).catch((err) => {
+        const message = err instanceof Error && err.message.length > 0 ? err.message : "That GIF couldn't be attached.";
+        patch(localId, { state: "failed", error: message });
+        fail(message);
+      });
+    },
+    [commit, fail, maxPerComment, patch]
+  );
+  const remove = useCallback(
+    (localId) => {
+      controllers.current.get(localId)?.abort();
+      controllers.current.delete(localId);
+      releasePreview(listRef.current.find((a) => a.localId === localId)?.previewUrl);
+      commit((current) => current.filter((a) => a.localId !== localId));
+    },
+    [commit, releasePreview]
+  );
+  const insertAsText = useCallback(
+    (localId) => {
+      const found = listRef.current.find((a) => a.localId === localId);
+      const text = found?.pastedText ?? null;
+      if (text === null) return null;
+      controllers.current.get(localId)?.abort();
+      controllers.current.delete(localId);
+      releasePreview(found?.previewUrl);
+      commit((current) => current.filter((a) => a.localId !== localId));
+      return text;
+    },
+    [commit, releasePreview]
+  );
+  const clear = useCallback(() => {
+    for (const controller of controllers.current.values()) controller.abort();
+    controllers.current.clear();
+    for (const attachment of listRef.current) releasePreview(attachment.previewUrl);
+    commit(() => []);
+  }, [commit, releasePreview]);
+  return {
+    attachments,
+    ticketIds: attachments.filter((a) => a.state === "ready" && a.ticketId !== void 0).map((a) => a.ticketId ?? ""),
+    isUploading: attachments.some((a) => a.state === "uploading"),
+    addFiles,
+    addPastedText,
+    addGif,
+    remove,
+    insertAsText,
+    clear
+  };
+}
+function useAttachmentUrl(attachmentId, resolve) {
+  const [url, setUrl] = useState(null);
+  const [failed, setFailed] = useState(false);
+  const [loading, setLoading] = useState(resolve !== void 0);
+  const resolveRef = useRef(resolve);
+  resolveRef.current = resolve;
+  const enabled = resolve !== void 0;
+  useEffect(() => {
+    const current = resolveRef.current;
+    if (current === void 0) return;
+    let live = true;
+    setUrl(null);
+    setFailed(false);
+    setLoading(true);
+    void current(attachmentId).then((next) => {
+      if (!live) return;
+      if (next === null || next.length === 0) setFailed(true);
+      else setUrl(next);
+      setLoading(false);
+    }).catch(() => {
+      if (!live) return;
+      setFailed(true);
+      setLoading(false);
+    });
+    return () => {
+      live = false;
+    };
+  }, [attachmentId, enabled]);
+  return { url, failed, loading };
+}
+var QUIET_ICON = cn(
+  "inline-flex shrink-0 items-center justify-center border-0 bg-transparent",
+  "text-[rgb(var(--text-tertiary))]",
+  "transition-[background-color,color] duration-[var(--dur-fast)] ease-[var(--ease-out)]",
+  "motion-reduce:transition-none",
+  "hover:bg-[rgb(var(--surface-overlay))] hover:text-[rgb(var(--foreground))]",
+  "focus-visible:outline-none focus-visible:[box-shadow:var(--ring-focus)]",
+  "disabled:cursor-default disabled:opacity-60"
+);
+var QUIET_ICON_BOX = {
+  minBlockSize: "var(--space-6)",
+  minInlineSize: "var(--space-6)",
+  borderRadius: "var(--radius-xs)"
+};
+function formatCharacterCount(count) {
+  const n = Math.max(0, Math.round(count));
+  return `${n.toLocaleString("en-US")} ${n === 1 ? "character" : "characters"}`;
+}
+function formatAttachmentSize(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "";
+  if (bytes < 1024) return `${String(bytes)} B`;
+  if (bytes < 1024 * 1024) return `${String(Math.round(bytes / 1024))} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function usePrefersReducedMotion() {
+  const [reduced, setReduced] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    const query = window.matchMedia("(prefers-reduced-motion: reduce)");
+    setReduced(query.matches);
+    const onChange = (event) => {
+      setReduced(event.matches);
+    };
+    query.addEventListener("change", onChange);
+    return () => {
+      query.removeEventListener("change", onChange);
+    };
+  }, []);
+  return reduced;
+}
+function AttachmentTray({
+  attachments,
+  onRemove,
+  onInsertAsText,
+  className
+}) {
+  if (attachments.length === 0) return null;
+  return /* @__PURE__ */ jsx(
+    "ul",
+    {
+      className: cn("flex list-none flex-wrap gap-[var(--space-2)] p-0", className),
+      style: { marginBlockStart: "var(--space-2)" },
+      children: attachments.map((attachment) => /* @__PURE__ */ jsx(
+        AttachmentChip,
+        {
+          attachment,
+          onRemove,
+          ...onInsertAsText === void 0 ? {} : { onInsertAsText }
+        },
+        attachment.localId
+      ))
+    }
+  );
+}
+function AttachmentChip({
+  attachment,
+  onRemove,
+  onInsertAsText
+}) {
+  const uploading = attachment.state === "uploading";
+  const failed = attachment.state === "failed";
+  const restorable = onInsertAsText !== void 0 && attachment.pastedText !== void 0;
+  return /* @__PURE__ */ jsxs(
+    "li",
+    {
+      className: cn(
+        "flex min-w-0 items-center gap-[var(--space-2)] border px-[var(--space-2)] py-[var(--space-1)]",
+        "text-[12px]"
+      ),
+      style: {
+        borderRadius: "var(--radius-sm)",
+        borderColor: failed ? "rgb(var(--destructive))" : "rgb(var(--border))",
+        // `--muted`, not `--surface-overlay*`. CLAUDE.md §2 names chips as
+        // exactly what the flat opaque grey is for; the translucent overlay
+        // tints wash out when they stack on another layer, and a chip inside a
+        // composer inside a card is two layers deep already.
+        background: "rgb(var(--muted))",
+        // The chip's height cannot depend on whether it holds a thumbnail, a
+        // progress bar or an error, or the composer would jump on every state
+        // change. One declared minimum, three contents.
+        minBlockSize: "var(--ctrl-md)",
+        maxInlineSize: "calc(var(--space-12) * 5)"
+      },
+      children: [
+        /* @__PURE__ */ jsx(AttachmentChipThumb, { attachment }),
+        /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 flex-col", children: [
+          /* @__PURE__ */ jsx("span", { className: "truncate", style: { color: "rgb(var(--foreground))" }, children: attachment.name }),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "flex items-center gap-[var(--space-2)] tabular-nums",
+              style: {
+                color: failed ? "rgb(var(--destructive))" : "rgb(var(--text-tertiary))",
+                // Reserved so the second line exists before there is anything on it.
+                minBlockSize: "var(--space-4)"
+              },
+              children: failed ? /* @__PURE__ */ jsx("span", { className: "truncate", children: attachment.error ?? "Upload failed" }) : uploading ? /* @__PURE__ */ jsx(AttachmentProgress, { value: attachment.progress, label: attachment.name }) : attachment.charCount === void 0 ? /* @__PURE__ */ jsx("span", { children: formatAttachmentSize(attachment.sizeBytes) }) : (
+                // D5, verbatim: "the character count shown on the chip". A byte
+                // size would be the wrong unit here — the person pasted characters,
+                // and for anything non-ASCII the two numbers differ.
+                /* @__PURE__ */ jsx("span", { children: formatCharacterCount(attachment.charCount) })
+              )
+            }
+          )
+        ] }),
+        restorable ? /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "secondary",
+            size: "sm",
+            onClick: () => {
+              onInsertAsText?.(attachment.localId);
+            },
+            children: "Insert as text instead"
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": uploading ? `Cancel ${attachment.name}` : `Remove ${attachment.name}`,
+            className: QUIET_ICON,
+            style: QUIET_ICON_BOX,
+            onClick: () => {
+              onRemove(attachment.localId);
+            },
+            children: /* @__PURE__ */ jsx(X, { size: 12, strokeWidth: 1.75, "aria-hidden": "true" })
+          }
+        )
+      ]
+    }
+  );
+}
+function AttachmentChipThumb({ attachment }) {
+  const visual = attachment.kind === "image" || attachment.kind === "gif";
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: "flex shrink-0 items-center justify-center overflow-hidden border",
+      style: {
+        inlineSize: "var(--space-6)",
+        blockSize: "var(--space-6)",
+        borderRadius: "var(--radius-xs)",
+        borderColor: "rgb(var(--border))",
+        background: "rgb(var(--muted))",
+        color: "rgb(var(--text-tertiary))"
+      },
+      children: visual && attachment.previewUrl !== void 0 ? /* @__PURE__ */ jsx("img", { src: attachment.previewUrl, alt: "", className: "h-full w-full object-cover" }) : visual ? /* @__PURE__ */ jsx(Image, { size: 12, strokeWidth: 1.5, "aria-hidden": "true" }) : /* @__PURE__ */ jsx(FileText, { size: 12, strokeWidth: 1.5, "aria-hidden": "true" })
+    }
+  );
+}
+function AttachmentProgress({ value, label }) {
+  const percent = Math.round(Math.max(0, Math.min(1, value)) * 100);
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      role: "progressbar",
+      "aria-label": `Uploading ${label}`,
+      "aria-valuemin": 0,
+      "aria-valuemax": 100,
+      "aria-valuenow": percent,
+      className: "block overflow-hidden",
+      style: {
+        inlineSize: "calc(var(--space-12) * 2)",
+        blockSize: "var(--space-1)",
+        borderRadius: "var(--radius-full)",
+        background: "rgb(var(--muted))"
+      },
+      children: /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "block transition-[inline-size] duration-[var(--dur-base)] ease-[var(--ease-out)] motion-reduce:transition-none",
+          style: {
+            inlineSize: `${String(percent)}%`,
+            blockSize: "100%",
+            background: "rgb(var(--accent))"
+          }
+        }
+      )
+    }
+  );
+}
+function AttachmentButton({
+  onFiles,
+  accept,
+  disabled = false,
+  label = "Attach a file"
+}) {
+  const inputRef = useRef(null);
+  const inputId = useId();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref: inputRef,
+        id: inputId,
+        type: "file",
+        multiple: true,
+        hidden: true,
+        ...accept === void 0 ? {} : { accept },
+        onChange: (event) => {
+          const { files } = event.currentTarget;
+          if (files !== null && files.length > 0) onFiles(files);
+          event.currentTarget.value = "";
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        "aria-label": label,
+        className: QUIET_ICON,
+        style: QUIET_ICON_BOX,
+        disabled,
+        onClick: () => {
+          inputRef.current?.click();
+        },
+        children: /* @__PURE__ */ jsx(Paperclip, { size: 14, strokeWidth: 1.75, "aria-hidden": "true" })
+      }
+    )
+  ] });
+}
+function AttachmentDropZone({
+  onFiles,
+  disabled = false,
+  children,
+  className
+}) {
+  const depth = useRef(0);
+  const [over, setOver] = useState(false);
+  const onDragEnter = useCallback(
+    (event) => {
+      if (disabled || !Array.from(event.dataTransfer.types).includes("Files")) return;
+      depth.current += 1;
+      setOver(true);
+    },
+    [disabled]
+  );
+  const onDragLeave = useCallback(() => {
+    depth.current = Math.max(0, depth.current - 1);
+    if (depth.current === 0) setOver(false);
+  }, []);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn("relative", className),
+      onDragEnter,
+      onDragOver: (event) => {
+        if (!disabled && Array.from(event.dataTransfer.types).includes("Files")) {
+          event.preventDefault();
+        }
+      },
+      onDragLeave,
+      onDrop: (event) => {
+        depth.current = 0;
+        setOver(false);
+        if (disabled) return;
+        const { files } = event.dataTransfer;
+        if (files.length === 0) return;
+        event.preventDefault();
+        onFiles(files);
+      },
+      children: [
+        children,
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            "aria-hidden": "true",
+            className: "pointer-events-none absolute inset-0 flex items-center justify-center border border-dashed transition-opacity duration-[var(--dur-fast)] ease-[var(--ease-out)] motion-reduce:transition-none",
+            style: {
+              visibility: over ? "visible" : "hidden",
+              opacity: over ? 1 : 0,
+              borderRadius: "var(--radius-md)",
+              borderColor: "rgb(var(--accent))",
+              background: "rgb(var(--accent-subtle))",
+              color: "rgb(var(--accent-ink))"
+            },
+            children: "Drop to attach"
+          }
+        )
+      ]
+    }
+  );
+}
+function GifPicker({ search, onPick, className }) {
+  const [query, setQuery] = useState("");
+  const [results, setResults] = useState([]);
+  const [state, setState] = useState("idle");
+  const reduced = usePrefersReducedMotion();
+  const listId = useId();
+  const searchRef = useRef(search);
+  searchRef.current = search;
+  useEffect(() => {
+    const trimmed = query.trim();
+    if (trimmed.length === 0) {
+      setResults([]);
+      setState("idle");
+      return;
+    }
+    let live = true;
+    setState("searching");
+    const timer = setTimeout(() => {
+      void searchRef.current(trimmed).then((next) => {
+        if (!live) return;
+        setResults(next);
+        setState("idle");
+      }).catch(() => {
+        if (!live) return;
+        setResults([]);
+        setState("error");
+      });
+    }, GIF_SEARCH_DEBOUNCE_MS);
+    return () => {
+      live = false;
+      clearTimeout(timer);
+    };
+  }, [query]);
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex flex-col gap-[var(--space-3)]", className), children: [
+    /* @__PURE__ */ jsx(
+      Input,
+      {
+        value: query,
+        onChange: (event) => {
+          setQuery(event.currentTarget.value);
+        },
+        placeholder: "Search GIFs",
+        "aria-label": "Search GIFs",
+        "aria-controls": listId,
+        leadingAffix: /* @__PURE__ */ jsx(Search, { size: 14, strokeWidth: 1.75, "aria-hidden": "true" })
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        id: listId,
+        className: "grid grid-cols-3 gap-[var(--space-2)] overflow-y-auto",
+        style: {
+          // Declared, so the panel is the same size empty, searching and full.
+          blockSize: "calc(var(--space-12) * 6)"
+        },
+        children: [
+          results.map((gif) => /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => {
+                onPick(gif);
+              },
+              className: "block overflow-hidden border transition-[border-color] duration-[var(--dur-fast)] ease-[var(--ease-out)] hover:border-[rgb(var(--border-strong))] focus-visible:outline-none focus-visible:[box-shadow:var(--ring-focus)] motion-reduce:transition-none",
+              style: {
+                borderRadius: "var(--radius-sm)",
+                borderColor: "rgb(var(--border))",
+                background: "rgb(var(--muted))",
+                aspectRatio: gif.height > 0 ? String(gif.width / gif.height) : "1"
+              },
+              children: reduced ? /* @__PURE__ */ jsx("img", { src: gif.stillUrl, alt: gif.title, className: "h-full w-full object-cover" }) : /* @__PURE__ */ jsx(
+                "video",
+                {
+                  src: gif.previewUrl,
+                  poster: gif.stillUrl,
+                  autoPlay: true,
+                  loop: true,
+                  muted: true,
+                  playsInline: true,
+                  "aria-label": gif.title,
+                  className: "h-full w-full object-cover"
+                }
+              )
+            },
+            gif.id
+          )),
+          results.length === 0 ? /* @__PURE__ */ jsx(
+            "p",
+            {
+              className: "col-span-3 self-center text-center text-[12px]",
+              style: { color: "rgb(var(--text-tertiary))" },
+              children: state === "error" ? "GIF search isn't available right now." : state === "searching" ? "Searching\u2026" : query.trim().length === 0 ? "Type to search." : "No GIFs matched."
+            }
+          ) : null
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "p",
+      {
+        className: "text-[11px] uppercase",
+        style: { color: "rgb(var(--text-tertiary))", letterSpacing: "0.06em" },
+        children: "Powered by GIPHY"
+      }
+    )
+  ] });
+}
+function AttachmentGif({ attachment, resolveUrl, className }) {
+  const reduced = usePrefersReducedMotion();
+  const { url, failed, loading } = useAttachmentUrl(attachment.id, resolveUrl);
+  const [playing, setPlaying] = useState(false);
+  const videoRef = useRef(null);
+  useEffect(() => {
+    if (reduced) setPlaying(false);
+  }, [reduced]);
+  const shouldPlay = !reduced || playing;
+  if (url === null || failed) {
+    return /* @__PURE__ */ jsx(
+      AttachmentPlaceholder,
+      {
+        attachment,
+        state: loading && !failed ? "loading" : "broken",
+        className
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: cn("relative block overflow-hidden border", className),
+      style: {
+        aspectRatio: String(attachment.aspectRatio ?? 16 / 10),
+        borderRadius: "var(--thread-inner-radius, var(--radius-sm))",
+        borderColor: "rgb(var(--border))",
+        background: "rgb(var(--surface-inset))",
+        inlineSize: "calc(var(--space-12) * 3)",
+        minInlineSize: "calc(var(--space-12) * 3)"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "video",
+          {
+            ref: videoRef,
+            src: url,
+            loop: true,
+            muted: true,
+            playsInline: true,
+            autoPlay: shouldPlay,
+            "aria-label": attachment.name,
+            className: "h-full w-full object-cover"
+          }
+        ),
+        shouldPlay ? null : /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": `Play ${attachment.name}`,
+            onClick: () => {
+              setPlaying(true);
+              void videoRef.current?.play();
+            },
+            className: "absolute inset-0 flex items-center justify-center focus-visible:outline-none focus-visible:[box-shadow:var(--ring-focus)]",
+            style: { background: "rgb(var(--media-scrim-mid))", color: "rgb(var(--media-on-scrim))" },
+            children: /* @__PURE__ */ jsx(Play, { size: 20, strokeWidth: 1.75, "aria-hidden": "true" })
+          }
+        )
+      ]
+    }
+  );
+}
+function AttachmentPlaceholder({
+  attachment,
+  state = "broken",
+  className
+}) {
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn("flex items-center justify-center overflow-hidden border", className),
+      style: {
+        aspectRatio: String(attachment.aspectRatio ?? 16 / 10),
+        borderRadius: "var(--thread-inner-radius, var(--radius-sm))",
+        borderColor: "rgb(var(--border))",
+        background: "rgb(var(--surface-inset))",
+        color: "rgb(var(--text-tertiary))",
+        inlineSize: "calc(var(--space-12) * 3)",
+        minInlineSize: "calc(var(--space-12) * 3)"
+      },
+      "aria-label": state === "loading" ? `Loading ${attachment.name}` : void 0,
+      children: state === "broken" ? /* @__PURE__ */ jsx(ImageOff, { size: 14, strokeWidth: 1.5, "aria-hidden": "true" }) : null
+    }
+  );
+}
+function AttachmentImage({
+  attachment,
+  onOpen,
+  resolveUrl,
+  className
+}) {
+  const reduced = usePrefersReducedMotion();
+  const [broken, setBroken] = useState(false);
+  const [playing, setPlaying] = useState(false);
+  const [capturedSrc, setCapturedSrc] = useState(null);
+  const imageRef = useRef(null);
+  const canvasRef = useRef(null);
+  const capturedSrcRef = useRef(null);
+  const resolved = useAttachmentUrl(attachment.id, attachment.url === void 0 ? resolveUrl : void 0);
+  const src = attachment.url ?? resolved.url ?? void 0;
+  const uploadedGif = attachment.mime?.toLowerCase() === "image/gif";
+  const captureStill = useCallback(
+    (image) => {
+      if (!uploadedGif || src === void 0 || capturedSrcRef.current === src) return;
+      const canvas = canvasRef.current;
+      const width = image.naturalWidth;
+      const height = image.naturalHeight;
+      if (canvas === null || width <= 0 || height <= 0) return;
+      canvas.width = width;
+      canvas.height = height;
+      const context = canvas.getContext("2d");
+      if (context === null) return;
+      context.drawImage(image, 0, 0, width, height);
+      capturedSrcRef.current = src;
+      setCapturedSrc(src);
+    },
+    [src, uploadedGif]
+  );
+  useEffect(() => {
+    if (!reduced) return;
+    setPlaying(false);
+    const image = imageRef.current;
+    if (image?.complete === true) captureStill(image);
+  }, [captureStill, reduced]);
+  const missing = broken || resolved.failed || src === void 0;
+  const pending = resolved.loading && !broken && !resolved.failed;
+  const interactive = onOpen !== void 0 && !missing;
+  const showStill = uploadedGif && reduced && !playing && !missing;
+  const body = pending ? null : missing ? /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: "flex h-full w-full items-center justify-center",
+      style: { color: "rgb(var(--text-tertiary))" },
+      children: /* @__PURE__ */ jsx(ImageOff, { size: 14, strokeWidth: 1.5, "aria-hidden": "true" })
+    }
+  ) : /* @__PURE__ */ jsxs("span", { className: "relative block h-full w-full", children: [
+    /* @__PURE__ */ jsx(
+      "img",
+      {
+        ref: imageRef,
+        src,
+        alt: attachment.name,
+        loading: "lazy",
+        className: "h-full w-full object-cover",
+        style: { visibility: showStill ? "hidden" : "visible" },
+        onLoad: (event) => {
+          captureStill(event.currentTarget);
+        },
+        onError: () => {
+          setBroken(true);
+        }
+      }
+    ),
+    uploadedGif ? /* @__PURE__ */ jsx(
+      "canvas",
+      {
+        ref: canvasRef,
+        "aria-hidden": "true",
+        hidden: !showStill || capturedSrc !== src,
+        className: "absolute inset-0 h-full w-full object-cover"
+      }
+    ) : null
+  ] });
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: cn(
+        "relative block overflow-hidden border",
+        "transition-[border-color] duration-[var(--dur-fast)] ease-[var(--ease-out)] motion-reduce:transition-none",
+        interactive && !showStill && "hover:border-[rgb(var(--border-strong))]",
+        (interactive || showStill) && "focus-within:outline-none focus-within:[box-shadow:var(--ring-focus)]",
+        className
+      ),
+      style: {
+        // Declared up front so the row cannot reflow when the bytes land.
+        aspectRatio: String(attachment.aspectRatio ?? 16 / 10),
+        borderRadius: "var(--thread-inner-radius, var(--radius-sm))",
+        borderColor: "rgb(var(--border))",
+        background: "rgb(var(--surface-inset))",
+        inlineSize: "calc(var(--space-12) * 3)",
+        minInlineSize: "calc(var(--space-12) * 3)"
+      },
+      children: [
+        interactive ? /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": `Open ${attachment.name}`,
+            "aria-hidden": showStill ? true : void 0,
+            disabled: showStill,
+            onClick: () => {
+              onOpen?.(attachment);
+            },
+            className: "block h-full w-full focus-visible:outline-none",
+            children: body
+          }
+        ) : body,
+        showStill ? /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": `Play ${attachment.name}`,
+            onClick: () => {
+              setPlaying(true);
+            },
+            className: "absolute inset-0 flex items-center justify-center focus-visible:outline-none",
+            style: { background: "rgb(var(--media-scrim-mid))", color: "rgb(var(--media-on-scrim))" },
+            children: /* @__PURE__ */ jsx(Play, { size: 20, strokeWidth: 1.75, "aria-hidden": "true" })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function AttachmentLightbox({ attachment, onClose, resolveUrl }) {
+  const closeRef = useRef(null);
+  const id = attachment?.id ?? "";
+  const { url, failed } = useAttachmentUrl(id, attachment === null ? void 0 : resolveUrl);
+  const surfaceRef = useRef(null);
+  useEffect(() => {
+    if (attachment === null) return;
+    closeRef.current?.focus();
+    const onKey = (event) => {
+      if (event.key === "Escape") {
+        onClose();
+        return;
+      }
+      if (event.key !== "Tab") return;
+      const root = surfaceRef.current;
+      if (root === null) return;
+      const focusable = Array.from(
+        root.querySelectorAll(
+          'a[href], button:not([disabled]), video[controls], [tabindex]:not([tabindex="-1"])'
+        )
+      );
+      if (focusable.length === 0) {
+        event.preventDefault();
+        return;
+      }
+      const first = focusable[0];
+      const last = focusable[focusable.length - 1];
+      const active = document.activeElement;
+      if (event.shiftKey && (active === first || !root.contains(active))) {
+        event.preventDefault();
+        last?.focus();
+      } else if (!event.shiftKey && (active === last || !root.contains(active))) {
+        event.preventDefault();
+        first?.focus();
+      }
+    };
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [attachment, onClose]);
+  if (attachment === null) return null;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": attachment.name,
+      className: "fixed inset-0 z-50 flex items-center justify-center p-[var(--space-6)]",
+      style: { background: "rgb(var(--media-scrim-strong))" },
+      onClick: onClose,
+      children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          ref: surfaceRef,
+          className: "relative flex max-h-full max-w-full items-center justify-center",
+          onClick: (event) => {
+            event.stopPropagation();
+          },
+          children: [
+            url === null || failed ? /* @__PURE__ */ jsx("p", { style: { color: "rgb(var(--media-on-scrim))" }, children: failed ? "This file isn't available." : "Loading\u2026" }) : attachment.kind === "gif" ? /* @__PURE__ */ jsx(
+              "video",
+              {
+                src: url,
+                controls: true,
+                loop: true,
+                muted: true,
+                playsInline: true,
+                "aria-label": attachment.name,
+                className: "max-h-full max-w-full"
+              }
+            ) : /* @__PURE__ */ jsx("img", { src: url, alt: attachment.name, className: "max-h-full max-w-full object-contain" }),
+            /* @__PURE__ */ jsx("span", { className: "absolute", style: { insetBlockStart: 0, insetInlineEnd: 0 }, children: /* @__PURE__ */ jsx(
+              "button",
+              {
+                ref: closeRef,
+                type: "button",
+                "aria-label": "Close",
+                className: QUIET_ICON,
+                style: { ...QUIET_ICON_BOX, color: "rgb(var(--media-on-scrim))" },
+                onClick: onClose,
+                children: /* @__PURE__ */ jsx(X, { size: 14, strokeWidth: 1.75, "aria-hidden": "true" })
+              }
+            ) })
+          ]
+        }
+      )
+    }
+  );
+}
+var ATTACHMENT_ACCEPT = ".png,.jpg,.jpeg,.webp,.gif,.pdf,.txt,.md,.csv,.json";
+var RichThreadComposerImpl = lazy(() => import('./rich-composer-impl-5NO443A6.js'));
+var RICH_FALLBACK_NOTICE = "Rich editor unavailable, plain editor loaded";
+function ComposerNotice({ children }) {
+  return /* @__PURE__ */ jsxs(
+    "p",
+    {
+      className: "flex items-center gap-[var(--space-1)] text-[12px]",
+      style: { color: "rgb(var(--text-tertiary))" },
+      children: [
+        /* @__PURE__ */ jsx(Info, { size: 12, strokeWidth: 1.75, "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx("span", { children })
+      ]
+    }
+  );
+}
+var ChunkBoundary = class extends Component {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(error, _info) {
+    this.props.onError(error);
+  }
+  render() {
+    return this.state.failed ? this.props.fallback : this.props.children;
+  }
+};
+function RichThreadComposer({
+  mentionItems,
+  uploadAttachment,
+  attachGif,
+  searchGifs,
+  attachmentAccept,
+  attachmentMaxPerComment,
+  attachmentMaxFileBytes,
+  attachmentMaxTotalBytes,
+  ...props
+}) {
+  const [failed, setFailed] = useState(false);
+  const [announcement, setAnnouncement] = useState({ text: "", seq: 0 });
+  const announce = useCallback((text) => {
+    setAnnouncement((prev) => ({ text, seq: prev.seq + 1 }));
+  }, []);
+  const onError = useCallback(
+    (error) => {
+      console.warn(
+        "rich composer: the editor chunk could not load; the plain composer is rendered instead",
+        error
+      );
+      setFailed(true);
+      announce(RICH_FALLBACK_NOTICE);
+    },
+    [announce]
+  );
+  const spoken = announcement.text === "" ? "" : announcement.seq % 2 === 0 ? `${announcement.text}\xA0` : announcement.text;
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-[var(--space-1)]", children: [
+    /* @__PURE__ */ jsx("div", { role: "status", "aria-live": "polite", "aria-atomic": "true", className: "sr-only", children: spoken }),
+    failed ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(ComposerNotice, { children: RICH_FALLBACK_NOTICE }),
+      /* @__PURE__ */ jsx(ThreadComposer, { ...props })
+    ] }) : /* @__PURE__ */ jsx(ChunkBoundary, { onError, fallback: /* @__PURE__ */ jsx(ThreadComposer, { ...props }), children: /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ThreadComposer, { ...props, disabled: true }), children: /* @__PURE__ */ jsx(
+      RichThreadComposerImpl,
+      {
+        ...props,
+        announce,
+        ...mentionItems === void 0 ? {} : { mentionItems },
+        ...uploadAttachment === void 0 ? {} : { uploadAttachment },
+        ...attachGif === void 0 ? {} : { attachGif },
+        ...searchGifs === void 0 ? {} : { searchGifs },
+        ...attachmentAccept === void 0 ? {} : { attachmentAccept },
+        ...attachmentMaxPerComment === void 0 ? {} : { attachmentMaxPerComment },
+        ...attachmentMaxFileBytes === void 0 ? {} : { attachmentMaxFileBytes },
+        ...attachmentMaxTotalBytes === void 0 ? {} : { attachmentMaxTotalBytes }
+      }
+    ) }) })
+  ] });
+}
+
+export { ATTACHMENT_ACCEPT, ATTACHMENT_LIMITS, AttachmentButton, AttachmentDropZone, AttachmentGif, AttachmentImage, AttachmentLightbox, AttachmentPlaceholder, AttachmentTray, Button, CodeBlock, CommentBody, ComposerFooter, ComposerNotice, GIF_SEARCH_DEBOUNCE_MS, GifPicker, Input, Kbd, MarkdownCode, MarkdownRenderer, PASTE_ATTACHMENT_THRESHOLD, POPOVER_SURFACE_STYLE, Popover, QUIET_ICON, QUIET_ICON_BOX, RichThreadComposer, ThreadComposer, __export, applyMarkdownFormat, cn, composeRefs, computeAnchoredPosition, formatAttachmentSize, handleTabTrap, parseMentionHref, pastedTextFilename, shouldAttachPaste, tabbablesWithin, useAnchoredPosition, useAttachmentUrl, useAttachments, useEscapeKey, useLayer, useOutsideClick, usePrefersReducedMotion };
+//# sourceMappingURL=chunk-RBYWGBQ2.js.map
+//# sourceMappingURL=chunk-RBYWGBQ2.js.map