@refraction-ui/react 0.16.1 → 0.17.0

package/dist/index.cjs

@@ -19423,8 +19423,8 @@ var init_Sender = __esm({
                     /* @min:%2elength */
                   ]);
                 },
-                beaconOnRetry: function(data, onComplete, canSend) {
-                  return _onBeaconRetry(data, onComplete, canSend);
+                beaconOnRetry: function(data, onComplete, canSend2) {
+                  return _onBeaconRetry(data, onComplete, canSend2);
                 }
               };
               var config = {
@@ -19884,7 +19884,7 @@ var init_Sender = __esm({
               return _doSend(beaconInst, payload, isAsync);
             }
           }
-          function _onBeaconRetry(payload, onComplete, canSend) {
+          function _onBeaconRetry(payload, onComplete, canSend2) {
             var internalPayload = payload;
             var data = internalPayload && internalPayload.oriPayload;
             if (!_disableBeaconSplit) {
@@ -19896,7 +19896,7 @@ var init_Sender = __esm({
                 var thePayload = data[lp];
                 var arr = [thePayload];
                 var item = _getPayload(arr);
-                if (!canSend(item, onComplete)) {
+                if (!canSend2(item, onComplete)) {
                   droppedPayload[
                     _DYN_PUSH2
                     /* @min:%2epush */
@@ -31204,14 +31204,14 @@ function createCalendar(props = {}) {
   const gridId = generateId("rfr-calendar");
   const labelId = generateId("rfr-calendar-label");
   function isDateDisabled(date) {
-    if (minDate && date < startOfDay2(minDate)) return true;
-    if (maxDate && date > endOfDay2(maxDate)) return true;
+    if (minDate && date < startOfDay(minDate)) return true;
+    if (maxDate && date > endOfDay(maxDate)) return true;
     return disabledDates.some((d2) => isSameDay(d2, date));
   }
-  function startOfDay2(date) {
+  function startOfDay(date) {
     return new Date(date.getFullYear(), date.getMonth(), date.getDate());
   }
-  function endOfDay2(date) {
+  function endOfDay(date) {
     return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
   }
   function buildDays() {
@@ -32755,6 +32755,1989 @@ var CommandSeparator = React11__namespace.forwardRef(
   }
 );
 CommandSeparator.displayName = "CommandSeparator";
+function detectTriggerInText(text, caret, triggerChar) {
+  if (triggerChar.length === 0) return null;
+  const before = text.slice(0, caret);
+  const idx = before.lastIndexOf(triggerChar);
+  if (idx === -1) return null;
+  if (idx > 0 && !/\s/.test(before[idx - 1])) return null;
+  const query = before.slice(idx + triggerChar.length);
+  if (/\s/.test(query)) return null;
+  return { triggered: true, query, start: idx };
+}
+var EMOJI_MAP = {
+  ":smile:": "\u{1F604}",
+  ":laugh:": "\u{1F602}",
+  ":joy:": "\u{1F602}",
+  ":grin:": "\u{1F601}",
+  ":wink:": "\u{1F609}",
+  ":blush:": "\u{1F60A}",
+  ":heart_eyes:": "\u{1F60D}",
+  ":kissing:": "\u{1F617}",
+  ":thinking:": "\u{1F914}",
+  ":neutral:": "\u{1F610}",
+  ":expressionless:": "\u{1F611}",
+  ":unamused:": "\u{1F612}",
+  ":sweat:": "\u{1F613}",
+  ":pensive:": "\u{1F614}",
+  ":confused:": "\u{1F615}",
+  ":disappointed:": "\u{1F61E}",
+  ":worried:": "\u{1F61F}",
+  ":angry:": "\u{1F620}",
+  ":rage:": "\u{1F621}",
+  ":cry:": "\u{1F622}",
+  ":sob:": "\u{1F62D}",
+  ":scream:": "\u{1F631}",
+  ":fearful:": "\u{1F628}",
+  ":cold_sweat:": "\u{1F630}",
+  ":relieved:": "\u{1F60C}",
+  ":sleepy:": "\u{1F62A}",
+  ":sleeping:": "\u{1F634}",
+  ":mask:": "\u{1F637}",
+  ":sunglasses:": "\u{1F60E}",
+  ":nerd:": "\u{1F913}",
+  ":heart:": "\u2764\uFE0F",
+  ":broken_heart:": "\u{1F494}",
+  ":sparkling_heart:": "\u{1F496}",
+  ":two_hearts:": "\u{1F495}",
+  ":fire:": "\u{1F525}",
+  ":100:": "\u{1F4AF}",
+  ":star:": "\u2B50",
+  ":star2:": "\u{1F31F}",
+  ":sparkles:": "\u2728",
+  ":thumbsup:": "\u{1F44D}",
+  ":thumbsdown:": "\u{1F44E}",
+  ":wave:": "\u{1F44B}",
+  ":clap:": "\u{1F44F}",
+  ":raised_hands:": "\u{1F64C}",
+  ":pray:": "\u{1F64F}",
+  ":muscle:": "\u{1F4AA}",
+  ":point_up:": "\u261D\uFE0F",
+  ":point_down:": "\u{1F447}",
+  ":point_left:": "\u{1F448}",
+  ":point_right:": "\u{1F449}",
+  ":ok_hand:": "\u{1F44C}",
+  ":v:": "\u270C\uFE0F",
+  ":eyes:": "\u{1F440}",
+  ":tongue:": "\u{1F445}",
+  ":lips:": "\u{1F444}",
+  ":rocket:": "\u{1F680}",
+  ":tada:": "\u{1F389}",
+  ":confetti:": "\u{1F38A}",
+  ":balloon:": "\u{1F388}",
+  ":gift:": "\u{1F381}",
+  ":trophy:": "\u{1F3C6}",
+  ":medal:": "\u{1F3C5}",
+  ":crown:": "\u{1F451}",
+  ":gem:": "\u{1F48E}",
+  ":bell:": "\u{1F514}",
+  ":check:": "\u2705",
+  ":x:": "\u274C",
+  ":warning:": "\u26A0\uFE0F",
+  ":no_entry:": "\u26D4",
+  ":question:": "\u2753",
+  ":exclamation:": "\u2757",
+  ":bulb:": "\u{1F4A1}",
+  ":book:": "\u{1F4D6}",
+  ":memo:": "\u{1F4DD}",
+  ":pencil:": "\u270F\uFE0F",
+  ":calendar:": "\u{1F4C5}",
+  ":clock:": "\u{1F550}",
+  ":hourglass:": "\u231B",
+  ":lock:": "\u{1F512}",
+  ":key:": "\u{1F511}",
+  ":hammer:": "\u{1F528}",
+  ":wrench:": "\u{1F527}",
+  ":link:": "\u{1F517}",
+  ":paperclip:": "\u{1F4CE}",
+  ":scissors:": "\u2702\uFE0F",
+  ":package:": "\u{1F4E6}",
+  ":email:": "\u{1F4E7}",
+  ":phone:": "\u{1F4DE}",
+  ":computer:": "\u{1F4BB}",
+  ":house:": "\u{1F3E0}",
+  ":tree:": "\u{1F333}",
+  ":sun:": "\u2600\uFE0F",
+  ":moon:": "\u{1F319}",
+  ":cloud:": "\u2601\uFE0F",
+  ":rain:": "\u{1F327}\uFE0F",
+  ":snow:": "\u2744\uFE0F",
+  ":zap:": "\u26A1",
+  ":rainbow:": "\u{1F308}",
+  ":pizza:": "\u{1F355}",
+  ":hamburger:": "\u{1F354}",
+  ":coffee:": "\u2615",
+  ":beer:": "\u{1F37A}",
+  ":wine:": "\u{1F377}",
+  ":cake:": "\u{1F370}",
+  ":dog:": "\u{1F436}",
+  ":cat:": "\u{1F431}",
+  ":poop:": "\u{1F4A9}",
+  ":ghost:": "\u{1F47B}",
+  ":skull:": "\u{1F480}",
+  ":alien:": "\u{1F47D}",
+  ":robot:": "\u{1F916}",
+  ":handshake:": "\u{1F91D}",
+  ":pray2:": "\u{1F64F}",
+  ":salute:": "\u{1FAE1}"
+};
+function detectEmojiShortcode(text) {
+  const match = text.match(/:([a-z0-9_]+):$/);
+  if (!match) return null;
+  const shortcode = `:${match[1]}:`;
+  const unicode = EMOJI_MAP[shortcode];
+  if (!unicode) return null;
+  return { shortcode, unicode };
+}
+
+// ../composer/dist/index.js
+function toMessageAttachment(attachment) {
+  return {
+    id: attachment.id,
+    name: attachment.name,
+    url: attachment.previewUrl ?? "",
+    type: attachment.mimeType ?? attachment.kind,
+    size: attachment.sizeBytes
+  };
+}
+var cachedSegmenter;
+function getSegmenter() {
+  if (cachedSegmenter === void 0) {
+    const IntlAny = typeof Intl !== "undefined" ? Intl : void 0;
+    const Segmenter = IntlAny?.Segmenter;
+    cachedSegmenter = Segmenter ? new Segmenter(void 0, { granularity: "grapheme" }) : null;
+  }
+  return cachedSegmenter;
+}
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(code) {
+  return code >= 56320 && code <= 57343;
+}
+function graphemeLength(text) {
+  if (text === "") return 0;
+  const segmenter = getSegmenter();
+  if (segmenter) {
+    let count2 = 0;
+    for (const _2 of segmenter.segment(text)) count2++;
+    return count2;
+  }
+  let count = 0;
+  for (const _2 of text) count++;
+  return count;
+}
+function clampGraphemes(text, max) {
+  if (max <= 0) return "";
+  const segmenter = getSegmenter();
+  if (segmenter) {
+    let count2 = 0;
+    let endIndex = text.length;
+    for (const part of segmenter.segment(text)) {
+      count2++;
+      if (count2 > max) {
+        endIndex = part.index;
+        break;
+      }
+    }
+    return text.slice(0, endIndex);
+  }
+  let count = 0;
+  let i2 = 0;
+  while (i2 < text.length && count < max) {
+    const code = text.charCodeAt(i2);
+    i2 += isHighSurrogate(code) && i2 + 1 < text.length && isLowSurrogate(text.charCodeAt(i2 + 1)) ? 2 : 1;
+    count++;
+  }
+  return text.slice(0, i2);
+}
+function payloadFor(raw) {
+  return raw.trim();
+}
+function canSend({ text, attachments = [], disabled = false, readOnly = false, busy = false }) {
+  if (disabled || readOnly || busy) return false;
+  return payloadFor(text).length > 0 || attachments.length > 0;
+}
+function shouldSubmitOnEnter({
+  shiftPressed,
+  isComposing
+}) {
+  return !shiftPressed && !isComposing;
+}
+var COUNTER_VISIBLE_FRACTION = 0.2;
+function computeCounter(text, maxLength) {
+  if (maxLength === void 0) {
+    return { visible: false, remaining: null, overLimit: false };
+  }
+  const remaining = maxLength - graphemeLength(text);
+  return {
+    visible: remaining <= maxLength * COUNTER_VISIBLE_FRACTION,
+    remaining,
+    overLimit: remaining <= 0
+  };
+}
+var DEFAULT_MAX_QUERY_LENGTH = 40;
+var DEFAULT_MAX_VISIBLE_RESULTS = 6;
+var SCAN_UNITS_PER_GRAPHEME = 16;
+function resolveTriggerConfig(trigger) {
+  const symbol = trigger.symbol;
+  return {
+    id: trigger.id,
+    symbol,
+    scope: trigger.scope ?? "anywhere",
+    queryPattern: trigger.queryPattern ?? null,
+    maxQueryLength: trigger.maxQueryLength ?? DEFAULT_MAX_QUERY_LENGTH,
+    closeOnSpace: trigger.closeOnSpace ?? true,
+    allowMidWord: trigger.allowMidWord ?? false,
+    extraBoundaryChars: trigger.extraBoundaryChars ?? [],
+    debounceMs: trigger.debounceMs ?? 0,
+    maxVisibleResults: trigger.maxVisibleResults ?? DEFAULT_MAX_VISIBLE_RESULTS,
+    wrapNavigation: trigger.wrapNavigation ?? true,
+    toDisplay: trigger.toDisplay ?? ((candidate) => `${symbol}${candidate.display}`),
+    resolve: trigger.resolve
+  };
+}
+function scanWindowFor(trigger) {
+  return trigger.maxQueryLength * SCAN_UNITS_PER_GRAPHEME + trigger.symbol.length;
+}
+function isWhitespace(ch) {
+  return /\s/.test(ch);
+}
+function boundaryOk(text, symbolStart, trigger) {
+  if (trigger.allowMidWord) return true;
+  if (symbolStart === 0) return true;
+  const prev = text[symbolStart - 1];
+  return isWhitespace(prev) || trigger.extraBoundaryChars.includes(prev);
+}
+function scopeOk(text, symbolStart, scope) {
+  if (scope === "anywhere") return true;
+  if (scope === "startOfMessage") return symbolStart === 0;
+  return symbolStart === 0 || text[symbolStart - 1] === "\n";
+}
+function findCandidate(text, caret, trigger) {
+  const window2 = scanWindowFor(trigger);
+  const isSimple = trigger.symbol.length === 1 && trigger.scope === "anywhere" && trigger.closeOnSpace && !trigger.allowMidWord && trigger.extraBoundaryChars.length === 0;
+  if (isSimple) {
+    const sliceStart2 = Math.max(0, caret - window2 - 1);
+    const slice = text.slice(sliceStart2, caret);
+    const hit = detectTriggerInText(slice, slice.length, trigger.symbol);
+    if (!hit) return null;
+    return { symbolStart: sliceStart2 + hit.start, query: hit.query };
+  }
+  const sliceStart = Math.max(0, caret - window2);
+  const rel = text.slice(sliceStart, caret).lastIndexOf(trigger.symbol);
+  if (rel === -1) return null;
+  const symbolStart = sliceStart + rel;
+  if (symbolStart + trigger.symbol.length > caret) return null;
+  return { symbolStart, query: text.slice(symbolStart + trigger.symbol.length, caret) };
+}
+function validateCandidate(text, caret, trigger, candidate, dismissed, tokenRanges) {
+  const { symbolStart, query } = candidate;
+  if (!boundaryOk(text, symbolStart, trigger)) return null;
+  if (!scopeOk(text, symbolStart, trigger.scope)) return null;
+  for (const range of tokenRanges) {
+    if (symbolStart >= range.start && symbolStart < range.end) return null;
+  }
+  if (dismissed.some((d2) => d2.triggerId === trigger.id && d2.symbolStart === symbolStart)) return null;
+  if (trigger.closeOnSpace && /\s/.test(query)) return null;
+  if (!trigger.closeOnSpace && query.includes("\n")) return null;
+  if (graphemeLength(query) > trigger.maxQueryLength) return null;
+  if (trigger.queryPattern && !trigger.queryPattern.test(query)) return null;
+  return { trigger, symbolStart, caret, query };
+}
+function detectActiveTrigger({
+  text,
+  caret,
+  triggers,
+  isComposing = false,
+  dismissed = [],
+  tokenRanges = []
+}) {
+  if (isComposing) return null;
+  let best = null;
+  for (const trigger of triggers) {
+    const candidate = findCandidate(text, caret, trigger);
+    if (!candidate) continue;
+    const match = validateCandidate(text, caret, trigger, candidate, dismissed, tokenRanges);
+    if (!match) continue;
+    if (!best || match.symbolStart > best.symbolStart || match.symbolStart === best.symbolStart && match.trigger.symbol.length > best.trigger.symbol.length) {
+      best = match;
+    }
+  }
+  return best;
+}
+var LOADING_DELAY_MS = 120;
+var DISMISS_GRACE_MS = 120;
+var CIRCUIT_BREAKER_THRESHOLD = 2;
+var CLOSED_SUGGESTION_STATE = {
+  isOpen: false,
+  items: [],
+  visibleItems: [],
+  activeIndex: 0,
+  loading: false,
+  error: null,
+  requestToken: 0
+};
+function createSuggestionController({ emit: emit2 }) {
+  let state = CLOSED_SUGGESTION_STATE;
+  let match = null;
+  let requestCounter = 0;
+  let debounceTimer = null;
+  let loadingTimer = null;
+  let dismissTimer = null;
+  const consecutiveFailures = /* @__PURE__ */ new Map();
+  const tripped = /* @__PURE__ */ new Set();
+  function clearTimer(timer) {
+    if (timer !== null) clearTimeout(timer);
+    return null;
+  }
+  function setState(patch) {
+    state = { ...state, ...patch };
+  }
+  function sameOccurrence(a2, b2) {
+    return a2 !== null && b2 !== null && a2.trigger.id === b2.trigger.id && a2.symbolStart === b2.symbolStart;
+  }
+  function closeInternal() {
+    debounceTimer = clearTimer(debounceTimer);
+    loadingTimer = clearTimer(loadingTimer);
+    requestCounter++;
+    match = null;
+    state = CLOSED_SUGGESTION_STATE;
+  }
+  function applyResults(forMatch, items) {
+    loadingTimer = clearTimer(loadingTimer);
+    consecutiveFailures.set(forMatch.trigger.id, 0);
+    setState({
+      isOpen: true,
+      items,
+      visibleItems: items.slice(0, forMatch.trigger.maxVisibleResults),
+      activeIndex: 0,
+      loading: false,
+      error: null
+    });
+  }
+  function applyFailure(forMatch, error) {
+    loadingTimer = clearTimer(loadingTimer);
+    const triggerId = forMatch.trigger.id;
+    const failures = (consecutiveFailures.get(triggerId) ?? 0) + 1;
+    consecutiveFailures.set(triggerId, failures);
+    if (failures >= CIRCUIT_BREAKER_THRESHOLD) {
+      tripped.add(triggerId);
+      closeInternal();
+      return;
+    }
+    setState({
+      isOpen: true,
+      items: [],
+      visibleItems: [],
+      loading: false,
+      error: error instanceof Error ? error.message : "Failed to load suggestions"
+    });
+  }
+  function dispatch(forMatch, notifySync) {
+    const token = ++requestCounter;
+    setState({ requestToken: token });
+    let result;
+    try {
+      result = forMatch.trigger.resolve(forMatch.query);
+    } catch (error) {
+      applyFailure(forMatch, error);
+      if (notifySync) emit2();
+      return;
+    }
+    if (Array.isArray(result)) {
+      applyResults(forMatch, result);
+      if (notifySync) emit2();
+      return;
+    }
+    loadingTimer = clearTimer(loadingTimer);
+    loadingTimer = setTimeout(() => {
+      if (token !== requestCounter) return;
+      setState({ isOpen: true, loading: true });
+      emit2();
+    }, LOADING_DELAY_MS);
+    result.then(
+      (items) => {
+        if (token !== requestCounter || !sameOccurrence(match, forMatch)) return;
+        applyResults(forMatch, items);
+        emit2();
+      },
+      (error) => {
+        if (token !== requestCounter || !sameOccurrence(match, forMatch)) return;
+        applyFailure(forMatch, error);
+        emit2();
+      }
+    );
+  }
+  function schedule(forMatch) {
+    debounceTimer = clearTimer(debounceTimer);
+    if (forMatch.trigger.debounceMs <= 0) {
+      dispatch(forMatch, false);
+      return;
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      if (sameOccurrence(match, forMatch) && match?.query === forMatch.query) {
+        dispatch(forMatch, true);
+      }
+    }, forMatch.trigger.debounceMs);
+  }
+  return {
+    get state() {
+      return state;
+    },
+    sync(next) {
+      if (next === null) {
+        if (match !== null || state.isOpen) closeInternal();
+        return;
+      }
+      if (tripped.has(next.trigger.id)) {
+        if (match !== null || state.isOpen) closeInternal();
+        return;
+      }
+      const isSame = sameOccurrence(match, next);
+      const queryChanged = !isSame || match?.query !== next.query;
+      match = next;
+      if (!isSame) {
+        state = { ...CLOSED_SUGGESTION_STATE, isOpen: true, requestToken: state.requestToken };
+      }
+      if (queryChanged) schedule(next);
+    },
+    moveNext() {
+      const count = state.items.length;
+      if (!state.isOpen || count === 0) return;
+      const wrap = match?.trigger.wrapNavigation ?? true;
+      const next = wrap ? (state.activeIndex + 1) % count : Math.min(state.activeIndex + 1, count - 1);
+      setState({ activeIndex: next });
+    },
+    movePrevious() {
+      const count = state.items.length;
+      if (!state.isOpen || count === 0) return;
+      const wrap = match?.trigger.wrapNavigation ?? true;
+      const previous = wrap ? (state.activeIndex - 1 + count) % count : Math.max(state.activeIndex - 1, 0);
+      setState({ activeIndex: previous });
+    },
+    setActiveIndex(index) {
+      if (!state.isOpen || state.items.length === 0) return;
+      setState({ activeIndex: Math.max(0, Math.min(index, state.items.length - 1)) });
+    },
+    retry() {
+      if (match === null) return;
+      if (tripped.has(match.trigger.id)) return;
+      setState({ error: null });
+      dispatch(match, false);
+    },
+    dismissDeferred(onClosed) {
+      dismissTimer = clearTimer(dismissTimer);
+      dismissTimer = setTimeout(() => {
+        dismissTimer = null;
+        closeInternal();
+        onClosed();
+      }, DISMISS_GRACE_MS);
+    },
+    cancelDeferredDismiss() {
+      dismissTimer = clearTimer(dismissTimer);
+    },
+    close() {
+      dismissTimer = clearTimer(dismissTimer);
+      closeInternal();
+    },
+    isTripped(triggerId) {
+      return tripped.has(triggerId);
+    },
+    destroy() {
+      debounceTimer = clearTimer(debounceTimer);
+      loadingTimer = clearTimer(loadingTimer);
+      dismissTimer = clearTimer(dismissTimer);
+      match = null;
+      state = CLOSED_SUGGESTION_STATE;
+    }
+  };
+}
+function diffEdit(oldText, newText) {
+  if (oldText === newText) return null;
+  const minLen = Math.min(oldText.length, newText.length);
+  let prefix = 0;
+  while (prefix < minLen && oldText[prefix] === newText[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < minLen - prefix && oldText[oldText.length - 1 - suffix] === newText[newText.length - 1 - suffix]) {
+    suffix++;
+  }
+  return { start: prefix, oldEnd: oldText.length - suffix, newEnd: newText.length - suffix };
+}
+function nearestBoundary(offset, token) {
+  return offset - token.start <= token.end - offset ? token.start : token.end;
+}
+function applyValueEdit({
+  oldValue,
+  newValue,
+  tokens,
+  newSelection,
+  maxLength
+}) {
+  const noChange = {
+    value: oldValue,
+    tokens: [...tokens],
+    selection: newSelection,
+    rejected: false,
+    trimmed: false,
+    removedTokens: [],
+    edit: null
+  };
+  const diff = diffEdit(oldValue, newValue);
+  if (!diff) return noChange;
+  const insertedRaw = newValue.slice(diff.start, diff.newEnd);
+  if (diff.oldEnd === diff.start) {
+    const host = tokens.find((t2) => t2.start < diff.start && diff.start < t2.end);
+    if (host) {
+      const caret2 = nearestBoundary(diff.start, host);
+      return { ...noChange, rejected: true, selection: { start: caret2, end: caret2 } };
+    }
+  }
+  let expStart = diff.start;
+  let expOldEnd = diff.oldEnd;
+  const removedTokens = [];
+  for (const token of tokens) {
+    const overlaps = token.start < expOldEnd && token.end > expStart;
+    if (!overlaps) continue;
+    removedTokens.push(token);
+    expStart = Math.min(expStart, token.start);
+    expOldEnd = Math.max(expOldEnd, token.end);
+  }
+  let inserted = insertedRaw;
+  let trimmed = false;
+  if (maxLength !== void 0 && inserted.length > 0) {
+    const baseLength = graphemeLength(oldValue.slice(0, expStart)) + graphemeLength(oldValue.slice(expOldEnd));
+    const budget = Math.max(0, maxLength - baseLength);
+    if (graphemeLength(inserted) > budget) {
+      inserted = clampGraphemes(inserted, budget);
+      trimmed = true;
+    }
+  }
+  const value = oldValue.slice(0, expStart) + inserted + oldValue.slice(expOldEnd);
+  const delta = expStart + inserted.length - expOldEnd;
+  const nextTokens = tokens.filter((t2) => !removedTokens.includes(t2)).map((t2) => t2.start >= expOldEnd ? { ...t2, start: t2.start + delta, end: t2.end + delta } : t2);
+  const appliedMatchesRaw = expStart === diff.start && expOldEnd === diff.oldEnd && !trimmed;
+  const caret = expStart + inserted.length;
+  const selection = appliedMatchesRaw ? newSelection : { start: caret, end: caret };
+  return {
+    value,
+    tokens: nextTokens,
+    selection: clampSelectionToValue(selection, value),
+    rejected: false,
+    trimmed,
+    removedTokens,
+    edit: { start: expStart, oldEnd: expOldEnd, newEnd: expStart + inserted.length }
+  };
+}
+function clampSelectionToValue(selection, value) {
+  const clamp3 = (n2) => Math.max(0, Math.min(n2, value.length));
+  return { start: clamp3(selection.start), end: clamp3(selection.end) };
+}
+function snapSelectionToTokens(tokens, selection, previous) {
+  const inside = (offset) => tokens.find((t2) => t2.start < offset && offset < t2.end);
+  if (selection.start === selection.end) {
+    const host = inside(selection.start);
+    if (!host) return selection;
+    let caret;
+    if (previous && previous.start === previous.end && previous.start !== selection.start) {
+      caret = selection.start > previous.start ? host.end : host.start;
+    } else {
+      caret = nearestBoundary(selection.start, host);
+    }
+    return { start: caret, end: caret };
+  }
+  const startHost = inside(selection.start);
+  const endHost = inside(selection.end);
+  return {
+    start: startHost ? startHost.start : selection.start,
+    end: endHost ? endHost.end : selection.end
+  };
+}
+function expandRangeOverTokens(tokens, range) {
+  let { start, end } = range;
+  for (const token of tokens) {
+    if (token.start < end && token.end > start) {
+      start = Math.min(start, token.start);
+      end = Math.max(end, token.end);
+    }
+  }
+  return { start, end };
+}
+function commitTokenAt({ value, tokens, start, end, token }) {
+  const display = token.display;
+  const nextValue = value.slice(0, start) + display + value.slice(end);
+  const delta = display.length - (end - start);
+  const placed = { ...token, start, end: start + display.length };
+  const shifted = tokens.map(
+    (t2) => t2.start >= end ? { ...t2, start: t2.start + delta, end: t2.end + delta } : t2
+  );
+  const nextTokens = [...shifted, placed].sort((a2, b2) => a2.start - b2.start);
+  const caret = placed.end;
+  return { value: nextValue, tokens: nextTokens, selection: { start: caret, end: caret } };
+}
+function serializeTokens(value, tokens) {
+  const resolved = tokens.map((t2) => ({
+    type: t2.triggerId,
+    id: t2.id,
+    display: t2.display,
+    start: t2.start,
+    end: t2.end
+  }));
+  return { plainText: value, tokens: resolved };
+}
+function detectTypedEmoji(value, caret) {
+  const hit = detectEmojiShortcode(value.slice(0, caret));
+  if (!hit) return null;
+  return { shortcode: hit.shortcode, unicode: hit.unicode, start: caret - hit.shortcode.length };
+}
+var DEFAULT_DRAFT_DEBOUNCE_MS = 400;
+var DEFAULT_TYPING_SIGNAL_INTERVAL_MS = 3e3;
+function validateDraft(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const draft = raw;
+  if (typeof draft.value !== "string") return null;
+  if (!Array.isArray(draft.tokens)) return null;
+  if (!Array.isArray(draft.attachmentIds)) return null;
+  for (const token of draft.tokens) {
+    if (typeof token !== "object" || token === null || typeof token.start !== "number" || typeof token.end !== "number" || typeof token.display !== "string" || // The one invariant that matters: ranges must project the display.
+    draft.value.substring(token.start, token.end) !== token.display) {
+      return null;
+    }
+  }
+  return {
+    value: draft.value,
+    tokens: draft.tokens,
+    attachmentIds: draft.attachmentIds,
+    updatedAt: typeof draft.updatedAt === "number" ? draft.updatedAt : 0
+  };
+}
+function createComposer(config = {}) {
+  const now = config.now ?? (() => Date.now());
+  const generateId$1 = config.generateId ?? generateId;
+  const onEvent = config.onEvent ?? (() => void 0);
+  const triggers = (config.triggers ?? []).map(resolveTriggerConfig);
+  const draftDebounceMs = config.draftDebounceMs ?? DEFAULT_DRAFT_DEBOUNCE_MS;
+  const typingSignalIntervalMs = config.typingSignalIntervalMs ?? DEFAULT_TYPING_SIGNAL_INTERVAL_MS;
+  const emojiTrigger = triggers.find((t2) => t2.symbol === ":") ?? null;
+  let value = config.initialValue ?? "";
+  let tokens = [...config.initialTokens ?? []];
+  let selection = { start: value.length, end: value.length };
+  let isComposing = false;
+  let isBusy = false;
+  let disabled = false;
+  let readOnly = false;
+  let error = null;
+  let attachments = [];
+  let mode = "compose";
+  let editingMessageId;
+  let preEditSnapshot = null;
+  let activeMatch = null;
+  let dismissed = [];
+  let clipShadow = null;
+  let lastTypingAt = Number.NEGATIVE_INFINITY;
+  let draftTimer = null;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  if (config.draftStore && config.draftKey) {
+    try {
+      const draft = validateDraft(config.draftStore.read(config.draftKey));
+      if (draft) {
+        value = draft.value;
+        tokens = draft.tokens;
+        selection = { start: value.length, end: value.length };
+      }
+    } catch {
+    }
+  }
+  const suggestions = createSuggestionController({ emit: () => emit2() });
+  function toActiveTriggerState(match) {
+    if (!match) return null;
+    return {
+      triggerId: match.trigger.id,
+      symbol: match.trigger.symbol,
+      symbolStart: match.symbolStart,
+      caret: match.caret,
+      query: match.query
+    };
+  }
+  function buildState() {
+    const counter = computeCounter(value, config.maxLength);
+    const overBudget = counter.remaining !== null && counter.remaining < 0;
+    return {
+      value,
+      selection,
+      isComposing,
+      isBusy,
+      disabled,
+      readOnly,
+      isEmpty: payloadFor(value).length === 0 && attachments.length === 0,
+      canSend: canSend({ text: value, attachments, disabled, readOnly, busy: isBusy }) && !overBudget,
+      error,
+      attachments: [...attachments],
+      tokens: [...tokens],
+      activeTrigger: toActiveTriggerState(activeMatch),
+      suggestion: destroyed ? CLOSED_SUGGESTION_STATE : suggestions.state,
+      counter,
+      mode,
+      editingMessageId
+    };
+  }
+  function emit2() {
+    if (destroyed) return;
+    const snapshot = buildState();
+    for (const listener of listeners) listener(snapshot);
+  }
+  function shiftDismissedForEdit(editStart, editOldEnd, delta) {
+    dismissed = dismissed.map((d2) => d2.symbolStart >= editOldEnd ? { ...d2, symbolStart: d2.symbolStart + delta } : d2).filter((d2) => {
+      if (d2.symbolStart >= editStart && d2.symbolStart < editOldEnd) return false;
+      const trigger = triggers.find((t2) => t2.id === d2.triggerId);
+      return trigger !== void 0 && value.startsWith(trigger.symbol, d2.symbolStart);
+    });
+  }
+  function recomputeTriggers() {
+    const collapsed = selection.start === selection.end;
+    activeMatch = collapsed && !isComposing && !disabled && !readOnly ? detectActiveTrigger({
+      text: value,
+      caret: selection.start,
+      triggers,
+      isComposing,
+      dismissed,
+      tokenRanges: tokens
+    }) : null;
+    suggestions.sync(activeMatch);
+  }
+  function fireTypingSignal() {
+    const at2 = now();
+    if (at2 - lastTypingAt >= typingSignalIntervalMs) {
+      lastTypingAt = at2;
+      onEvent({ type: "typing" });
+    }
+  }
+  function scheduleDraftWrite() {
+    if (!config.draftStore || !config.draftKey) return;
+    if (draftTimer !== null) clearTimeout(draftTimer);
+    draftTimer = setTimeout(() => {
+      draftTimer = null;
+      if (isComposing || destroyed) return;
+      config.draftStore?.write(config.draftKey, {
+        value,
+        tokens: [...tokens],
+        attachmentIds: attachments.map((a2) => a2.id),
+        updatedAt: now()
+      });
+    }, draftDebounceMs);
+  }
+  function cancelDraftWrite() {
+    if (draftTimer !== null) {
+      clearTimeout(draftTimer);
+      draftTimer = null;
+    }
+  }
+  function clearPersistedDraft() {
+    cancelDraftWrite();
+    if (config.draftStore && config.draftKey) config.draftStore.clear(config.draftKey);
+  }
+  function maybeCommitTypedEmoji() {
+    if (!emojiTrigger || selection.start !== selection.end) return;
+    const caretBefore = selection.start;
+    const hit = detectTypedEmoji(value, caretBefore);
+    if (!hit) return;
+    if (tokens.some((t2) => t2.start < caretBefore && hit.start < t2.end)) return;
+    const token = {
+      triggerId: emojiTrigger.id,
+      symbol: emojiTrigger.symbol,
+      id: hit.shortcode,
+      label: hit.shortcode.slice(1, -1),
+      display: hit.unicode
+    };
+    const committed = commitTokenAt({
+      value,
+      tokens,
+      start: hit.start,
+      end: caretBefore,
+      token
+    });
+    const delta = committed.value.length - value.length;
+    value = committed.value;
+    tokens = committed.tokens;
+    selection = committed.selection;
+    shiftDismissedForEdit(hit.start, caretBefore, delta);
+  }
+  function mutateValue(newText, newSelection, opts = {}) {
+    const previousSelection = selection;
+    if (isComposing) {
+      const result2 = applyValueEdit({ oldValue: value, newValue: newText, tokens, newSelection });
+      value = result2.value;
+      tokens = result2.tokens;
+      selection = result2.selection;
+      emit2();
+      return { applied: true, editStart: result2.edit?.start ?? newSelection.start };
+    }
+    const result = applyValueEdit({
+      oldValue: value,
+      newValue: newText,
+      tokens,
+      newSelection,
+      maxLength: config.maxLength
+    });
+    if (result.rejected) {
+      onEvent({ type: "edit-rejected", reason: "inside-token" });
+      selection = result.selection;
+      recomputeTriggers();
+      emit2();
+      return { applied: false, editStart: 0 };
+    }
+    if (result.trimmed && opts.trimEventOnClamp !== false) {
+      onEvent({ type: "paste-trimmed" });
+    }
+    const editStart = result.edit?.start ?? newSelection.start;
+    value = result.value;
+    tokens = result.tokens;
+    selection = snapSelectionToTokens(tokens, result.selection, previousSelection);
+    if (result.edit) {
+      shiftDismissedForEdit(
+        result.edit.start,
+        result.edit.oldEnd,
+        result.edit.newEnd - result.edit.oldEnd
+      );
+    }
+    maybeCommitTypedEmoji();
+    recomputeTriggers();
+    if (!opts.programmatic) fireTypingSignal();
+    scheduleDraftWrite();
+    emit2();
+    return { applied: true, editStart };
+  }
+  function buildSubmissionTokens() {
+    const plainText = payloadFor(value);
+    const leading = value.length - value.trimStart().length;
+    const serialized = serializeTokens(value, tokens);
+    return {
+      plainText,
+      tokens: serialized.tokens.map((t2) => ({ ...t2, start: t2.start - leading, end: t2.end - leading }))
+    };
+  }
+  function commitSuggestion(index) {
+    const match = activeMatch;
+    const menu = suggestions.state;
+    if (!match || !menu.isOpen) return false;
+    const item = menu.items[index ?? menu.activeIndex];
+    if (!item) return false;
+    const display = match.trigger.toDisplay(item);
+    if (config.maxLength !== void 0) {
+      const replacedSpan = value.slice(match.symbolStart, match.caret);
+      const nextLength = graphemeLength(value) - graphemeLength(replacedSpan) + graphemeLength(display);
+      if (nextLength > config.maxLength) {
+        onEvent({ type: "insert-rejected", reason: "max-length" });
+        emit2();
+        return false;
+      }
+    }
+    const token = {
+      triggerId: match.trigger.id,
+      symbol: match.trigger.symbol,
+      id: item.id,
+      label: item.display,
+      display,
+      metadata: item.metadata
+    };
+    const committed = commitTokenAt({
+      value,
+      tokens,
+      start: match.symbolStart,
+      end: match.caret,
+      token
+    });
+    const delta = committed.value.length - value.length;
+    value = committed.value;
+    tokens = committed.tokens;
+    selection = committed.selection;
+    shiftDismissedForEdit(match.symbolStart, match.caret, delta);
+    suggestions.cancelDeferredDismiss();
+    activeMatch = null;
+    suggestions.sync(null);
+    scheduleDraftWrite();
+    emit2();
+    return true;
+  }
+  function performSubmit() {
+    const counter = computeCounter(value, config.maxLength);
+    const overBudget = counter.remaining !== null && counter.remaining < 0;
+    if (!canSend({ text: value, attachments, disabled, readOnly, busy: isBusy }) || overBudget) {
+      return null;
+    }
+    const { plainText, tokens: submissionTokens } = buildSubmissionTokens();
+    if (config.validator) {
+      const verdict = config.validator(plainText, submissionTokens);
+      if (!verdict.isValid) {
+        error = verdict.reason ?? "Message failed validation";
+        emit2();
+        return null;
+      }
+    }
+    const submission = {
+      plainText,
+      tokens: submissionTokens,
+      attachments: [...attachments],
+      replyToMessageId: config.replyToMessageId,
+      ...mode === "edit" ? { editingMessageId } : {}
+    };
+    value = "";
+    tokens = [];
+    attachments = [];
+    selection = { start: 0, end: 0 };
+    error = null;
+    activeMatch = null;
+    dismissed = [];
+    clipShadow = null;
+    mode = "compose";
+    editingMessageId = void 0;
+    preEditSnapshot = null;
+    suggestions.close();
+    clearPersistedDraft();
+    emit2();
+    return submission;
+  }
+  const api = {
+    getState() {
+      return buildState();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    setValue(text, sel, opts) {
+      if (destroyed || disabled) return;
+      if (readOnly) {
+        if (text === value && sel) api.setSelection(sel);
+        return;
+      }
+      const nextSelection = sel ?? { start: text.length, end: text.length };
+      mutateValue(text, nextSelection, { programmatic: opts?.programmatic });
+    },
+    setSelection(sel) {
+      if (destroyed || disabled) return;
+      const previous = selection;
+      selection = snapSelectionToTokens(tokens, {
+        start: Math.max(0, Math.min(sel.start, value.length)),
+        end: Math.max(0, Math.min(sel.end, value.length))
+      }, previous);
+      recomputeTriggers();
+      emit2();
+    },
+    insertTextAtCursor(text) {
+      if (destroyed) return;
+      if (disabled) {
+        onEvent({ type: "insert-rejected", reason: "disabled" });
+        return;
+      }
+      if (readOnly) {
+        onEvent({ type: "insert-rejected", reason: "read-only" });
+        return;
+      }
+      if (isComposing) {
+        onEvent({ type: "insert-rejected", reason: "composing" });
+        return;
+      }
+      if (config.maxLength !== void 0) {
+        const range = expandRangeOverTokens(tokens, selection);
+        const base = graphemeLength(value.slice(0, range.start)) + graphemeLength(value.slice(range.end));
+        if (base + graphemeLength(text) > config.maxLength) {
+          onEvent({ type: "insert-rejected", reason: "max-length" });
+          return;
+        }
+      }
+      const nextText = value.slice(0, selection.start) + text + value.slice(selection.end);
+      const caret = selection.start + text.length;
+      mutateValue(nextText, { start: caret, end: caret });
+    },
+    setComposing(composing) {
+      if (destroyed || isComposing === composing) return;
+      isComposing = composing;
+      if (!composing) {
+        if (config.maxLength !== void 0 && graphemeLength(value) > config.maxLength) {
+          value = clampGraphemes(value, config.maxLength);
+          tokens = tokens.filter((t2) => t2.end <= value.length);
+          selection = {
+            start: Math.min(selection.start, value.length),
+            end: Math.min(selection.end, value.length)
+          };
+        }
+        maybeCommitTypedEmoji();
+        recomputeTriggers();
+        scheduleDraftWrite();
+      } else {
+        activeMatch = null;
+        suggestions.sync(null);
+      }
+      emit2();
+    },
+    applyEnter({ shiftPressed }) {
+      if (destroyed || disabled || readOnly) return "noop";
+      const menu = suggestions.state;
+      if (menu.isOpen && !isComposing) {
+        if (menu.items.length > 0) {
+          return commitSuggestion() ? "committed-suggestion" : "noop";
+        }
+        return "noop";
+      }
+      if (!shouldSubmitOnEnter({ shiftPressed, isComposing })) {
+        return isComposing ? "noop" : "newline";
+      }
+      return performSubmit() ? "submitted" : "noop";
+    },
+    moveSuggestionNext() {
+      suggestions.moveNext();
+      emit2();
+    },
+    moveSuggestionPrevious() {
+      suggestions.movePrevious();
+      emit2();
+    },
+    setSuggestionActiveIndex(index) {
+      suggestions.setActiveIndex(index);
+      emit2();
+    },
+    applySuggestion(index) {
+      commitSuggestion(index);
+    },
+    dismissSuggestion() {
+      if (activeMatch) {
+        dismissed.push({ triggerId: activeMatch.trigger.id, symbolStart: activeMatch.symbolStart });
+        activeMatch = null;
+      }
+      suggestions.close();
+      emit2();
+    },
+    dismissSuggestionDeferred() {
+      suggestions.dismissDeferred(() => {
+        activeMatch = null;
+        emit2();
+      });
+    },
+    retrySuggestions() {
+      suggestions.retry();
+      emit2();
+    },
+    addAttachment(draft) {
+      if (destroyed) return null;
+      if (config.maxAttachments !== void 0 && attachments.length >= config.maxAttachments) {
+        onEvent({ type: "attachment-rejected", reason: "max-attachments", name: draft.name });
+        return null;
+      }
+      if (config.maxAttachmentSizeBytes !== void 0 && draft.sizeBytes !== void 0 && draft.sizeBytes > config.maxAttachmentSizeBytes) {
+        onEvent({ type: "attachment-rejected", reason: "max-size", name: draft.name });
+        return null;
+      }
+      if (config.acceptAttachment) {
+        const verdict = config.acceptAttachment(draft);
+        if (verdict !== true) {
+          onEvent({
+            type: "attachment-rejected",
+            reason: "not-accepted",
+            name: draft.name,
+            ...typeof verdict === "string" ? { detail: verdict } : {}
+          });
+          return null;
+        }
+      }
+      const id = draft.id ?? generateId$1("rfr-attachment");
+      attachments = [...attachments, { ...draft, id, status: draft.status ?? "pending" }];
+      scheduleDraftWrite();
+      emit2();
+      return id;
+    },
+    updateAttachment(id, patch) {
+      if (destroyed) return;
+      attachments = attachments.map((a2) => a2.id === id ? { ...a2, ...patch, id } : a2);
+      emit2();
+    },
+    removeAttachment(id) {
+      if (destroyed) return;
+      attachments = attachments.filter((a2) => a2.id !== id);
+      scheduleDraftWrite();
+      emit2();
+    },
+    setBusy(busy) {
+      if (destroyed || isBusy === busy) return;
+      isBusy = busy;
+      emit2();
+    },
+    setError(nextError) {
+      if (destroyed) return;
+      error = nextError;
+      emit2();
+    },
+    setDisabled(nextDisabled) {
+      if (destroyed || disabled === nextDisabled) return;
+      disabled = nextDisabled;
+      if (disabled) {
+        activeMatch = null;
+        suggestions.close();
+      }
+      emit2();
+    },
+    setReadOnly(nextReadOnly) {
+      if (destroyed || readOnly === nextReadOnly) return;
+      readOnly = nextReadOnly;
+      if (readOnly) {
+        activeMatch = null;
+        suggestions.close();
+      }
+      emit2();
+    },
+    beginEdit({ value: editValue, tokens: editTokens, messageId }) {
+      if (destroyed || disabled) return;
+      preEditSnapshot = { value, tokens: [...tokens], selection, attachments: [...attachments] };
+      mode = "edit";
+      editingMessageId = messageId;
+      value = editValue;
+      tokens = [...editTokens ?? []];
+      selection = { start: value.length, end: value.length };
+      activeMatch = null;
+      dismissed = [];
+      suggestions.close();
+      emit2();
+    },
+    cancelEdit() {
+      if (destroyed || mode !== "edit") return;
+      const snapshot = preEditSnapshot;
+      mode = "compose";
+      editingMessageId = void 0;
+      preEditSnapshot = null;
+      if (snapshot) {
+        value = snapshot.value;
+        tokens = snapshot.tokens;
+        selection = snapshot.selection;
+        attachments = snapshot.attachments;
+      }
+      activeMatch = null;
+      suggestions.close();
+      emit2();
+    },
+    copySelection() {
+      return value.slice(selection.start, selection.end);
+    },
+    cutSelection() {
+      if (destroyed || disabled || readOnly) return "";
+      if (selection.start === selection.end) return "";
+      const range = expandRangeOverTokens(tokens, selection);
+      const text = value.slice(range.start, range.end);
+      clipShadow = {
+        text,
+        tokens: tokens.filter((t2) => t2.start >= range.start && t2.end <= range.end).map((t2) => ({ ...t2, start: t2.start - range.start, end: t2.end - range.start }))
+      };
+      const nextText = value.slice(0, range.start) + value.slice(range.end);
+      mutateValue(nextText, { start: range.start, end: range.start });
+      return text;
+    },
+    pasteText(text) {
+      if (destroyed || disabled || readOnly) return;
+      const shadow = clipShadow;
+      const range = expandRangeOverTokens(tokens, selection);
+      const nextText = value.slice(0, range.start) + text + value.slice(range.end);
+      const caret = range.start + text.length;
+      const before = value;
+      mutateValue(nextText, { start: caret, end: caret }, { trimEventOnClamp: true });
+      if (shadow && text === shadow.text && value === before.slice(0, range.start) + text + before.slice(range.end)) {
+        const restored = shadow.tokens.map((t2) => ({
+          ...t2,
+          start: t2.start + range.start,
+          end: t2.end + range.start
+        }));
+        tokens = [...tokens, ...restored].sort((a2, b2) => a2.start - b2.start);
+        emit2();
+      }
+    },
+    submit() {
+      if (destroyed) return null;
+      return performSubmit();
+    },
+    reset() {
+      if (destroyed) return;
+      cancelDraftWrite();
+      suggestions.close();
+      value = config.initialValue ?? "";
+      tokens = [...config.initialTokens ?? []];
+      selection = { start: value.length, end: value.length };
+      isComposing = false;
+      isBusy = false;
+      error = null;
+      attachments = [];
+      mode = "compose";
+      editingMessageId = void 0;
+      preEditSnapshot = null;
+      activeMatch = null;
+      dismissed = [];
+      clipShadow = null;
+      lastTypingAt = Number.NEGATIVE_INFINITY;
+      recomputeTriggers();
+      emit2();
+    },
+    serialize() {
+      return serializeTokens(value, tokens);
+    },
+    destroy() {
+      if (destroyed) return;
+      cancelDraftWrite();
+      suggestions.destroy();
+      listeners.clear();
+      destroyed = true;
+    }
+  };
+  return api;
+}
+var composerSurfaceVariants = cva({
+  base: [
+    "overflow-hidden rounded-2xl border border-border bg-background shadow-sm",
+    "transition-shadow focus-within:border-foreground/25 focus-within:shadow-md"
+  ].join(" "),
+  variants: {
+    disabled: {
+      true: "pointer-events-none opacity-60",
+      false: ""
+    },
+    error: {
+      true: "border-destructive/50",
+      false: ""
+    }
+  },
+  defaultVariants: {
+    disabled: "false",
+    error: "false"
+  }
+});
+var composerFieldClass = "block w-full resize-none bg-transparent px-3.5 py-3 text-sm placeholder:text-muted-foreground focus:outline-none";
+var composerTrayClass = "flex flex-wrap gap-2 px-3 pt-3";
+var composerAttachmentChipVariants = cva({
+  base: "inline-flex items-center gap-1 rounded-md bg-muted px-2 py-0.5 text-xs",
+  variants: {
+    status: {
+      pending: "opacity-70",
+      uploading: "opacity-70",
+      ready: "",
+      error: "text-destructive"
+    }
+  },
+  defaultVariants: {
+    status: "pending"
+  }
+});
+var composerTokenPillClass = "rounded bg-accent/40 px-0.5 text-accent-foreground";
+var composerMenuClass = "z-20 w-72 overflow-hidden rounded-xl border border-border bg-popover shadow-lg";
+var composerMenuItemVariants = cva({
+  base: "flex w-full items-center gap-2 px-3 py-2 text-left text-sm",
+  variants: {
+    active: {
+      true: "bg-accent",
+      false: "hover:bg-accent/50"
+    }
+  },
+  defaultVariants: {
+    active: "false"
+  }
+});
+var composerCounterVariants = cva({
+  base: "text-xs tabular-nums",
+  variants: {
+    overLimit: {
+      true: "font-medium text-destructive",
+      false: "text-muted-foreground"
+    }
+  },
+  defaultVariants: {
+    overLimit: "false"
+  }
+});
+var composerPrimaryActionVariants = cva({
+  base: "flex h-9 w-9 items-center justify-center rounded-full transition",
+  variants: {
+    enabled: {
+      true: "bg-primary text-primary-foreground hover:opacity-90",
+      false: "bg-muted text-muted-foreground"
+    }
+  },
+  defaultVariants: {
+    enabled: "false"
+  }
+});
+function useComposer(config = {}, init) {
+  const configRef = React11__namespace.useRef(config);
+  const initRef = React11__namespace.useRef(init);
+  const coreRef = React11__namespace.useRef(null);
+  const getCore = React11__namespace.useCallback(() => {
+    if (coreRef.current === null) {
+      const api = createComposer(configRef.current);
+      initRef.current?.(api);
+      coreRef.current = { api, snapshot: api.getState() };
+    }
+    return coreRef.current;
+  }, []);
+  const subscribe = React11__namespace.useCallback(
+    (onStoreChange) => {
+      const core = getCore();
+      return core.api.subscribe((next) => {
+        core.snapshot = next;
+        onStoreChange();
+      });
+    },
+    [getCore]
+  );
+  const getSnapshot = React11__namespace.useCallback(() => getCore().snapshot, [getCore]);
+  const state = React11__namespace.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  React11__namespace.useEffect(
+    () => () => {
+      coreRef.current?.api.destroy();
+      coreRef.current = null;
+    },
+    []
+  );
+  return { state, api: getCore().api };
+}
+var FIELD_LINE_HEIGHT = 1.5;
+var FIELD_VERTICAL_PADDING_REM = 1.5;
+var TRIMMED_NOTICE_HIDE_MS = 4e3;
+function fieldHeightFor(lines) {
+  return `calc(${lines * FIELD_LINE_HEIGHT}em + ${FIELD_VERTICAL_PADDING_REM}rem)`;
+}
+var DEFAULT_COMPOSER_STRINGS = {
+  composerLabel: "Message composer",
+  messageLabel: "Message",
+  sendLabel: "Send",
+  stopLabel: "Stop",
+  attachLabel: "Attach a file",
+  removeAttachmentLabel: (name) => `Remove attachment ${name}`,
+  suggestionsLabel: "Suggestions",
+  noMatchesLabel: (query) => `No matches for "${query}"`,
+  loadingLabel: "Loading suggestions\u2026",
+  retryLabel: "Retry",
+  trimmedNotice: "Pasted text was trimmed to fit the length limit",
+  counterLabel: (remaining) => `${remaining} characters remaining`,
+  editingLabel: "Editing message",
+  cancelEditLabel: "Cancel edit",
+  resultsAnnouncement: (count) => `${count} suggestions available`
+};
+function useLatestRef(value) {
+  const ref = React11__namespace.useRef(value);
+  ref.current = value;
+  return ref;
+}
+function kindFromMime(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("video/")) return "video";
+  if (mimeType.startsWith("audio/")) return "audio";
+  return "file";
+}
+function segmentValue(value, tokens) {
+  const segments = [];
+  let cursor = 0;
+  for (const token of tokens) {
+    if (token.start > cursor) {
+      segments.push({ key: `p${cursor}`, text: value.slice(cursor, token.start), isToken: false });
+    }
+    segments.push({ key: `t${token.start}`, text: value.slice(token.start, token.end), isToken: true });
+    cursor = token.end;
+  }
+  if (cursor < value.length) {
+    segments.push({ key: `p${cursor}`, text: value.slice(cursor), isToken: false });
+  }
+  return segments;
+}
+var iconSvgProps = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24",
+  width: 16,
+  height: 16,
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round",
+  "aria-hidden": true
+};
+function IconArrowUp() {
+  return /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...iconSvgProps, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 19V5" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m5 12 7-7 7 7" })
+  ] });
+}
+function IconStop() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { ...iconSvgProps, children: /* @__PURE__ */ jsxRuntime.jsx("rect", { x: 7, y: 7, width: 10, height: 10, rx: 1.5 }) });
+}
+var RefractionComposer = React11__namespace.forwardRef(
+  ({
+    value: valueProp,
+    defaultValue,
+    onChange,
+    placeholder,
+    disabledPlaceholder,
+    minLines = 1,
+    maxLines = 6,
+    maxLength,
+    maxAttachments,
+    disabled = false,
+    readOnly = false,
+    busy = false,
+    onStop,
+    autoFocus,
+    dir,
+    triggers,
+    submitOnEnter,
+    strings: stringsProp,
+    leading,
+    trailing,
+    primaryAction,
+    renderSuggestion,
+    initialAttachments,
+    draftStore,
+    draftKey,
+    validator,
+    replyToMessageId,
+    onSubmit,
+    onEditLastRequested,
+    onEditCancel,
+    onTypingActivity,
+    onAttachmentAdd,
+    onAttachmentRejected,
+    onEvent,
+    apiRef,
+    id,
+    className,
+    ...rest
+  }, forwardedRef) => {
+    const strings = React11__namespace.useMemo(
+      () => ({ ...DEFAULT_COMPOSER_STRINGS, ...stringsProp }),
+      [stringsProp]
+    );
+    const onSubmitRef = useLatestRef(onSubmit);
+    const onChangeRef = useLatestRef(onChange);
+    const onStopRef = useLatestRef(onStop);
+    const onEventRef = useLatestRef(onEvent);
+    const onTypingActivityRef = useLatestRef(onTypingActivity);
+    const onAttachmentAddRef = useLatestRef(onAttachmentAdd);
+    const onAttachmentRejectedRef = useLatestRef(onAttachmentRejected);
+    const onEditLastRequestedRef = useLatestRef(onEditLastRequested);
+    const onEditCancelRef = useLatestRef(onEditCancel);
+    const [trimmedNoticeVisible, setTrimmedNoticeVisible] = React11__namespace.useState(false);
+    const trimmedTimerRef = React11__namespace.useRef(null);
+    const configRef = React11__namespace.useRef(null);
+    if (configRef.current === null) {
+      configRef.current = {
+        initialValue: valueProp ?? defaultValue ?? "",
+        minLines,
+        maxLines,
+        triggers,
+        onEvent: (event) => {
+          if (event.type === "typing") onTypingActivityRef.current?.();
+          if (event.type === "attachment-rejected") onAttachmentRejectedRef.current?.(event);
+          if (event.type === "paste-trimmed") {
+            setTrimmedNoticeVisible(true);
+            if (trimmedTimerRef.current !== null) clearTimeout(trimmedTimerRef.current);
+            trimmedTimerRef.current = setTimeout(() => {
+              trimmedTimerRef.current = null;
+              setTrimmedNoticeVisible(false);
+            }, TRIMMED_NOTICE_HIDE_MS);
+          }
+          onEventRef.current?.(event);
+        }
+      };
+    }
+    configRef.current.maxLength = maxLength;
+    configRef.current.maxAttachments = maxAttachments;
+    configRef.current.validator = validator;
+    configRef.current.replyToMessageId = replyToMessageId;
+    configRef.current.draftStore = draftStore;
+    configRef.current.draftKey = draftKey;
+    const { state, api } = useComposer(configRef.current, (core) => {
+      for (const draft of initialAttachments ?? []) core.addAttachment(draft);
+      if (disabled) core.setDisabled(true);
+      if (readOnly) core.setReadOnly(true);
+      if (busy) core.setBusy(true);
+    });
+    React11__namespace.useEffect(() => () => {
+      if (trimmedTimerRef.current !== null) clearTimeout(trimmedTimerRef.current);
+    }, []);
+    const textareaRef = React11__namespace.useRef(null);
+    const highlightRef = React11__namespace.useRef(null);
+    const mergedTextareaRef = React11__namespace.useCallback(
+      (node) => {
+        textareaRef.current = node;
+        if (typeof forwardedRef === "function") forwardedRef(node);
+        else if (forwardedRef) forwardedRef.current = node;
+      },
+      [forwardedRef]
+    );
+    const idBase = React11__namespace.useRef(id ?? generateId("composer")).current;
+    const listId = `${idBase}-listbox`;
+    const optionId = (index) => `${idBase}-option-${index}`;
+    React11__namespace.useEffect(() => {
+      if (!apiRef) return;
+      if (typeof apiRef === "function") {
+        apiRef(api);
+        return () => {
+          apiRef(null);
+        };
+      }
+      const mutableRef = apiRef;
+      mutableRef.current = api;
+      return () => {
+        mutableRef.current = null;
+      };
+    }, [apiRef, api]);
+    React11__namespace.useEffect(() => {
+      api.setDisabled(disabled);
+    }, [api, disabled]);
+    React11__namespace.useEffect(() => {
+      api.setReadOnly(readOnly);
+    }, [api, readOnly]);
+    React11__namespace.useEffect(() => {
+      api.setBusy(busy);
+    }, [api, busy]);
+    React11__namespace.useEffect(() => {
+      if (valueProp === void 0) return;
+      const current = api.getState();
+      if (current.disabled || current.readOnly || current.value === valueProp) return;
+      api.setValue(
+        valueProp,
+        { start: valueProp.length, end: valueProp.length },
+        { programmatic: true }
+      );
+    }, [api, valueProp, state.value]);
+    const withValueChange = React11__namespace.useCallback(
+      (mutate) => {
+        const before = api.getState().value;
+        const result = mutate();
+        const after = api.getState().value;
+        if (after !== before) onChangeRef.current?.(after);
+        return result;
+      },
+      [api, onChangeRef]
+    );
+    const [coarsePointer, setCoarsePointer] = React11__namespace.useState(false);
+    React11__namespace.useEffect(() => {
+      if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+      const query = window.matchMedia("(pointer: coarse)");
+      const update = () => setCoarsePointer(query.matches);
+      update();
+      query.addEventListener?.("change", update);
+      return () => query.removeEventListener?.("change", update);
+    }, []);
+    const submitEnabled = submitOnEnter ?? !coarsePointer;
+    React11__namespace.useEffect(() => {
+      const el = textareaRef.current;
+      if (!el) return;
+      if (el.value !== state.value) el.value = state.value;
+      if (document.activeElement === el && (el.selectionStart !== state.selection.start || el.selectionEnd !== state.selection.end)) {
+        el.setSelectionRange(state.selection.start, state.selection.end);
+      }
+    }, [state.value, state.selection.start, state.selection.end]);
+    const readSelection = (el) => ({
+      start: el.selectionStart ?? el.value.length,
+      end: el.selectionEnd ?? el.value.length
+    });
+    const handleChange = (event) => {
+      const el = event.currentTarget;
+      withValueChange(() => api.setValue(el.value, readSelection(el)));
+    };
+    const handleSelect = (event) => {
+      const el = event.currentTarget;
+      const next = readSelection(el);
+      const current = api.getState().selection;
+      if (next.start !== current.start || next.end !== current.end) {
+        api.setSelection(next);
+      }
+    };
+    const submitNow = React11__namespace.useCallback(() => {
+      const submission = withValueChange(() => api.submit());
+      if (submission) onSubmitRef.current?.(submission);
+      return submission !== null;
+    }, [api, onSubmitRef, withValueChange]);
+    const handleKeyDown = (event) => {
+      const snapshot = api.getState();
+      const menuOpen2 = snapshot.suggestion.isOpen && !snapshot.isComposing;
+      const hasMenuItems = snapshot.suggestion.items.length > 0;
+      if (menuOpen2) {
+        if (event.key === "ArrowDown" && hasMenuItems) {
+          event.preventDefault();
+          api.moveSuggestionNext();
+          return;
+        }
+        if (event.key === "ArrowUp" && hasMenuItems) {
+          event.preventDefault();
+          api.moveSuggestionPrevious();
+          return;
+        }
+        if (event.key === "Tab" && hasMenuItems) {
+          event.preventDefault();
+          withValueChange(() => api.applySuggestion());
+          return;
+        }
+        if (event.key === "Escape") {
+          event.preventDefault();
+          api.dismissSuggestion();
+          return;
+        }
+      }
+      if (event.key === "Escape" && !menuOpen2 && snapshot.mode === "edit") {
+        event.preventDefault();
+        withValueChange(() => api.cancelEdit());
+        onEditCancelRef.current?.();
+        return;
+      }
+      if (event.key === "ArrowUp" && !menuOpen2 && !snapshot.isComposing && snapshot.value === "" && onEditLastRequestedRef.current) {
+        event.preventDefault();
+        onEditLastRequestedRef.current();
+        return;
+      }
+      if (event.key === "Enter") {
+        if (menuOpen2) {
+          event.preventDefault();
+          withValueChange(() => api.applyEnter({ shiftPressed: event.shiftKey }));
+          return;
+        }
+        if (snapshot.isComposing) return;
+        if (event.shiftKey || !submitEnabled) return;
+        event.preventDefault();
+        if (snapshot.disabled || snapshot.readOnly) return;
+        submitNow();
+      }
+    };
+    const handleCompositionStart = () => api.setComposing(true);
+    const handleCompositionEnd = () => withValueChange(() => api.setComposing(false));
+    const handleCopy = (event) => {
+      const text = api.copySelection();
+      if (text === "") return;
+      event.preventDefault();
+      event.clipboardData.setData("text/plain", text);
+    };
+    const handleCut = (event) => {
+      event.preventDefault();
+      const text = withValueChange(() => api.cutSelection());
+      if (text !== "") event.clipboardData.setData("text/plain", text);
+    };
+    const addFiles = React11__namespace.useCallback(
+      (files) => {
+        for (const file of Array.from(files)) {
+          const previewUrl = typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : void 0;
+          const attachmentId = api.addAttachment({
+            kind: kindFromMime(file.type),
+            name: file.name,
+            mimeType: file.type || void 0,
+            sizeBytes: file.size,
+            previewUrl
+          });
+          if (attachmentId === null) {
+            if (previewUrl !== void 0) URL.revokeObjectURL(previewUrl);
+            continue;
+          }
+          const added = api.getState().attachments.find((a2) => a2.id === attachmentId);
+          if (added) onAttachmentAddRef.current?.(added);
+        }
+      },
+      [api, onAttachmentAddRef]
+    );
+    const handlePaste = (event) => {
+      const files = event.clipboardData?.files;
+      if (files && files.length > 0) {
+        event.preventDefault();
+        addFiles(files);
+        return;
+      }
+      event.preventDefault();
+      withValueChange(() => api.pasteText(event.clipboardData?.getData("text/plain") ?? ""));
+    };
+    const [dragActive, setDragActive] = React11__namespace.useState(false);
+    const dragHasPayload = (event) => {
+      const types = event.dataTransfer ? Array.from(event.dataTransfer.types ?? []) : [];
+      return types.includes("Files") || types.includes("text/plain");
+    };
+    const handleDragOver = (event) => {
+      if (!dragHasPayload(event)) return;
+      event.preventDefault();
+      setDragActive(true);
+    };
+    const handleDragLeave = () => setDragActive(false);
+    const handleDrop = (event) => {
+      event.preventDefault();
+      setDragActive(false);
+      const transfer = event.dataTransfer;
+      if (!transfer) return;
+      if (transfer.files && transfer.files.length > 0) {
+        addFiles(transfer.files);
+        return;
+      }
+      const text = transfer.getData("text/plain");
+      if (text) withValueChange(() => api.pasteText(text));
+    };
+    const handleBlur = () => api.dismissSuggestionDeferred();
+    const handleScroll = (event) => {
+      if (highlightRef.current) {
+        highlightRef.current.scrollTop = event.currentTarget.scrollTop;
+      }
+    };
+    const hasTriggers = (triggers?.length ?? 0) > 0;
+    const menuOpen = state.suggestion.isOpen;
+    const visibleItems = state.suggestion.visibleItems;
+    const activeIndex = state.suggestion.activeIndex;
+    const hasText = state.value.trim().length > 0;
+    const effectivePlaceholder = state.disabled && disabledPlaceholder !== void 0 ? disabledPlaceholder : placeholder;
+    const segments = React11__namespace.useMemo(
+      () => segmentValue(state.value, state.tokens),
+      [state.value, state.tokens]
+    );
+    const primaryContext = {
+      hasText,
+      canSend: state.canSend,
+      busy: state.isBusy
+    };
+    const defaultPrimaryAction = state.isBusy ? /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        "aria-label": strings.stopLabel,
+        className: composerPrimaryActionVariants({ enabled: "true" }),
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => onStopRef.current?.(),
+        children: /* @__PURE__ */ jsxRuntime.jsx(IconStop, {})
+      }
+    ) : /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        "aria-label": strings.sendLabel,
+        disabled: !state.canSend,
+        className: composerPrimaryActionVariants({ enabled: state.canSend ? "true" : "false" }),
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: submitNow,
+        children: /* @__PURE__ */ jsxRuntime.jsx(IconArrowUp, {})
+      }
+    );
+    const menuBody = () => {
+      if (state.suggestion.loading) {
+        return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-2 text-sm text-muted-foreground", children: strings.loadingLabel });
+      }
+      if (state.suggestion.error !== null) {
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 px-3 py-2 text-sm text-destructive", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-1 truncate", children: state.suggestion.error }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              className: "font-medium underline",
+              onMouseDown: (event) => event.preventDefault(),
+              onClick: () => api.retrySuggestions(),
+              children: strings.retryLabel
+            }
+          )
+        ] });
+      }
+      if (visibleItems.length === 0) {
+        return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-2 text-sm text-muted-foreground", children: strings.noMatchesLabel(state.activeTrigger?.query ?? "") });
+      }
+      return visibleItems.map((candidate, index) => {
+        const active = index === activeIndex;
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            role: "option",
+            id: optionId(index),
+            "aria-selected": active,
+            className: composerMenuItemVariants({ active: active ? "true" : "false" }),
+            onMouseEnter: () => api.setSuggestionActiveIndex(index),
+            onMouseDown: (event) => event.preventDefault(),
+            onClick: () => withValueChange(() => api.applySuggestion(index)),
+            children: renderSuggestion ? renderSuggestion(candidate, { active, index }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-1 truncate", children: candidate.display }),
+              candidate.subtitle !== void 0 && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate text-xs text-muted-foreground", children: candidate.subtitle })
+            ] })
+          },
+          candidate.id
+        );
+      });
+    };
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ...rest,
+        id: idBase,
+        dir,
+        role: "form",
+        "aria-label": strings.composerLabel,
+        className: cn("relative", className),
+        onDragOver: handleDragOver,
+        onDragLeave: handleDragLeave,
+        onDrop: handleDrop,
+        children: [
+          menuOpen && /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              id: listId,
+              role: "listbox",
+              "aria-label": strings.suggestionsLabel,
+              className: cn(composerMenuClass, "absolute bottom-full start-0 mb-2"),
+              children: menuBody()
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              "data-dragover": dragActive ? "" : void 0,
+              className: cn(
+                composerSurfaceVariants({
+                  disabled: state.disabled ? "true" : "false",
+                  error: state.error !== null ? "true" : "false"
+                }),
+                dragActive && "border-primary/60 shadow-md"
+              ),
+              children: [
+                state.error !== null && /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    role: "alert",
+                    className: "flex items-center gap-2 border-b border-border bg-destructive/5 px-3 py-2 text-xs text-destructive",
+                    children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-1 truncate", children: state.error })
+                  }
+                ),
+                state.mode === "edit" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 border-b border-border px-3 py-2 text-xs text-muted-foreground", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-1 truncate", children: strings.editingLabel }),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      type: "button",
+                      className: "font-medium underline",
+                      onClick: () => {
+                        withValueChange(() => api.cancelEdit());
+                        onEditCancelRef.current?.();
+                      },
+                      children: strings.cancelEditLabel
+                    }
+                  )
+                ] }),
+                trimmedNoticeVisible && /* @__PURE__ */ jsxRuntime.jsx("div", { role: "status", className: "px-3 pt-2 text-xs text-muted-foreground", children: strings.trimmedNotice }),
+                state.attachments.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: composerTrayClass, children: state.attachments.map((attachment) => /* @__PURE__ */ jsxRuntime.jsxs(
+                  "span",
+                  {
+                    className: composerAttachmentChipVariants({ status: attachment.status }),
+                    children: [
+                      attachment.name,
+                      /* @__PURE__ */ jsxRuntime.jsx(
+                        "button",
+                        {
+                          type: "button",
+                          "aria-label": strings.removeAttachmentLabel(attachment.name),
+                          className: "text-muted-foreground hover:text-destructive",
+                          onClick: () => {
+                            api.removeAttachment(attachment.id);
+                            if (attachment.previewUrl !== void 0 && typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+                              URL.revokeObjectURL(attachment.previewUrl);
+                            }
+                          },
+                          children: "\u2715"
+                        }
+                      )
+                    ]
+                  },
+                  attachment.id
+                )) }),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs(
+                    "div",
+                    {
+                      ref: highlightRef,
+                      "aria-hidden": "true",
+                      className: cn(
+                        composerFieldClass,
+                        "pointer-events-none overflow-hidden whitespace-pre-wrap break-words text-transparent"
+                      ),
+                      style: {
+                        lineHeight: FIELD_LINE_HEIGHT,
+                        minHeight: fieldHeightFor(minLines),
+                        maxHeight: fieldHeightFor(maxLines)
+                      },
+                      children: [
+                        segments.map(
+                          (segment) => segment.isToken ? /* @__PURE__ */ jsxRuntime.jsx(
+                            "span",
+                            {
+                              "data-token": "",
+                              className: cn(composerTokenPillClass, "px-0 text-transparent"),
+                              children: /* @__PURE__ */ jsxRuntime.jsx("bdi", { children: segment.text })
+                            },
+                            segment.key
+                          ) : /* @__PURE__ */ jsxRuntime.jsx("span", { children: segment.text }, segment.key)
+                        ),
+                        "\u200B"
+                      ]
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "textarea",
+                    {
+                      ref: mergedTextareaRef,
+                      id: `${idBase}-input`,
+                      rows: minLines,
+                      value: state.value,
+                      placeholder: effectivePlaceholder,
+                      disabled: state.disabled,
+                      readOnly: state.readOnly,
+                      autoFocus,
+                      "aria-multiline": "true",
+                      "aria-label": strings.messageLabel,
+                      ...hasTriggers ? {
+                        "aria-autocomplete": "list",
+                        "aria-expanded": menuOpen,
+                        "aria-controls": listId,
+                        "aria-activedescendant": menuOpen && visibleItems.length > 0 ? optionId(activeIndex) : void 0
+                      } : {},
+                      className: cn(
+                        composerFieldClass,
+                        "absolute inset-0 h-full overflow-y-auto rounded-md focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                      ),
+                      style: { lineHeight: FIELD_LINE_HEIGHT, maxHeight: fieldHeightFor(maxLines) },
+                      onChange: handleChange,
+                      onSelect: handleSelect,
+                      onKeyDown: handleKeyDown,
+                      onCompositionStart: handleCompositionStart,
+                      onCompositionEnd: handleCompositionEnd,
+                      onCopy: handleCopy,
+                      onCut: handleCut,
+                      onPaste: handlePaste,
+                      onBlur: handleBlur,
+                      onScroll: handleScroll
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5 px-2 pb-2", children: [
+                  leading,
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1" }),
+                  state.counter.visible && state.counter.remaining !== null && /* @__PURE__ */ jsxRuntime.jsx(
+                    "div",
+                    {
+                      "aria-live": state.counter.overLimit ? "polite" : void 0,
+                      className: cn(
+                        composerCounterVariants({
+                          overLimit: state.counter.overLimit ? "true" : "false"
+                        }),
+                        "me-2"
+                      ),
+                      children: strings.counterLabel(state.counter.remaining)
+                    }
+                  ),
+                  trailing,
+                  primaryAction ? primaryAction(primaryContext) : defaultPrimaryAction
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { "aria-live": "polite", className: "sr-only", children: menuOpen && !state.suggestion.loading && state.suggestion.error === null ? visibleItems.length === 0 ? strings.noMatchesLabel(state.activeTrigger?.query ?? "") : strings.resultsAnnouncement(visibleItems.length) : "" })
+        ]
+      }
+    );
+  }
+);
+RefractionComposer.displayName = "RefractionComposer";
 
 // ../conversation/dist/index.js
 function byTime(a2, b2) {
@@ -33498,11 +35481,11 @@ var IconListOl = () => svg([
   h("path", { key: "e", d: "M4 10h2" }),
   h("path", { key: "f", d: "M6 18H4c0-1 2-2 2-3s-1-1.5-2-1" })
 ]);
-var IconArrowUp = () => svg([
+var IconArrowUp2 = () => svg([
   h("path", { key: "a", d: "M12 19V5" }),
   h("path", { key: "b", d: "m5 12 7-7 7 7" })
 ]);
-var IconStop = () => svg(h("rect", { x: 7, y: 7, width: 10, height: 10, rx: 1.5 }));
+var IconStop2 = () => svg(h("rect", { x: 7, y: 7, width: 10, height: 10, rx: 1.5 }));
 var EMOJI = {
   smile: "\u{1F604}",
   grin: "\u{1F601}",
@@ -33546,13 +35529,18 @@ var EMOJI = {
   moon: "\u{1F319}",
   zap: "\u26A1"
 };
+var TRIGGER_CHARS = ["/", "@", ":"];
+var TRIGGER_QUERY_PATTERN = /^[\w+-]*$/;
 function detectTrigger(text, caret) {
-  const before = text.slice(0, caret);
-  const m2 = before.match(/(?:^|\s)([/@:])([\w+-]*)$/);
-  if (!m2) return null;
-  const type = m2[1];
-  const query = m2[2] ?? "";
-  return { type, query, start: caret - query.length - 1, end: caret };
+  let best = null;
+  for (const type of TRIGGER_CHARS) {
+    const hit = detectTriggerInText(text, caret, type);
+    if (!hit || !TRIGGER_QUERY_PATTERN.test(hit.query)) continue;
+    if (!best || hit.start > best.start) {
+      best = { type, query: hit.query, start: hit.start, end: caret };
+    }
+  }
+  return best;
 }
 function Composer({
   placeholder = "Send a message\u2026",
@@ -33846,7 +35834,7 @@ ${sel}
           busy ? h(
             "button",
             { type: "button", "aria-label": "Stop", className: "flex h-9 w-9 items-center justify-center rounded-full bg-primary text-primary-foreground transition hover:opacity-90", onClick: () => onStop?.() },
-            h(IconStop)
+            h(IconStop2)
           ) : h(
             "button",
             {
@@ -33856,7 +35844,7 @@ ${sel}
               disabled: !value.trim() && pending.length === 0,
               onClick: submit
             },
-            h(IconArrowUp)
+            h(IconArrowUp2)
           )
         )
       )
@@ -42173,427 +44161,39 @@ var Checkbox = React11__namespace.forwardRef(
 Checkbox.displayName = "Checkbox";
 
 // ../date-picker/dist/index.js
-function isSameDay2(a2, b2) {
-  return a2.getFullYear() === b2.getFullYear() && a2.getMonth() === b2.getMonth() && a2.getDate() === b2.getDate();
-}
-function startOfMonth2(date) {
-  return new Date(date.getFullYear(), date.getMonth(), 1);
-}
-function startOfDay(date) {
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
-}
-function endOfDay(date) {
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
-}
-var DAY_NAMES2 = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-function padZero(n2) {
-  return n2 < 10 ? `0${n2}` : `${n2}`;
-}
-function formatDate(date, format, showTime) {
-  if (!date) return "";
-  const year = date.getFullYear();
-  const month = padZero(date.getMonth() + 1);
-  const day = padZero(date.getDate());
-  const hours = padZero(date.getHours());
-  const minutes = padZero(date.getMinutes());
-  let result = format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day);
-  if (showTime) {
-    result = result.replace("HH", hours).replace("mm", minutes);
-  }
-  return result;
-}
-function createDatePicker(props = {}) {
-  const {
-    value,
-    onChange,
-    minDate,
-    maxDate,
-    showTime = false,
-    format = showTime ? "YYYY-MM-DD HH:mm" : "YYYY-MM-DD",
-    placeholder = "Select date...",
-    open: controlledOpen,
-    defaultOpen = false,
-    onOpenChange
-  } = props;
-  const today = /* @__PURE__ */ new Date();
-  let internalOpen = controlledOpen ?? defaultOpen;
-  let currentMonth = value ? startOfMonth2(value) : startOfMonth2(today);
-  let view = "calendar";
-  const hours = value ? value.getHours() : 0;
-  const minutes = value ? value.getMinutes() : 0;
-  const triggerId = generateId("rfr-datepicker-trigger");
-  const dropdownId = generateId("rfr-datepicker-dropdown");
-  const gridId = generateId("rfr-datepicker-grid");
-  const labelId = generateId("rfr-datepicker-label");
-  function isOpen() {
-    if (controlledOpen !== void 0) return controlledOpen;
-    return internalOpen;
-  }
-  function isDateDisabled(date) {
-    if (minDate && date < startOfDay(minDate)) return true;
-    if (maxDate && date > endOfDay(maxDate)) return true;
-    return false;
-  }
-  function buildDays() {
-    const year = currentMonth.getFullYear();
-    const month = currentMonth.getMonth();
-    const first = new Date(year, month, 1);
-    const startDow = first.getDay();
-    const gridStart = new Date(year, month, 1 - startDow);
-    const days = [];
-    for (let i2 = 0; i2 < 42; i2++) {
-      const date = new Date(
-        gridStart.getFullYear(),
-        gridStart.getMonth(),
-        gridStart.getDate() + i2
-      );
-      days.push({
-        date,
-        isToday: isSameDay2(date, today),
-        isSelected: value ? isSameDay2(date, value) : false,
-        isCurrentMonth: date.getMonth() === month,
-        isDisabled: isDateDisabled(date)
-      });
-    }
-    return days;
-  }
-  function openPicker() {
-    internalOpen = true;
-    onOpenChange?.(true);
-  }
-  function closePicker() {
-    internalOpen = false;
-    onOpenChange?.(false);
-  }
-  function togglePicker() {
-    if (isOpen()) {
-      closePicker();
-    } else {
-      openPicker();
-    }
-  }
-  function selectDate(date) {
-    if (isDateDisabled(date)) return;
-    const newDate = new Date(date);
-    if (value) {
-      newDate.setHours(value.getHours());
-      newDate.setMinutes(value.getMinutes());
-    }
-    onChange?.(newDate);
-    if (!showTime) {
-      closePicker();
-    }
-  }
-  function setHours(h5) {
-    if (h5 < 0 || h5 > 23) return;
-    const newDate = value ? new Date(value) : /* @__PURE__ */ new Date();
-    newDate.setHours(h5);
-    onChange?.(newDate);
-  }
-  function setMinutes(m2) {
-    if (m2 < 0 || m2 > 59) return;
-    const newDate = value ? new Date(value) : /* @__PURE__ */ new Date();
-    newDate.setMinutes(m2);
-    onChange?.(newDate);
-  }
-  function prevMonth() {
-    currentMonth = new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1);
-  }
-  function nextMonth() {
-    currentMonth = new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1);
-  }
-  function setView(v2) {
-    view = v2;
-  }
-  function formatDisplay() {
-    return value ? formatDate(value, format, showTime) : placeholder;
-  }
-  const keyboardHandlers = {
-    [Keys.Escape]: (e2) => {
-      e2.preventDefault();
-      closePicker();
-    }
-  };
-  const triggerProps = {
-    "aria-expanded": isOpen(),
-    "aria-controls": dropdownId,
-    "aria-haspopup": "dialog",
-    id: triggerId,
-    role: "combobox"
-  };
-  const dropdownProps = {
-    role: "dialog",
-    "aria-modal": true,
-    "aria-labelledby": labelId,
-    id: dropdownId
-  };
-  const gridProps = {
-    role: "grid",
-    "aria-labelledby": labelId,
-    id: gridId
-  };
-  function getDayAriaProps(day) {
-    return {
-      role: "gridcell",
-      "aria-selected": day.isSelected,
-      "aria-disabled": day.isDisabled,
-      "aria-current": day.isToday ? "date" : void 0,
-      "aria-label": `${DAY_NAMES2[day.date.getDay()]}, ${day.date.toLocaleDateString("en-US", {
-        month: "long",
-        day: "numeric",
-        year: "numeric"
-      })}`
-    };
-  }
-  return {
-    state: {
-      open: isOpen(),
-      selectedDate: value,
-      view,
-      hours,
-      minutes,
-      currentMonth
-    },
-    days: buildDays(),
-    openPicker,
-    closePicker,
-    togglePicker,
-    selectDate,
-    setHours,
-    setMinutes,
-    prevMonth,
-    nextMonth,
-    setView,
-    formatDisplay,
-    triggerProps,
-    dropdownProps,
-    gridProps,
-    getDayAriaProps,
-    keyboardHandlers,
-    ids: {
-      trigger: triggerId,
-      dropdown: dropdownId,
-      grid: gridId,
-      label: labelId
-    }
-  };
-}
 var datePickerTriggerStyles = "inline-flex items-center gap-2 rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring cursor-pointer";
-var datePickerDropdownStyles = "absolute z-50 mt-1 rounded-md border bg-popover p-4 text-popover-foreground shadow-md";
-var datePickerDayVariants = cva({
-  base: "inline-flex h-8 w-8 items-center justify-center rounded-md text-sm cursor-pointer hover:bg-accent hover:text-accent-foreground",
-  variants: {
-    state: {
-      default: "",
-      selected: "bg-primary text-primary-foreground hover:bg-primary/90",
-      today: "border border-accent-foreground",
-      disabled: "text-muted-foreground opacity-50 pointer-events-none",
-      outside: "text-muted-foreground opacity-30"
-    }
-  },
-  defaultVariants: {
-    state: "default"
-  }
-});
-var datePickerTimeStyles = "flex items-center gap-2 mt-3 pt-3 border-t";
-var datePickerTimeInputStyles = "w-14 rounded-md border border-input bg-background px-2 py-1 text-sm text-center";
-
-// ../react-date-picker/dist/index.js
-function DatePicker({
-  value,
-  onChange,
-  minDate,
-  maxDate,
-  showTime = false,
-  format,
-  placeholder,
-  className,
-  disabled = false
-}) {
-  const [open, setOpen] = React11__namespace.useState(false);
-  const [currentMonth, setCurrentMonth] = React11__namespace.useState(
-    () => value ? new Date(value.getFullYear(), value.getMonth(), 1) : new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1)
-  );
-  const [view, setView] = React11__namespace.useState("calendar");
-  const containerRef = React11__namespace.useRef(null);
-  const api = React11__namespace.useMemo(
-    () => createDatePicker({
-      value,
-      onChange,
-      minDate,
-      maxDate,
-      showTime,
-      format,
-      placeholder,
-      open,
-      onOpenChange: setOpen
-    }),
-    [value, onChange, minDate, maxDate, showTime, format, placeholder, open]
-  );
-  React11__namespace.useMemo(() => {
-    createDatePicker({
-      value,
-      minDate,
-      maxDate,
-      open: true
-    });
-    const tempApi = createDatePicker({
-      value,
-      minDate,
-      maxDate,
-      open: true
-    });
-    return tempApi.days;
-  }, [value, minDate, maxDate, currentMonth]);
-  React11__namespace.useEffect(() => {
-    if (!open) return;
-    function handleClick(e2) {
-      if (containerRef.current && !containerRef.current.contains(e2.target)) {
-        setOpen(false);
-      }
-    }
-    document.addEventListener("mousedown", handleClick);
-    return () => document.removeEventListener("mousedown", handleClick);
-  }, [open]);
-  React11__namespace.useEffect(() => {
-    if (!open) return;
-    function handleKeyDown(e2) {
-      if (e2.key === "Escape") {
-        e2.preventDefault();
-        setOpen(false);
+var DatePicker = React11__namespace.forwardRef(
+  ({ value, onChange, minDate, maxDate, showTime = false, format, placeholder, className, disabled = false, ...props }, ref) => {
+    const dateToString = (date) => {
+      if (!date) return "";
+      const offset = date.getTimezoneOffset() * 6e4;
+      const localDate = new Date(date.getTime() - offset);
+      const iso = localDate.toISOString();
+      return showTime ? iso.slice(0, 16) : iso.slice(0, 10);
+    };
+    const handleChange = (e2) => {
+      if (!onChange) return;
+      if (e2.target.value) {
+        onChange(new Date(e2.target.value));
       }
-    }
-    document.addEventListener("keydown", handleKeyDown);
-    return () => document.removeEventListener("keydown", handleKeyDown);
-  }, [open]);
-  const displayValue = api.formatDisplay();
-  const handleSelectDate = (date) => {
-    const newDate = new Date(date);
-    if (value) {
-      newDate.setHours(value.getHours());
-      newDate.setMinutes(value.getMinutes());
-    }
-    onChange?.(newDate);
-    if (!showTime) {
-      setOpen(false);
-    }
-  };
-  const handleHoursChange = (e2) => {
-    const h5 = parseInt(e2.target.value, 10);
-    if (isNaN(h5) || h5 < 0 || h5 > 23) return;
-    const newDate = value ? new Date(value) : /* @__PURE__ */ new Date();
-    newDate.setHours(h5);
-    onChange?.(newDate);
-  };
-  const handleMinutesChange = (e2) => {
-    const m2 = parseInt(e2.target.value, 10);
-    if (isNaN(m2) || m2 < 0 || m2 > 59) return;
-    const newDate = value ? new Date(value) : /* @__PURE__ */ new Date();
-    newDate.setMinutes(m2);
-    onChange?.(newDate);
-  };
-  const monthLabel = currentMonth.toLocaleDateString("en-US", { month: "long", year: "numeric" });
-  return React11__namespace.createElement(
-    "div",
-    { ref: containerRef, className: cn("relative inline-block", className) },
-    React11__namespace.createElement(
-      "button",
-      {
-        type: "button",
-        className: cn(datePickerTriggerStyles, disabled && "opacity-50 cursor-not-allowed"),
-        onClick: () => !disabled && setOpen(!open),
-        "aria-expanded": open,
-        "aria-haspopup": "dialog",
-        disabled
-      },
-      displayValue
-    ),
-    open && React11__namespace.createElement(
-      "div",
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
       {
-        className: datePickerDropdownStyles,
-        role: "dialog",
-        "aria-modal": true
-      },
-      React11__namespace.createElement(
-        "div",
-        { className: "flex items-center justify-between mb-3" },
-        React11__namespace.createElement(
-          "button",
-          {
-            type: "button",
-            className: "p-1 hover:bg-accent rounded cursor-pointer",
-            onClick: () => setCurrentMonth(new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1)),
-            "aria-label": "Previous month"
-          },
-          "\u2039"
-        ),
-        React11__namespace.createElement("span", { className: "text-sm font-medium" }, monthLabel),
-        React11__namespace.createElement(
-          "button",
-          {
-            type: "button",
-            className: "p-1 hover:bg-accent rounded cursor-pointer",
-            onClick: () => setCurrentMonth(new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1)),
-            "aria-label": "Next month"
-          },
-          "\u203A"
-        )
-      ),
-      React11__namespace.createElement(
-        "div",
-        { className: "grid grid-cols-7 gap-0 text-center", role: "grid" },
-        ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"].map(
-          (d2) => React11__namespace.createElement("div", { key: d2, className: "text-xs text-muted-foreground py-1 font-medium" }, d2)
-        ),
-        api.days.map((day, i2) => {
-          let state = "default";
-          if (day.isDisabled) state = "disabled";
-          else if (day.isSelected) state = "selected";
-          else if (day.isToday) state = "today";
-          else if (!day.isCurrentMonth) state = "outside";
-          return React11__namespace.createElement(
-            "button",
-            {
-              key: i2,
-              type: "button",
-              className: datePickerDayVariants({ state }),
-              onClick: () => !day.isDisabled && handleSelectDate(day.date),
-              disabled: day.isDisabled,
-              "aria-selected": day.isSelected,
-              "aria-disabled": day.isDisabled
-            },
-            day.date.getDate()
-          );
-        })
-      ),
-      showTime && React11__namespace.createElement(
-        "div",
-        { className: datePickerTimeStyles },
-        React11__namespace.createElement("span", { className: "text-sm text-muted-foreground" }, "Time:"),
-        React11__namespace.createElement("input", {
-          type: "number",
-          min: 0,
-          max: 23,
-          value: value ? value.getHours() : 0,
-          onChange: handleHoursChange,
-          className: datePickerTimeInputStyles,
-          "aria-label": "Hours"
-        }),
-        React11__namespace.createElement("span", { className: "text-muted-foreground" }, ":"),
-        React11__namespace.createElement("input", {
-          type: "number",
-          min: 0,
-          max: 59,
-          value: value ? value.getMinutes() : 0,
-          onChange: handleMinutesChange,
-          className: datePickerTimeInputStyles,
-          "aria-label": "Minutes"
-        })
-      )
-    )
-  );
-}
+        ref,
+        type: showTime ? "datetime-local" : "date",
+        className: cn(datePickerTriggerStyles, "justify-start text-left font-normal w-[280px]", className),
+        value: dateToString(value),
+        min: dateToString(minDate),
+        max: dateToString(maxDate),
+        onChange: handleChange,
+        disabled,
+        placeholder,
+        ...props
+      }
+    );
+  }
+);
 DatePicker.displayName = "DatePicker";
 
 // ../emoji-picker/dist/index.js
@@ -52940,6 +54540,7 @@ exports.ContentProtection = ContentProtection;
 exports.CookieConsent = CookieConsent;
 exports.Cursor = Cursor;
 exports.DEFAULT_CATEGORIES = DEFAULT_CATEGORIES;
+exports.DEFAULT_COMPOSER_STRINGS = DEFAULT_COMPOSER_STRINGS;
 exports.DEFAULT_VOICE_PILL_POSITION = DEFAULT_VOICE_PILL_POSITION;
 exports.DEFAULT_VOICE_PILL_SPEAKER = DEFAULT_VOICE_PILL_SPEAKER;
 exports.DEFAULT_WAVEFORM_BAR_COUNT = DEFAULT_WAVEFORM_BAR_COUNT;
@@ -53028,6 +54629,7 @@ exports.RadioItem = RadioItem;
 exports.RatingScale = RatingScale;
 exports.ReactionBar = ReactionBar;
 exports.ReactionBurst = ReactionBurst;
+exports.RefractionComposer = RefractionComposer;
 exports.ResizableDivider = ResizableDivider;
 exports.ResizableLayout = ResizableLayout;
 exports.ResizablePane = ResizablePane;
@@ -53154,10 +54756,20 @@ exports.commandGroupVariants = commandGroupVariants;
 exports.commandInputVariants = commandInputVariants;
 exports.commandItemVariants = commandItemVariants;
 exports.commandVariants = commandVariants;
+exports.composerAttachmentChipVariants = composerAttachmentChipVariants;
+exports.composerCounterVariants = composerCounterVariants;
+exports.composerFieldClass = composerFieldClass;
+exports.composerMenuClass = composerMenuClass;
+exports.composerMenuItemVariants = composerMenuItemVariants;
+exports.composerPrimaryActionVariants = composerPrimaryActionVariants;
+exports.composerSurfaceVariants = composerSurfaceVariants;
+exports.composerTokenPillClass = composerTokenPillClass;
+exports.composerTrayClass = composerTrayClass;
 exports.contentProtectionVariants = contentProtectionVariants;
 exports.controlsVariants = controlsVariants;
 exports.createAnalytics = createAnalytics;
 exports.createAppInsightsSink = createAppInsightsSink;
+exports.createComposer = createComposer;
 exports.createConsoleSink = createConsoleSink;
 exports.createConversation = createConversation;
 exports.createCookieConsent = createCookieConsent;
@@ -53315,12 +54927,14 @@ exports.threadMessageStyles = threadMessageStyles;
 exports.threadReactionsStyles = threadReactionsStyles;
 exports.threadTimestampStyles = threadTimestampStyles;
 exports.toCssDimension = toCssDimension;
+exports.toMessageAttachment = toMessageAttachment;
 exports.toastVariants = toastVariants;
 exports.toolbarVariants = toolbarVariants;
 exports.tooltipContentVariants = tooltipContentVariants;
 exports.typewriterVariants = typewriterVariants;
 exports.useAnalytics = useAnalytics;
 exports.useAuth = useAuth;
+exports.useComposer = useComposer;
 exports.useConversation = useConversation;
 exports.useCookieConsent = useCookieConsent;
 exports.useFloatingReactions = useFloatingReactions;