@xoroh/axis 0.0.0-stage → 0.1.0

package/dist/models.cjs

@@ -0,0 +1,1952 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/models.ts
+var models_exports = {};
+__export(models_exports, {
+  addTimeMinutes: () => addTimeMinutes,
+  appendTypeaheadQuery: () => appendTypeaheadQuery,
+  buildCalendarGrid: () => buildCalendarGrid,
+  clampNumberValue: () => clampNumberValue,
+  clampSliderValue: () => clampSliderValue,
+  composeEventHandlers: () => composeEventHandlers,
+  createDismissPolicy: () => createDismissPolicy,
+  createIdScope: () => createIdScope,
+  createOverlayModality: () => createOverlayModality,
+  createPortalRegistry: () => createPortalRegistry,
+  createPresenceModel: () => createPresenceModel,
+  createToastQueue: () => createToastQueue,
+  daysInCalendarMonth: () => daysInCalendarMonth,
+  defaultCollectionMatch: () => defaultCollectionMatch,
+  dismissBranchesFor: () => dismissBranchesFor,
+  dismissTriggersFor: () => dismissTriggersFor,
+  filterCollectionKeys: () => filterCollectionKeys,
+  findCollectionText: () => findCollectionText,
+  formatNumberValue: () => formatNumberValue,
+  formatTimeParts: () => formatTimeParts,
+  formatTimeValue: () => formatTimeValue,
+  getSharedOverlayModality: () => getSharedOverlayModality,
+  isAtBottom: () => isAtBottom,
+  isCalendarDateDisabled: () => isCalendarDateDisabled,
+  isChatBusy: () => isChatBusy,
+  isChatError: () => isChatError,
+  isChatStreaming: () => isChatStreaming,
+  isEmptyValue: () => isEmptyValue,
+  isSelected: () => isSelected,
+  isToolCallApproval: () => isToolCallApproval,
+  isToolCallComplete: () => isToolCallComplete,
+  isToolCallError: () => isToolCallError,
+  isToolCallRunning: () => isToolCallRunning,
+  isTypeaheadExpired: () => isTypeaheadExpired,
+  isUserMessage: () => isUserMessage,
+  leadingBlankCount: () => leadingBlankCount,
+  matchTypeaheadKey: () => matchTypeaheadKey,
+  mergeFormErrors: () => mergeFormErrors,
+  mergeSlotProps: () => mergeSlotProps,
+  minutesForStep: () => minutesForStep,
+  nearestSliderThumbIndex: () => nearestSliderThumbIndex,
+  nextBranchIndex: () => nextBranchIndex,
+  nextPresenceState: () => nextPresenceState,
+  nextTrapIndex: () => nextTrapIndex,
+  normalizeBranchIndex: () => normalizeBranchIndex,
+  normalizeChatSources: () => normalizeChatSources,
+  normalizeFieldErrors: () => normalizeFieldErrors,
+  normalizeSelection: () => normalizeSelection,
+  normalizeSliderValues: () => normalizeSliderValues,
+  normalizeTimeValue: () => normalizeTimeValue,
+  parseCalendarDate: () => parseCalendarDate,
+  parseCalendarMonth: () => parseCalendarMonth,
+  parseNumberValue: () => parseNumberValue,
+  previousBranchIndex: () => previousBranchIndex,
+  resolveAutofocus: () => resolveAutofocus,
+  resolveCalendarFocus: () => resolveCalendarFocus,
+  resolveCalendarMonthNames: () => resolveCalendarMonthNames,
+  resolveCalendarSelection: () => resolveCalendarSelection,
+  resolveCalendarWeekdayNames: () => resolveCalendarWeekdayNames,
+  resolveCanSend: () => resolveCanSend,
+  resolveChatMessageLabel: () => resolveChatMessageLabel,
+  resolveChatMessageSpeaker: () => resolveChatMessageSpeaker,
+  resolveChatSourceLabel: () => resolveChatSourceLabel,
+  resolveComposerHeight: () => resolveComposerHeight,
+  resolveDir: () => resolveDir,
+  resolveFloatingRect: () => resolveFloatingRect,
+  resolveFloatingSide: () => resolveFloatingSide,
+  resolveLocaleFirstDay: () => resolveLocaleFirstDay,
+  resolvePortalTarget: () => resolvePortalTarget,
+  resolveReasoningOpen: () => resolveReasoningOpen,
+  resolveRender: () => resolveRender,
+  resolveScrollButtonVisible: () => resolveScrollButtonVisible,
+  resolveSliderCommit: () => resolveSliderCommit,
+  resolveStyle: () => resolveStyle,
+  resolveToolCallLabel: () => resolveToolCallLabel,
+  shiftCalendarMonth: () => shiftCalendarMonth,
+  shouldCancelOnEscapeKey: () => shouldCancelOnEscapeKey,
+  shouldDismissOn: () => shouldDismissOn,
+  shouldHideBranchPicker: () => shouldHideBranchPicker,
+  shouldSubmitOnKey: () => shouldSubmitOnKey,
+  sliderRatioFromLocation: () => sliderRatioFromLocation,
+  sliderValueFromRatio: () => sliderValueFromRatio,
+  sliderValuePercent: () => sliderValuePercent,
+  snapSliderValue: () => snapSliderValue,
+  stepNumberValue: () => stepNumberValue,
+  toCalendarDate: () => toCalendarDate,
+  toCalendarMonth: () => toCalendarMonth,
+  toTwentyFourHour: () => toTwentyFourHour,
+  toggleSelection: () => toggleSelection,
+  updateAttachment: () => updateAttachment,
+  useAttachments: () => useAttachments,
+  useBranch: () => useBranch,
+  useCollectionRegistry: () => useCollectionRegistry,
+  useControllableState: () => useControllableState,
+  useOverlayModality: () => useOverlayModality,
+  useOverlayRegistration: () => useOverlayRegistration,
+  usePresence: () => usePresence,
+  usePress: () => usePress,
+  usePromptInput: () => usePromptInput,
+  useRovingModel: () => useRovingModel,
+  useSelection: () => useSelection,
+  useStickToBottom: () => useStickToBottom,
+  useToolCall: () => useToolCall,
+  validateAttachment: () => validateAttachment
+});
+module.exports = __toCommonJS(models_exports);
+
+// src/a11y.ts
+function createIdScope(prefix) {
+  let counter = 0;
+  return {
+    prefix,
+    nextId: () => {
+      counter += 1;
+      return `${prefix}-${counter}`;
+    }
+  };
+}
+function resolveDir(options) {
+  return options?.dir ?? options?.defaultDir ?? "ltr";
+}
+
+// src/attachments.ts
+var import_react2 = require("react");
+
+// src/useControllableState.ts
+var import_react = require("react");
+function useControllableState(value, defaultValue, onChange) {
+  const [internal, setInternal] = (0, import_react.useState)(defaultValue);
+  const controlled = value !== void 0;
+  const current = controlled ? value : internal;
+  const currentRef = (0, import_react.useRef)(current);
+  const wasControlled = (0, import_react.useRef)(controlled);
+  currentRef.current = current;
+  (0, import_react.useEffect)(() => {
+    if (wasControlled.current !== controlled) {
+      console.warn(
+        "Axis: a component changed from controlled to uncontrolled (or vice versa). Keep the value prop defined for its lifetime."
+      );
+      wasControlled.current = controlled;
+    }
+  }, [controlled]);
+  const setValue = (0, import_react.useCallback)(
+    (action, details) => {
+      const previous = currentRef.current;
+      const next = typeof action === "function" ? action(previous) : action;
+      currentRef.current = next;
+      if (!controlled) setInternal(next);
+      if (!Object.is(previous, next)) {
+        if (details === void 0) onChange?.(next);
+        else onChange?.(next, details);
+      }
+    },
+    [controlled, onChange]
+  );
+  return [current, setValue];
+}
+
+// src/attachments.ts
+function validateAttachment(current, candidate, limits) {
+  if (current.some((entry) => entry.id === candidate.id)) return "duplicate";
+  if (limits?.maxFileSize !== void 0 && candidate.size !== void 0 && candidate.size > limits.maxFileSize) {
+    return "too-large";
+  }
+  if (limits?.maxFiles !== void 0 && current.length >= limits.maxFiles) {
+    return "too-many";
+  }
+  return null;
+}
+function updateAttachment(current, id, patch) {
+  return current.map(
+    (entry) => entry.id === id ? { ...entry, ...patch } : entry
+  );
+}
+function useAttachments(options) {
+  const [raw, setRaw] = useControllableState(
+    options?.value,
+    options?.defaultValue ?? [],
+    options?.onChange
+  );
+  const attachments = raw ?? [];
+  const { maxFiles, maxFileSize, onError } = options ?? {};
+  const addMany = (0, import_react2.useCallback)(
+    (candidates) => {
+      const working = [...attachments];
+      let accepted = false;
+      for (const candidate of candidates) {
+        const error = validateAttachment(working, candidate, {
+          maxFiles,
+          maxFileSize
+        });
+        if (error) {
+          onError?.(error, candidate);
+          continue;
+        }
+        working.push(candidate);
+        accepted = true;
+      }
+      if (accepted) setRaw(working);
+    },
+    [attachments, maxFiles, maxFileSize, onError, setRaw]
+  );
+  const add = (0, import_react2.useCallback)(
+    (candidate) => {
+      addMany([candidate]);
+    },
+    [addMany]
+  );
+  const update = (0, import_react2.useCallback)(
+    (id, patch) => {
+      setRaw((previous) => updateAttachment(previous ?? [], id, patch));
+    },
+    [setRaw]
+  );
+  const remove = (0, import_react2.useCallback)(
+    (id) => {
+      setRaw((previous) => (previous ?? []).filter((entry) => entry.id !== id));
+    },
+    [setRaw]
+  );
+  const clear = (0, import_react2.useCallback)(() => {
+    setRaw([]);
+  }, [setRaw]);
+  return { attachments, add, addMany, update, remove, clear };
+}
+
+// src/calendar.ts
+var ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+var MONTH_PATTERN = /^(\d{4})-(\d{2})$/;
+var FALLBACK_WEEKDAY_NAMES = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"];
+function parseCalendarDate(value) {
+  if (typeof value !== "string") return null;
+  const match = ISO_DATE_PATTERN.exec(value);
+  if (match === null) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  const check = new Date(Date.UTC(year, month - 1, day));
+  if (check.getUTCFullYear() !== year || check.getUTCMonth() !== month - 1 || check.getUTCDate() !== day) {
+    return null;
+  }
+  return { year, monthIndex: month - 1, day };
+}
+function parseCalendarMonth(value) {
+  if (typeof value !== "string") return null;
+  const match = MONTH_PATTERN.exec(value);
+  if (match === null) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  if (month < 1 || month > 12) return null;
+  return { year, monthIndex: month - 1 };
+}
+function toCalendarDate(year, monthIndex, day) {
+  return `${String(year).padStart(4, "0")}-${String(monthIndex + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function toCalendarMonth(year, monthIndex) {
+  return `${String(year).padStart(4, "0")}-${String(monthIndex + 1).padStart(2, "0")}`;
+}
+function daysInCalendarMonth(year, monthIndex) {
+  return new Date(Date.UTC(year, monthIndex + 1, 0)).getUTCDate();
+}
+function shiftCalendarMonth(year, monthIndex, delta) {
+  const total = year * 12 + monthIndex + delta;
+  const nextYear = Math.floor(total / 12);
+  return { year: nextYear, monthIndex: total - nextYear * 12 };
+}
+function leadingBlankCount(year, monthIndex, firstDayOfWeek = 0) {
+  const sundayFirst = new Date(Date.UTC(year, monthIndex, 1)).getUTCDay();
+  return (sundayFirst - firstDayOfWeek + 7) % 7;
+}
+function resolveCalendarWeekdayNames(locale = "en-US", firstDayOfWeek = 0) {
+  let names = FALLBACK_WEEKDAY_NAMES;
+  try {
+    const format = new Intl.DateTimeFormat(locale, {
+      weekday: "short",
+      timeZone: "UTC"
+    });
+    names = Array.from(
+      { length: 7 },
+      (_, i) => format.format(new Date(Date.UTC(2026, 5, 7 + i)))
+    );
+  } catch {
+    names = FALLBACK_WEEKDAY_NAMES;
+  }
+  return [...names.slice(firstDayOfWeek), ...names.slice(0, firstDayOfWeek)];
+}
+function validBound(value) {
+  return parseCalendarDate(value) !== null && typeof value === "string" ? value : null;
+}
+function resolveCalendarMonthNames(locale = "en-US", style = "long") {
+  const fallback = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ];
+  try {
+    const format = new Intl.DateTimeFormat(locale, {
+      month: style,
+      timeZone: "UTC"
+    });
+    return Array.from(
+      { length: 12 },
+      (_, monthIndex) => format.format(new Date(Date.UTC(2026, monthIndex, 15, 12)))
+    );
+  } catch {
+    return fallback;
+  }
+}
+function resolveLocaleFirstDay(locale = "en-US") {
+  const override = fwExtensionFirstDay(locale);
+  if (override !== void 0) return override;
+  const live = liveWeekInfoFirstDay(locale);
+  if (live !== void 0) return live;
+  return tableFirstDay(regionOfLocale(locale));
+}
+function fwExtensionFirstDay(locale) {
+  const subtags = String(locale).toLowerCase().replace(/_/g, "-").split("-");
+  const uIndex = subtags.indexOf("u");
+  if (uIndex === -1) return void 0;
+  const section = [];
+  for (let i = uIndex + 1; i < subtags.length; i++) {
+    const sub = subtags[i];
+    if (sub === void 0 || sub.length < 2) break;
+    section.push(sub);
+  }
+  const keyIndex = section.indexOf("fw");
+  const value = keyIndex === -1 ? void 0 : section[keyIndex + 1];
+  switch (value) {
+    case "mon":
+      return 1;
+    case "tue":
+      return 2;
+    case "wed":
+      return 3;
+    case "thu":
+      return 4;
+    case "fri":
+      return 5;
+    case "sat":
+      return 6;
+    case "sun":
+      return 0;
+    default:
+      return void 0;
+  }
+}
+function liveWeekInfoFirstDay(locale) {
+  try {
+    const Ctor = Intl.Locale;
+    if (typeof Ctor !== "function") return void 0;
+    const loc = new Ctor(locale);
+    const fromMethod = typeof loc.getWeekInfo === "function" ? loc.getWeekInfo() : void 0;
+    const info = fromMethod ?? loc.weekInfo;
+    const firstDay = info !== null && typeof info === "object" ? info.firstDay : void 0;
+    if (typeof firstDay === "number" && Number.isInteger(firstDay) && firstDay >= 1 && firstDay <= 7) {
+      return (firstDay % 7 + 7) % 7;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var SATURDAY_START = /* @__PURE__ */ new Set([
+  "AF",
+  "BH",
+  "DJ",
+  "DZ",
+  "EG",
+  "IQ",
+  "IR",
+  "JO",
+  "KW",
+  "LY",
+  "OM",
+  "QA",
+  "SD",
+  "SY"
+]);
+var FRIDAY_START = /* @__PURE__ */ new Set(["MV"]);
+var SUNDAY_START = /* @__PURE__ */ new Set([
+  "AG",
+  "AS",
+  "BD",
+  "BR",
+  "BS",
+  "BT",
+  "BW",
+  "BZ",
+  "CA",
+  "CO",
+  "DM",
+  "DO",
+  "ET",
+  "GT",
+  "GU",
+  "HK",
+  "HN",
+  "ID",
+  "IL",
+  "IN",
+  "IS",
+  "JM",
+  "JP",
+  "KE",
+  "KH",
+  "KR",
+  "LA",
+  "MH",
+  "MM",
+  "MO",
+  "MT",
+  "MX",
+  "MZ",
+  "NI",
+  "NP",
+  "PA",
+  "PE",
+  "PH",
+  "PK",
+  "PR",
+  "PT",
+  "PY",
+  "SA",
+  "SG",
+  "SV",
+  "TH",
+  "TT",
+  "TW",
+  "UM",
+  "US",
+  "VE",
+  "VI",
+  "WS",
+  "YE",
+  "ZA",
+  "ZW"
+]);
+function tableFirstDay(region) {
+  if (region !== void 0) {
+    if (SATURDAY_START.has(region)) return 6;
+    if (FRIDAY_START.has(region)) return 5;
+    if (SUNDAY_START.has(region)) return 0;
+  }
+  return 1;
+}
+var LIKELY_REGION = {
+  ar: "EG",
+  en: "US",
+  es: "ES",
+  fa: "IR",
+  he: "IL",
+  hi: "IN",
+  id: "ID",
+  ja: "JP",
+  ko: "KR",
+  pt: "BR",
+  th: "TH",
+  zh: "CN"
+};
+function regionOfLocale(locale) {
+  try {
+    const Ctor = Intl.Locale;
+    if (typeof Ctor === "function") {
+      const region = new Ctor(locale).maximize?.().region;
+      if (typeof region === "string" && region !== "") {
+        return region.toUpperCase();
+      }
+    }
+  } catch {
+  }
+  const parts = String(locale).replace(/_/g, "-").split("-");
+  const language = parts[0]?.toLowerCase();
+  if (parts.length === 1 && language !== void 0) {
+    const likely = LIKELY_REGION[language];
+    if (likely !== void 0) return likely;
+  }
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    if (part !== void 0 && (/^[A-Za-z]{2}$/.test(part) || /^[0-9]{3}$/.test(part))) {
+      return part.toUpperCase();
+    }
+  }
+  return void 0;
+}
+function isCalendarDateDisabled(iso, options = {}) {
+  const { minDate, maxDate, isDateDisabled, disabled = false } = options;
+  if (disabled) return true;
+  const min = validBound(minDate);
+  const max = validBound(maxDate);
+  if (min !== null && iso < min) return true;
+  if (max !== null && iso > max) return true;
+  return isDateDisabled?.(iso) === true;
+}
+function buildCalendarGrid(monthKey, options = {}) {
+  const {
+    firstDayOfWeek = 0,
+    locale = "en-US",
+    selected = null,
+    range = null
+  } = options;
+  const weekdayNames = resolveCalendarWeekdayNames(locale, firstDayOfWeek);
+  const parts = parseCalendarMonth(monthKey);
+  if (parts === null) return { weeks: [], weekdayNames };
+  const dayCount = daysInCalendarMonth(parts.year, parts.monthIndex);
+  const blanks = leadingBlankCount(
+    parts.year,
+    parts.monthIndex,
+    firstDayOfWeek
+  );
+  const cells = [];
+  for (let i = 0; i < blanks; i += 1) cells.push(null);
+  for (let day = 1; day <= dayCount; day += 1) {
+    const iso = toCalendarDate(parts.year, parts.monthIndex, day);
+    const disabled = isCalendarDateDisabled(iso, options);
+    const inRange = range !== null && iso >= range.start && iso <= range.end;
+    cells.push({
+      iso,
+      day,
+      disabled,
+      selected: selected !== null && iso === selected,
+      range: range === null || !inRange ? null : iso === range.start && iso === range.end ? "start" : iso === range.start ? "start" : iso === range.end ? "end" : "inside"
+    });
+  }
+  while (cells.length % 7 !== 0) cells.push(null);
+  const weeks = [];
+  for (let i = 0; i < cells.length; i += 7) {
+    weeks.push(cells.slice(i, i + 7));
+  }
+  return { weeks, weekdayNames };
+}
+function clampDay(year, monthIndex, day) {
+  return Math.min(Math.max(1, day), daysInCalendarMonth(year, monthIndex));
+}
+function shiftCalendarDay(year, monthIndex, day, deltaDays) {
+  const shifted = new Date(Date.UTC(year, monthIndex, day + deltaDays));
+  return {
+    year: shifted.getUTCFullYear(),
+    monthIndex: shifted.getUTCMonth(),
+    day: shifted.getUTCDate()
+  };
+}
+function resolveCalendarFocus(currentISO, key, options = {}) {
+  const { firstDayOfWeek = 0, dir = "ltr" } = options;
+  const parts = parseCalendarDate(currentISO);
+  if (parts === null) return null;
+  const { year, monthIndex, day } = parts;
+  switch (key) {
+    case "ArrowLeft":
+    case "ArrowRight": {
+      const step = key === "ArrowLeft" ? -1 : 1;
+      const next = shiftCalendarDay(
+        year,
+        monthIndex,
+        day,
+        dir === "rtl" ? -step : step
+      );
+      return toCalendarDate(next.year, next.monthIndex, next.day);
+    }
+    case "ArrowUp":
+    case "ArrowDown": {
+      const next = shiftCalendarDay(
+        year,
+        monthIndex,
+        day,
+        key === "ArrowUp" ? -7 : 7
+      );
+      return toCalendarDate(next.year, next.monthIndex, next.day);
+    }
+    case "Home":
+    case "End": {
+      const blanks = leadingBlankCount(year, monthIndex, firstDayOfWeek);
+      const rowStart = day - (day - 1 + blanks) % 7;
+      const rowEnd = Math.min(
+        rowStart + 6,
+        daysInCalendarMonth(year, monthIndex)
+      );
+      const target = key === "Home" ? rowStart : rowEnd;
+      return toCalendarDate(
+        year,
+        monthIndex,
+        clampDay(year, monthIndex, target)
+      );
+    }
+    case "PageUp":
+    case "PageDown": {
+      const next = shiftCalendarMonth(
+        year,
+        monthIndex,
+        key === "PageUp" ? -1 : 1
+      );
+      return toCalendarDate(
+        next.year,
+        next.monthIndex,
+        clampDay(next.year, next.monthIndex, day)
+      );
+    }
+  }
+}
+function resolveCalendarSelection(iso, options = {}) {
+  const { mode = "single", range = null } = options;
+  if (parseCalendarDate(iso) === null) return null;
+  if (isCalendarDateDisabled(iso, options)) return null;
+  if (mode === "single") return { value: iso, range };
+  if (range === null || range.start !== range.end) {
+    return { value: iso, range: { start: iso, end: iso } };
+  }
+  const start = range.start <= iso ? range.start : iso;
+  const end = range.start <= iso ? iso : range.start;
+  return { value: iso, range: { start, end } };
+}
+
+// src/chatBranch.ts
+var import_react3 = require("react");
+function normalizeBranchIndex(index, count) {
+  if (count <= 0) return 0;
+  if (!Number.isFinite(index)) return 0;
+  return Math.min(Math.max(Math.floor(index), 0), count - 1);
+}
+function nextBranchIndex(index, count) {
+  if (count <= 0) return 0;
+  return Math.min(normalizeBranchIndex(index, count) + 1, count - 1);
+}
+function previousBranchIndex(index, count) {
+  if (count <= 0) return 0;
+  return Math.max(normalizeBranchIndex(index, count) - 1, 0);
+}
+function shouldHideBranchPicker(count, hideWhenSingleBranch = true) {
+  return hideWhenSingleBranch && count <= 1;
+}
+function useBranch(options) {
+  const count = Math.max(0, Math.floor(options.count));
+  const [raw, setRaw] = useControllableState(
+    options.value,
+    options.defaultValue ?? 0,
+    options.onChange
+  );
+  const index = normalizeBranchIndex(raw ?? 0, count);
+  const goTo = (0, import_react3.useCallback)(
+    (next2) => {
+      setRaw(normalizeBranchIndex(next2, count));
+    },
+    [count, setRaw]
+  );
+  const next = (0, import_react3.useCallback)(() => {
+    setRaw((previous2) => nextBranchIndex(previous2 ?? 0, count));
+  }, [count, setRaw]);
+  const previous = (0, import_react3.useCallback)(() => {
+    setRaw((previous2) => previousBranchIndex(previous2 ?? 0, count));
+  }, [count, setRaw]);
+  return { index, count, previous, next, goTo };
+}
+
+// src/chatMessage.ts
+function resolveChatMessageSpeaker(options) {
+  if (options.authorName?.trim()) return options.authorName.trim();
+  switch (options.role) {
+    case "user":
+      return "You";
+    case "assistant":
+      return "Assistant";
+    case "system":
+      return "System";
+    case "tool":
+      return "Tool";
+  }
+}
+function resolveChatMessageLabel(options) {
+  const speaker = resolveChatMessageSpeaker(options);
+  const text = options.text?.trim();
+  return text ? `${speaker}: ${text}` : speaker;
+}
+function isUserMessage(message) {
+  return message.role === "user";
+}
+
+// src/chatSource.ts
+function normalizeChatSources(sources) {
+  if (!sources) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const source of sources) {
+    const href = source.href.trim();
+    if (!href || seen.has(href)) continue;
+    seen.add(href);
+    out.push({ ...source, href });
+  }
+  return out;
+}
+function resolveChatSourceLabel(source) {
+  const title = source.title?.trim();
+  return title ? title : source.href.trim();
+}
+
+// src/chatStatus.ts
+function isChatBusy(status) {
+  return status === "submitted" || status === "streaming";
+}
+function isChatStreaming(status) {
+  return status === "streaming";
+}
+function isChatError(status) {
+  return status === "error";
+}
+
+// src/collection.ts
+var import_react4 = require("react");
+function defaultCollectionMatch(query, text) {
+  const needle = query.trim().toLowerCase();
+  if (needle === "") return true;
+  return text.toLowerCase().includes(needle);
+}
+function filterCollectionKeys(items, query, match = defaultCollectionMatch) {
+  return items.filter((item) => match(query, item.text)).map((item) => item.key);
+}
+function findCollectionText(items, key) {
+  return items.find((item) => item.key === key)?.text;
+}
+function useCollectionRegistry() {
+  const [items, setItems] = (0, import_react4.useState)([]);
+  const register = (0, import_react4.useCallback)((item) => {
+    setItems((previous) => {
+      const at = previous.findIndex((entry) => entry.key === item.key);
+      if (at === -1) return [...previous, item];
+      if (previous[at]?.text === item.text) return previous;
+      const next = [...previous];
+      next[at] = item;
+      return next;
+    });
+  }, []);
+  const unregister = (0, import_react4.useCallback)((key) => {
+    setItems(
+      (previous) => previous.some((entry) => entry.key === key) ? previous.filter((entry) => entry.key !== key) : previous
+    );
+  }, []);
+  return (0, import_react4.useMemo)(
+    () => ({ items, register, unregister }),
+    [items, register, unregister]
+  );
+}
+
+// src/dismissPolicy.ts
+function createDismissPolicy(options) {
+  const dismissible = options.dismissible ?? options.hasDismissHandler;
+  return {
+    canDismiss: dismissible,
+    // A close control is derived from the SAME value the triggers read, so the
+    // two can never disagree.
+    showClose: dismissible,
+    shouldDismiss: (trigger, enabled, triggers) => enabled && dismissible && triggers[trigger] === true
+  };
+}
+function dismissTriggersFor(surface) {
+  return {
+    scrim: surface.modal,
+    escape: surface.modal,
+    closeButton: surface.hasVisibleClose
+  };
+}
+
+// src/dismissWiring.ts
+function dismissBranchesFor(options) {
+  const armed = options.modal && options.dismissible;
+  return {
+    "outside-pointer": armed,
+    "focus-out": armed,
+    escape: armed,
+    // The system back button exists on native only, but the DECLARATION is
+    // platform-free: web simply never binds this branch, the same shape as the
+    // parity contract's `dismissalOnlyNative`. Declaring it here keeps the set
+    // identical on both sides instead of letting each renderer invent one.
+    "system-back": armed,
+    close: options.dismissible && options.hasVisibleClose
+  };
+}
+function shouldDismissOn(source, enabled, branches) {
+  return enabled && branches[source] === true;
+}
+
+// src/focusTrap.ts
+function nextTrapIndex(current, count, move, loop) {
+  if (count <= 0) return -1;
+  const at = Math.min(Math.max(current, 0), count - 1);
+  switch (move) {
+    case "first":
+      return 0;
+    case "last":
+      return count - 1;
+    case "next":
+      return at + 1 < count ? at + 1 : loop ? 0 : at;
+    case "previous":
+      return at - 1 >= 0 ? at - 1 : loop ? count - 1 : at;
+  }
+}
+function resolveAutofocus(count, autoFocusIndex) {
+  if (count <= 0) return { type: "none" };
+  if (autoFocusIndex !== void 0 && autoFocusIndex >= 0 && autoFocusIndex < count) {
+    return { type: "focus-stop", index: autoFocusIndex };
+  }
+  return { type: "focus-stop", index: 0 };
+}
+
+// src/form.ts
+function normalizeFieldErrors(error) {
+  if (error === void 0) return [];
+  return Array.isArray(error) ? [...error] : [error];
+}
+function mergeFormErrors(internal, server) {
+  const merged = {};
+  const names = /* @__PURE__ */ new Set([...Object.keys(internal), ...Object.keys(server)]);
+  for (const name of names) {
+    const fromServer = server[name];
+    if (fromServer !== void 0) {
+      merged[name] = fromServer;
+      continue;
+    }
+    const fromInternal = internal[name];
+    if (fromInternal !== void 0) merged[name] = fromInternal;
+  }
+  return merged;
+}
+function isEmptyValue(value) {
+  return value === void 0 || value === null || value === "";
+}
+
+// src/number.ts
+function formatNumberValue(value, spec = {}) {
+  if (value === null || !Number.isFinite(value)) return "";
+  const { locale, format } = spec;
+  try {
+    return new Intl.NumberFormat(locale, format).format(value);
+  } catch {
+    return String(value);
+  }
+}
+function parseNumberValue(text, spec = {}) {
+  if (typeof text !== "string") return null;
+  const trimmed = text.trim();
+  if (trimmed === "") return null;
+  let decimal = ".";
+  let grouping = ",";
+  try {
+    const parts = new Intl.NumberFormat(
+      spec.locale,
+      spec.format !== void 0 ? { ...spec.format, useGrouping: true } : void 0
+    ).formatToParts(12345.6);
+    for (const part of parts) {
+      if (part.type === "decimal") decimal = part.value;
+      if (part.type === "group") grouping = part.value;
+    }
+  } catch {
+  }
+  const compact = trimmed.split(" ").join("").split("\xA0").join("");
+  const noGrouping = grouping === "" ? compact : compact.split(grouping).join("");
+  const normalized = decimal === "." ? noGrouping : noGrouping.split(decimal).join(".");
+  if (!/^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/.test(normalized)) {
+    return null;
+  }
+  const parsed = Number.parseFloat(normalized);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function clampNumberValue(value, min, max) {
+  if (min !== void 0 && value < min) return min;
+  if (max !== void 0 && value > max) return max;
+  return value;
+}
+function stepNumberValue(value, direction, options = {}) {
+  const { step = 1, snapOnStep = false, min, max } = options;
+  const effective = step > 0 && Number.isFinite(step) ? step : 1;
+  const raw = value + direction * effective;
+  const snapped = snapOnStep && effective > 0 ? Math.round(raw / effective) * effective : raw;
+  const clean = snapOnStep && effective > 0 ? Number(snapped.toPrecision(12)) : snapped;
+  return clampNumberValue(clean, min, max);
+}
+
+// src/overlayModality.ts
+var import_react5 = require("react");
+function createOverlayModality() {
+  const stack = [];
+  const modalById = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const l of listeners) l();
+  };
+  return {
+    register(id, options) {
+      if (!stack.includes(id)) {
+        stack.push(id);
+        modalById.set(id, options?.modal ?? false);
+        emit();
+      }
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const i = stack.indexOf(id);
+        if (i !== -1) {
+          stack.splice(i, 1);
+          modalById.delete(id);
+          emit();
+        }
+      };
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getState() {
+      const snapshot = stack.slice();
+      const modalTop = [...snapshot].reverse().find((id) => modalById.get(id) === true) ?? null;
+      return {
+        top: snapshot.length ? snapshot[snapshot.length - 1] : null,
+        stack: snapshot,
+        modalTop,
+        isModalActive: modalTop !== null,
+        isTop: (id) => snapshot[snapshot.length - 1] === id,
+        isInertOutside: (id) => snapshot.length > 0 && snapshot[snapshot.length - 1] !== id
+      };
+    }
+  };
+}
+function useOverlayRegistration(registry, id, active = true, modal = false) {
+  const latest = (0, import_react5.useRef)({ registry, id, active, modal });
+  latest.current = { registry, id, active, modal };
+  (0, import_react5.useEffect)(() => {
+    if (!latest.current.active) return;
+    return latest.current.registry.register(latest.current.id, {
+      modal: latest.current.modal
+    });
+  }, [registry, id, active, modal]);
+}
+function useOverlayModality(registry) {
+  const [state, setState] = (0, import_react5.useState)(
+    () => registry.getState()
+  );
+  const read = (0, import_react5.useCallback)(() => setState(registry.getState()), [registry]);
+  (0, import_react5.useEffect)(() => {
+    read();
+    return registry.subscribe(read);
+  }, [registry, read]);
+  return state;
+}
+var sharedOverlayModality = null;
+function getSharedOverlayModality() {
+  if (!sharedOverlayModality) {
+    sharedOverlayModality = createOverlayModality();
+  }
+  return sharedOverlayModality;
+}
+
+// src/portal.ts
+function createPortalRegistry() {
+  const mounted = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const l of listeners) l();
+  };
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    mount(id) {
+      if (mounted.has(id)) return;
+      mounted.set(id, sequence++);
+      emit();
+    },
+    unmount(id) {
+      if (!mounted.has(id)) return;
+      mounted.delete(id);
+      emit();
+    },
+    order() {
+      return [...mounted.entries()].sort((a, b) => a[1] - b[1]).map(([id]) => id);
+    },
+    isMounted: (id) => mounted.has(id)
+  };
+}
+function resolvePortalTarget(options) {
+  return options.ownerProvided ?? options.defaultTarget ?? "kern-portal-root";
+}
+
+// src/positioning.ts
+function resolveFloatingOrigin(anchor, size, options) {
+  const placement = options?.placement ?? "bottom";
+  const offset = options?.offset ?? 0;
+  const align = options?.align ?? "center";
+  const alignOffset = options?.alignOffset ?? 0;
+  const cross = (anchorStart, anchorSpan, surfaceSpan) => {
+    if (align === "start") return anchorStart + alignOffset;
+    if (align === "end")
+      return anchorStart + anchorSpan - surfaceSpan + alignOffset;
+    return anchorStart + (anchorSpan - surfaceSpan) / 2 + alignOffset;
+  };
+  switch (placement) {
+    case "top":
+      return {
+        x: cross(anchor.x, anchor.width, size.width),
+        y: anchor.y - size.height - offset
+      };
+    case "left":
+      return {
+        x: anchor.x - size.width - offset,
+        y: cross(anchor.y, anchor.height, size.height)
+      };
+    case "right":
+      return {
+        x: anchor.x + anchor.width + offset,
+        y: cross(anchor.y, anchor.height, size.height)
+      };
+    case "bottom":
+      return {
+        x: cross(anchor.x, anchor.width, size.width),
+        y: anchor.y + anchor.height + offset
+      };
+  }
+}
+function clampRectToViewport(origin, size, viewport, padding) {
+  const pad = padding ?? 0;
+  const maxX = Math.max(pad, viewport.width - size.width - pad);
+  const maxY = Math.max(pad, viewport.height - size.height - pad);
+  return {
+    x: Math.min(Math.max(origin.x, pad), maxX),
+    y: Math.min(Math.max(origin.y, pad), maxY)
+  };
+}
+function resolveFloatingSide(anchor, size, options) {
+  const placement = options?.placement ?? "bottom";
+  if (!options?.viewport) return placement;
+  const pad = options.viewportPadding ?? 0;
+  const offset = options.offset ?? 0;
+  const viewport = options.viewport;
+  if (placement === "bottom") {
+    const bottomOverflow = anchor.y + anchor.height + offset + size.height - (viewport.height - pad);
+    const topFits = anchor.y - offset - size.height >= pad;
+    if (bottomOverflow > 0 && topFits) return "top";
+  } else if (placement === "top") {
+    const topOverflow = pad - (anchor.y - offset - size.height);
+    const bottomFits = anchor.y + anchor.height + offset + size.height <= viewport.height - pad;
+    if (topOverflow > 0 && bottomFits) return "bottom";
+  } else if (placement === "right") {
+    const rightOverflow = anchor.x + anchor.width + offset + size.width - (viewport.width - pad);
+    const leftFits = anchor.x - offset - size.width >= pad;
+    if (rightOverflow > 0 && leftFits) return "left";
+  } else if (placement === "left") {
+    const leftOverflow = pad - (anchor.x - offset - size.width);
+    const rightFits = anchor.x + anchor.width + offset + size.width <= viewport.width - pad;
+    if (leftOverflow > 0 && rightFits) return "right";
+  }
+  return placement;
+}
+function resolveFloatingRect(anchor, size, options) {
+  const placement = options?.flip ? resolveFloatingSide(anchor, size, options) : options?.placement;
+  const origin = resolveFloatingOrigin(anchor, size, { ...options, placement });
+  if (!options?.viewport) return origin;
+  return clampRectToViewport(
+    origin,
+    size,
+    options.viewport,
+    options.viewportPadding
+  );
+}
+
+// src/presence.ts
+var import_react6 = require("react");
+function nextPresenceState(current, open) {
+  if (open) return "mounted";
+  return current === "unmounted" ? "unmounted" : "exiting";
+}
+function createPresenceModel(initialOpen) {
+  let state = initialOpen ? "mounted" : "unmounted";
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const l of listeners) l();
+  };
+  const setState = (next) => {
+    if (next === state) return;
+    state = next;
+    emit();
+  };
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getState: () => state,
+    setOpen: (open) => setState(nextPresenceState(state, open)),
+    finishExit: () => {
+      if (state === "exiting") setState("unmounted");
+    },
+    isPresent: () => state !== "unmounted"
+  };
+}
+function usePresence(open) {
+  const [model] = (0, import_react6.useState)(() => createPresenceModel(open));
+  const state = (0, import_react6.useSyncExternalStore)(
+    (listener) => model.subscribe(listener),
+    () => model.getState()
+  );
+  (0, import_react6.useEffect)(() => {
+    model.setOpen(open);
+  }, [model, open]);
+  return {
+    present: state !== "unmounted",
+    state,
+    finishExit: model.finishExit
+  };
+}
+
+// src/press.ts
+var import_react7 = require("react");
+function createPressModel(options) {
+  const disabled = options?.disabled ?? false;
+  const onPress = options?.onPress;
+  let phase = "idle";
+  return {
+    getPhase: () => phase,
+    isPressed: () => phase === "pressed",
+    isDisabled: () => disabled,
+    begin: () => {
+      if (disabled || phase === "pressed") return;
+      phase = "pressed";
+    },
+    end: () => {
+      if (disabled || phase !== "pressed") return;
+      phase = "idle";
+      onPress?.();
+    },
+    cancel: () => {
+      phase = "idle";
+    }
+  };
+}
+function usePress(options) {
+  const [model] = (0, import_react7.useState)(() => createPressModel(options));
+  const [pressed, setPressed] = (0, import_react7.useState)(false);
+  const sync = (0, import_react7.useCallback)(() => setPressed(model.isPressed()), [model]);
+  const begin = (0, import_react7.useCallback)(() => {
+    model.begin();
+    sync();
+  }, [model, sync]);
+  const end = (0, import_react7.useCallback)(() => {
+    model.end();
+    sync();
+  }, [model, sync]);
+  const cancel = (0, import_react7.useCallback)(() => {
+    model.cancel();
+    sync();
+  }, [model, sync]);
+  return { pressed, begin, end, cancel };
+}
+
+// src/promptInput.ts
+var import_react8 = require("react");
+function resolveCanSend(options) {
+  if (!options.text.trim()) return false;
+  if (isChatBusy(options.status)) return false;
+  if (options.maxLength !== void 0 && options.text.length > options.maxLength) {
+    return false;
+  }
+  return true;
+}
+function shouldSubmitOnKey(options) {
+  if (options.key !== "Enter") return false;
+  switch (options.submitMode) {
+    case "enter":
+      return !options.shiftKey;
+    case "ctrlEnter":
+      return Boolean(options.ctrlKey || options.metaKey);
+    case "none":
+      return false;
+  }
+}
+function shouldCancelOnEscapeKey(key, cancelOnEscape) {
+  return cancelOnEscape && key === "Escape";
+}
+function resolveComposerHeight(options) {
+  const minLines = Math.max(1, options.minLines ?? 1);
+  const maxLines = Math.max(minLines, options.maxLines ?? 5);
+  const lines = Math.min(Math.max(options.lineCount, minLines), maxLines);
+  return lines * options.lineHeight;
+}
+function usePromptInput(options) {
+  const [raw, setRaw] = useControllableState(
+    options?.value,
+    options?.defaultValue ?? "",
+    options?.onChange
+  );
+  const value = raw ?? "";
+  const {
+    status = "idle",
+    submitMode = "enter",
+    cancelOnEscape = false,
+    maxLength,
+    onSubmit
+  } = options ?? {};
+  const canSend = resolveCanSend({ text: value, status, maxLength });
+  const setValue = (0, import_react8.useCallback)(
+    (next) => {
+      setRaw(next);
+    },
+    [setRaw]
+  );
+  const clear = (0, import_react8.useCallback)(() => {
+    setRaw("");
+  }, [setRaw]);
+  const submit = (0, import_react8.useCallback)(() => {
+    if (!resolveCanSend({ text: value, status, maxLength })) return;
+    onSubmit?.(value);
+  }, [value, status, maxLength, onSubmit]);
+  const handleKey = (0, import_react8.useCallback)(
+    (event) => {
+      if (shouldSubmitOnKey({ ...event, submitMode }) && resolveCanSend({ text: value, status, maxLength })) {
+        onSubmit?.(value);
+        return true;
+      }
+      if (shouldCancelOnEscapeKey(event.key, cancelOnEscape)) {
+        setRaw("");
+        return true;
+      }
+      return false;
+    },
+    [value, status, maxLength, submitMode, cancelOnEscape, onSubmit, setRaw]
+  );
+  return { value, setValue, canSend, submit, clear, handleKey };
+}
+
+// src/reasoning.ts
+function resolveReasoningOpen(open, status) {
+  if (status === "streaming") return true;
+  return open ?? false;
+}
+
+// src/render.ts
+var import_react9 = require("react");
+
+// src/slot.ts
+function isHandler(value) {
+  return typeof value === "function";
+}
+function composeEventHandlers(partHandler, consumerHandler) {
+  if (!partHandler) return consumerHandler;
+  if (!consumerHandler) return partHandler;
+  return (event) => {
+    partHandler(event);
+    consumerHandler(event);
+  };
+}
+function flattenStyleProp(style) {
+  if (Array.isArray(style)) {
+    const out = {};
+    for (const entry of style) {
+      Object.assign(out, flattenStyleProp(entry));
+    }
+    return out;
+  }
+  if (typeof style === "object" && style !== null) {
+    return { ...style };
+  }
+  return {};
+}
+function mergeSlotProps(partProps, ...consumerSets) {
+  const merged = { ...partProps };
+  for (const set of consumerSets) {
+    if (!set) continue;
+    for (const key of Object.keys(set)) {
+      const incoming = set[key];
+      if (incoming === void 0) continue;
+      const current = merged[key];
+      if (key.startsWith("on") && isHandler(current) && isHandler(incoming)) {
+        merged[key] = composeEventHandlers(
+          current,
+          incoming
+        );
+        continue;
+      }
+      if (key === "className" && typeof current === "string" && typeof incoming === "string") {
+        merged[key] = `${current} ${incoming}`;
+        continue;
+      }
+      if (key === "style" && (typeof current === "object" || Array.isArray(current)) && current !== null && (typeof incoming === "object" || Array.isArray(incoming)) && incoming !== null) {
+        merged[key] = {
+          ...flattenStyleProp(current),
+          ...flattenStyleProp(incoming)
+        };
+        continue;
+      }
+      merged[key] = incoming;
+    }
+  }
+  return merged;
+}
+
+// src/render.ts
+function resolveStyle(style, state) {
+  if (typeof style === "function") {
+    return style(state);
+  }
+  return style;
+}
+function resolveRender(render, partProps, state) {
+  if (render === void 0 || render === null) return null;
+  if (typeof render === "function") {
+    return render(partProps, state);
+  }
+  if ((0, import_react9.isValidElement)(render)) {
+    const merged = mergeSlotProps(
+      partProps,
+      render.props ?? {}
+    );
+    const element = render;
+    return (0, import_react9.cloneElement)(element, {
+      ...merged,
+      className: void 0
+    });
+  }
+  return null;
+}
+
+// src/roving.ts
+var import_react10 = require("react");
+function clamp(index, count) {
+  if (count <= 0) return 0;
+  return Math.min(Math.max(index, 0), count - 1);
+}
+function createRovingModel(options) {
+  const {
+    count,
+    orientation = "horizontal",
+    loop = false,
+    isDisabled = () => false
+  } = options;
+  const controlled = options.activeIndex !== void 0;
+  let current = clamp(
+    options.activeIndex ?? options.defaultActiveIndex ?? 0,
+    count
+  );
+  const listeners = [];
+  const notify = (next) => {
+    for (const fn of listeners) fn(next);
+  };
+  const commit = (raw) => {
+    const next = clamp(raw, count);
+    if (next === current) return;
+    if (controlled) {
+      options.onActiveIndexChange?.(next);
+      return;
+    }
+    current = next;
+    notify(next);
+  };
+  const step = (delta) => {
+    if (count <= 0) return current;
+    const span = count;
+    let index = current;
+    for (let probe = 0; probe < span; probe += 1) {
+      index += delta;
+      if (index < 0 || index > span - 1) {
+        if (!loop) return current;
+        index = (index + span) % span;
+      }
+      if (!isDisabled(index)) break;
+    }
+    if (isDisabled(index)) return current;
+    commit(index);
+    return current;
+  };
+  return {
+    get activeIndex() {
+      return current;
+    },
+    set activeIndex(value) {
+      commit(value);
+    },
+    setActive: commit,
+    next: () => step(1),
+    previous: () => step(-1),
+    // `commit` reports rather than returns, so these read `current` back rather
+    // than returning its void.
+    first: () => {
+      commit(0);
+      return current;
+    },
+    last: () => {
+      commit(count - 1);
+      return current;
+    },
+    describe: (index) => {
+      const disabled = count > 0 && isDisabled(index);
+      const isActive = count > 0 && !disabled && clamp(index, count) === current;
+      return {
+        index,
+        isActive,
+        // EXACTLY ONE tabbable item per group — the whole point of the model.
+        // When the active item is disabled there is none, which is correct: a
+        // group whose only stop is disabled contributes no tab stop.
+        isTabbable: isActive,
+        disabled
+      };
+    },
+    orientation,
+    loop
+  };
+}
+function useRovingModel(options) {
+  const controlled = options.activeIndex !== void 0;
+  const [internal, setInternal] = (0, import_react10.useState)(
+    () => clamp(options.defaultActiveIndex ?? 0, options.count)
+  );
+  const model = createRovingModel({
+    ...options,
+    // Always pass the resolved value, so the model behaves as controlled and
+    // reports changes rather than mutating its own copy.
+    activeIndex: controlled ? options.activeIndex ?? 0 : internal,
+    onActiveIndexChange: (next) => {
+      if (!controlled) setInternal(next);
+      options.onActiveIndexChange?.(next);
+    }
+  });
+  return model;
+}
+
+// src/selection.ts
+var import_react11 = require("react");
+function normalizeSelection(value, mode) {
+  if (value === void 0) return [];
+  const list = typeof value === "string" || typeof value === "number" ? [value] : value;
+  if (mode !== "multiple") return list.slice(0, 1);
+  return [...new Set(list)];
+}
+function isSelected(selected, key) {
+  return selected.includes(key);
+}
+function toggleSelection(selected, key, mode) {
+  if (mode === "single-toggle") {
+    return selected[0] === key ? [] : [key];
+  }
+  if (mode === "single") return [key];
+  return selected.includes(key) ? selected.filter((entry) => entry !== key) : [...selected, key];
+}
+function sameSelection(a, b) {
+  if (a.length !== b.length) return false;
+  const setA = new Set(a);
+  return b.every((entry) => setA.has(entry));
+}
+function useSelection({
+  value,
+  defaultValue,
+  onChange,
+  mode
+}) {
+  const notify = (0, import_react11.useCallback)(
+    (next) => {
+      onChange?.(normalizeSelection(next, mode));
+    },
+    [onChange, mode]
+  );
+  const [raw, setRaw] = useControllableState(
+    value,
+    defaultValue,
+    notify
+  );
+  const selected = (0, import_react11.useMemo)(() => normalizeSelection(raw, mode), [raw, mode]);
+  const select = (0, import_react11.useCallback)(
+    (key) => {
+      setRaw((previous) => {
+        const current = normalizeSelection(previous, mode);
+        const updated = toggleSelection(current, key, mode);
+        if (sameSelection(current, updated)) return previous;
+        return updated;
+      });
+    },
+    [mode, setRaw]
+  );
+  return [selected, select];
+}
+
+// src/slider.ts
+function clampSliderValue(value, min, max) {
+  const hi = max > min ? max : min;
+  if (!Number.isFinite(value)) return min;
+  return Math.min(Math.max(value, min), hi);
+}
+function snapSliderValue(value, min, step) {
+  if (!Number.isFinite(step) || step <= 0) return value;
+  return min + Math.round((value - min) / step) * step;
+}
+function sliderValuePercent(value, min, max) {
+  const hi = max > min ? max : min;
+  const range = hi - min;
+  if (range <= 0) return 0;
+  return (clampSliderValue(value, min, max) - min) / range * 100;
+}
+function normalizeSliderValues(value, min, max) {
+  const list = Array.isArray(value) ? [...value] : [value];
+  if (list.length === 0) return [min];
+  return list.map(
+    (v) => clampSliderValue(
+      typeof v === "number" && Number.isFinite(v) ? v : min,
+      min,
+      max
+    )
+  );
+}
+function sliderRatioFromLocation(location, extent, orientation) {
+  if (!(extent > 0)) return 0;
+  const ratio = location / extent;
+  const clamped = Math.min(Math.max(ratio, 0), 1);
+  return orientation === "vertical" ? 1 - clamped : clamped;
+}
+function sliderValueFromRatio(ratio, min, max) {
+  const hi = max > min ? max : min;
+  return min + Math.min(Math.max(ratio, 0), 1) * (hi - min);
+}
+function nearestSliderThumbIndex(values, target) {
+  let best = 0;
+  let bestDistance = Infinity;
+  for (let i = 0; i < values.length; i++) {
+    const distance = Math.abs((values[i] ?? 0) - target);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = i;
+    }
+  }
+  return best;
+}
+function resolveSliderCommit(values, index, next, options) {
+  const { min, max, step, minStepsBetweenValues } = options;
+  const clamped = clampSliderValue(next, min, max);
+  const snapped = clampSliderValue(
+    snapSliderValue(clamped, min, step),
+    min,
+    max
+  );
+  if (values.length < 2) return [snapped];
+  const gapSteps = Math.max(0, minStepsBetweenValues);
+  const gap = step > 0 && Number.isFinite(step) ? gapSteps * step : gapSteps;
+  const updated = [...values];
+  const at = Math.min(Math.max(index, 0), updated.length - 1);
+  updated[at] = snapped;
+  const lower = at > 0 ? (updated[at - 1] ?? min) + gap : min;
+  const upper = at < updated.length - 1 ? (updated[at + 1] ?? max) - gap : max;
+  const lo = Math.min(lower, upper);
+  const hi = Math.max(lower, upper);
+  updated[at] = Math.min(Math.max(snapped, lo), hi);
+  return updated;
+}
+
+// src/stickToBottom.ts
+var import_react12 = require("react");
+function distanceToBottom(metrics) {
+  return metrics.contentHeight - metrics.viewportHeight - metrics.scrollOffset;
+}
+function isAtBottom(metrics, threshold = 24) {
+  return distanceToBottom(metrics) <= threshold;
+}
+function resolveScrollButtonVisible(options) {
+  return !options.stuck && options.contentHeight > options.viewportHeight;
+}
+function useStickToBottom(options) {
+  const threshold = options?.threshold ?? 24;
+  const [stuck, setStuck] = useControllableState(
+    options?.stuck,
+    options?.defaultStuck ?? true,
+    options?.onStuckChange
+  );
+  const pinned = stuck ?? true;
+  const handleScroll = (0, import_react12.useCallback)(
+    (metrics) => {
+      setStuck(isAtBottom(metrics, threshold));
+    },
+    [setStuck, threshold]
+  );
+  const handleContentChange = (0, import_react12.useCallback)(
+    (metrics) => {
+      const atBottom = isAtBottom(metrics, threshold);
+      if (!pinned) return false;
+      if (!atBottom) setStuck(false);
+      return atBottom;
+    },
+    [pinned, setStuck, threshold]
+  );
+  const scrollToBottom = (0, import_react12.useCallback)(() => {
+    setStuck(true);
+  }, [setStuck]);
+  const showScrollButton = (0, import_react12.useCallback)(
+    (metrics) => resolveScrollButtonVisible({
+      stuck: pinned,
+      contentHeight: metrics.contentHeight,
+      viewportHeight: metrics.viewportHeight
+    }),
+    [pinned]
+  );
+  return {
+    stuck: pinned,
+    showScrollButton,
+    handleScroll,
+    handleContentChange,
+    scrollToBottom
+  };
+}
+
+// src/time.ts
+function minutesForStep(step) {
+  const valid = Number.isInteger(step) && step > 0 && Number.isInteger(60 / step);
+  if (!valid) {
+    return Array.from({ length: 60 }, (_, i) => i);
+  }
+  return Array.from({ length: 60 / step }, (_, i) => i * step);
+}
+function normalizeTimeValue(value, step = 1) {
+  const options = minutesForStep(step);
+  const hours = Number.isFinite(value?.hours) ? Math.min(Math.max(Math.trunc(value?.hours ?? 0), 0), 23) : 0;
+  const rawMinutes = Number.isFinite(value?.minutes) ? Math.trunc(value?.minutes ?? 0) : 0;
+  let minutes = 0;
+  for (const option of options) {
+    if (option <= rawMinutes) minutes = option;
+  }
+  return { hours, minutes };
+}
+function formatTimeValue(value, format) {
+  const normalised = normalizeTimeValue(value);
+  if (format === "24h") {
+    return {
+      hours: normalised.hours,
+      period: normalised.hours < 12 ? "AM" : "PM"
+    };
+  }
+  const twelve = normalised.hours % 12 === 0 ? 12 : normalised.hours % 12;
+  return { hours: twelve, period: normalised.hours < 12 ? "AM" : "PM" };
+}
+function toTwentyFourHour(twelveHour, period) {
+  const base = twelveHour % 12;
+  return period === "PM" ? base + 12 : base;
+}
+function formatDigits(value, digits, locale) {
+  try {
+    return new Intl.NumberFormat(locale, {
+      minimumIntegerDigits: digits,
+      useGrouping: false
+    }).format(value);
+  } catch {
+    return String(value).padStart(digits, "0");
+  }
+}
+function resolveDayPeriod(locale, hours24) {
+  try {
+    const format = new Intl.DateTimeFormat(locale, {
+      hour: "numeric",
+      hour12: true
+    });
+    const found = format.formatToParts(new Date(Date.UTC(2026, 0, 1, hours24))).find((part) => part.type === "dayPeriod")?.value;
+    if (found !== void 0) return found;
+  } catch {
+  }
+  return hours24 < 12 ? "AM" : "PM";
+}
+function formatTimeParts(value, format = "24h", locale) {
+  const normalised = normalizeTimeValue(value);
+  if (format === "24h") {
+    return {
+      hours: formatDigits(normalised.hours, 2, locale),
+      minutes: formatDigits(normalised.minutes, 2, locale),
+      period: null
+    };
+  }
+  const twelve = normalised.hours % 12 === 0 ? 12 : normalised.hours % 12;
+  return {
+    hours: formatDigits(twelve, 1, locale),
+    minutes: formatDigits(normalised.minutes, 2, locale),
+    period: resolveDayPeriod(locale, normalised.hours)
+  };
+}
+function addTimeMinutes(value, deltaMinutes, step = 1) {
+  const base = normalizeTimeValue(value, step);
+  const delta = Number.isFinite(deltaMinutes) ? Math.trunc(deltaMinutes) : 0;
+  const total = base.hours * 60 + base.minutes + delta;
+  const wrapped = (total % 1440 + 1440) % 1440;
+  return normalizeTimeValue(
+    { hours: Math.floor(wrapped / 60), minutes: wrapped % 60 },
+    step
+  );
+}
+
+// src/toastQueue.ts
+function createToastQueue() {
+  const queued = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  let version = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    version += 1;
+    for (const l of listeners) l();
+  };
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    add(id) {
+      if (queued.has(id)) return;
+      queued.set(id, sequence++);
+      emit();
+    },
+    dismiss(id) {
+      if (!queued.has(id)) return;
+      queued.delete(id);
+      emit();
+    },
+    clear() {
+      if (queued.size === 0) return;
+      queued.clear();
+      emit();
+    },
+    order() {
+      return [...queued.entries()].sort((a, b) => a[1] - b[1]).map(([id]) => id);
+    },
+    isOpen: (id) => queued.has(id),
+    count: () => queued.size,
+    version: () => version
+  };
+}
+
+// src/toolCall.ts
+var import_react13 = require("react");
+function isToolCallRunning(state) {
+  return state === "input-streaming" || state === "input-available";
+}
+function isToolCallComplete(state) {
+  return state === "output-available" || state === "output-denied";
+}
+function isToolCallError(state) {
+  return state === "output-error";
+}
+function isToolCallApproval(state) {
+  return state === "approval-requested";
+}
+function resolveToolCallLabel(options) {
+  const { name, state } = options;
+  switch (state) {
+    case "input-streaming":
+      return `Tool ${name} running`;
+    case "input-available":
+      return `Tool ${name} queued`;
+    case "output-available":
+      return `Tool ${name} completed`;
+    case "output-denied":
+      return `Tool ${name} denied`;
+    case "approval-requested":
+      return `Tool ${name} needs approval`;
+    case "output-error": {
+      const detail = options.errorText?.trim();
+      return detail ? `Tool ${name} failed: ${detail}` : `Tool ${name} failed`;
+    }
+  }
+}
+function useToolCall(options) {
+  const [state, setState] = useControllableState(
+    options?.state,
+    options?.defaultState ?? "input-streaming",
+    options?.onStateChange
+  );
+  const current = state ?? "input-streaming";
+  const { onApprove, onDeny } = options ?? {};
+  const approve = (0, import_react13.useCallback)(() => {
+    if (current !== "approval-requested") return;
+    setState("input-available");
+    onApprove?.();
+  }, [current, setState, onApprove]);
+  const deny = (0, import_react13.useCallback)(() => {
+    if (current !== "approval-requested") return;
+    setState("output-denied");
+    onDeny?.();
+  }, [current, setState, onDeny]);
+  return { state: current, approve, deny };
+}
+
+// src/typeahead.ts
+function appendTypeaheadQuery(previous, char, now, timeout = 500) {
+  if (char.length !== 1) return previous ?? { text: "", at: now };
+  if (!previous || now - previous.at > timeout) return { text: char, at: now };
+  return { text: previous.text + char, at: now };
+}
+function isTypeaheadExpired(buffer, now, timeout = 500) {
+  if (!buffer || buffer.text === "") return true;
+  return now - buffer.at > timeout;
+}
+function matchTypeaheadKey(items, query, fromKey) {
+  const buffer = query.toLowerCase();
+  if (buffer === "" || items.length === 0) return void 0;
+  const first = buffer.charAt(0);
+  const repeating = buffer.length > 1 && buffer.split("").every((char) => char === first);
+  const needle = repeating ? first : buffer;
+  const matches = (text) => text.toLowerCase().startsWith(needle);
+  if (!repeating) {
+    return items.find((item) => matches(item.text))?.key;
+  }
+  const from = fromKey === void 0 || fromKey === null ? -1 : items.findIndex((item) => item.key === fromKey);
+  for (let step = 1; step <= items.length; step += 1) {
+    const index = (from + step + items.length * 2) % items.length;
+    const item = items[index];
+    if (item && matches(item.text)) return item.key;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addTimeMinutes,
+  appendTypeaheadQuery,
+  buildCalendarGrid,
+  clampNumberValue,
+  clampSliderValue,
+  composeEventHandlers,
+  createDismissPolicy,
+  createIdScope,
+  createOverlayModality,
+  createPortalRegistry,
+  createPresenceModel,
+  createToastQueue,
+  daysInCalendarMonth,
+  defaultCollectionMatch,
+  dismissBranchesFor,
+  dismissTriggersFor,
+  filterCollectionKeys,
+  findCollectionText,
+  formatNumberValue,
+  formatTimeParts,
+  formatTimeValue,
+  getSharedOverlayModality,
+  isAtBottom,
+  isCalendarDateDisabled,
+  isChatBusy,
+  isChatError,
+  isChatStreaming,
+  isEmptyValue,
+  isSelected,
+  isToolCallApproval,
+  isToolCallComplete,
+  isToolCallError,
+  isToolCallRunning,
+  isTypeaheadExpired,
+  isUserMessage,
+  leadingBlankCount,
+  matchTypeaheadKey,
+  mergeFormErrors,
+  mergeSlotProps,
+  minutesForStep,
+  nearestSliderThumbIndex,
+  nextBranchIndex,
+  nextPresenceState,
+  nextTrapIndex,
+  normalizeBranchIndex,
+  normalizeChatSources,
+  normalizeFieldErrors,
+  normalizeSelection,
+  normalizeSliderValues,
+  normalizeTimeValue,
+  parseCalendarDate,
+  parseCalendarMonth,
+  parseNumberValue,
+  previousBranchIndex,
+  resolveAutofocus,
+  resolveCalendarFocus,
+  resolveCalendarMonthNames,
+  resolveCalendarSelection,
+  resolveCalendarWeekdayNames,
+  resolveCanSend,
+  resolveChatMessageLabel,
+  resolveChatMessageSpeaker,
+  resolveChatSourceLabel,
+  resolveComposerHeight,
+  resolveDir,
+  resolveFloatingRect,
+  resolveFloatingSide,
+  resolveLocaleFirstDay,
+  resolvePortalTarget,
+  resolveReasoningOpen,
+  resolveRender,
+  resolveScrollButtonVisible,
+  resolveSliderCommit,
+  resolveStyle,
+  resolveToolCallLabel,
+  shiftCalendarMonth,
+  shouldCancelOnEscapeKey,
+  shouldDismissOn,
+  shouldHideBranchPicker,
+  shouldSubmitOnKey,
+  sliderRatioFromLocation,
+  sliderValueFromRatio,
+  sliderValuePercent,
+  snapSliderValue,
+  stepNumberValue,
+  toCalendarDate,
+  toCalendarMonth,
+  toTwentyFourHour,
+  toggleSelection,
+  updateAttachment,
+  useAttachments,
+  useBranch,
+  useCollectionRegistry,
+  useControllableState,
+  useOverlayModality,
+  useOverlayRegistration,
+  usePresence,
+  usePress,
+  usePromptInput,
+  useRovingModel,
+  useSelection,
+  useStickToBottom,
+  useToolCall,
+  validateAttachment
+});