@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-2FSBSCZJ.js

@@ -0,0 +1,451 @@
+"use client";
+import {
+  createOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/recordings-model.ts
+import {
+  recordingMicrophoneIsOwner,
+  recordingSpeakerDefault
+} from "@opengeni/contracts";
+var defaultText = createOpenGeniText();
+function formatClock(milliseconds) {
+  const total = Math.max(0, Math.floor(milliseconds / 1e3));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const seconds = total % 60;
+  const ss = String(seconds).padStart(2, "0");
+  return hours > 0 ? `${hours}:${String(minutes).padStart(2, "0")}:${ss}` : `${minutes}:${ss}`;
+}
+function formatDuration(milliseconds, msg = defaultText) {
+  const seconds = Math.round(Math.max(0, milliseconds) / 1e3);
+  if (seconds < 60) return msg("meetings.recordings.durationSeconds", { seconds });
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return msg("meetings.recordings.durationMinutes", { minutes });
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return rest === 0 ? msg("meetings.recordings.durationHours", { hours }) : msg("meetings.recordings.durationHoursMinutes", { hours, minutes: rest });
+}
+function meetingPhase(recording) {
+  if (recording.state === "capturing") return { kind: "uploading" };
+  const version = recording.transcript;
+  if (version?.state === "complete") return { kind: "ready", version };
+  if (version?.state === "queued" || version?.state === "processing") {
+    return { kind: "transcribing", version };
+  }
+  if (version?.state === "failed" || recording.state === "failed") {
+    return { kind: "failed", version: version ?? null };
+  }
+  if (recording.state === "processing") return { kind: "transcribing", version: null };
+  return { kind: "no_transcript" };
+}
+function meetingHereStatus(recorder, recordingId, online = true) {
+  if (!recorder) return null;
+  if (recorder.recordingId !== recordingId) {
+    const upload2 = recorder.uploads?.[recordingId];
+    if (!upload2 || upload2.discarded) return null;
+    if (upload2.failed) return "upload_failed";
+    if (upload2.finalized) return "transcribing";
+    if (!online || upload2.retryingAfterError) return "waiting_for_connection";
+    return "uploading";
+  }
+  if (recorder.state === "recording") return "recording";
+  if (recorder.state === "paused") return "paused";
+  if (recorder.state === "idle" || recorder.state === "starting") return null;
+  const upload = recorder.upload;
+  if (upload?.discarded) return null;
+  if (upload?.failed) return "upload_failed";
+  if (recorder.state === "failed" && !upload?.finalized) return null;
+  if (!upload?.finalized && (!online || upload?.retryingAfterError)) {
+    return "waiting_for_connection";
+  }
+  return "transcribing";
+}
+function meetingUploadFailure(recorder, recordingId) {
+  if (!recorder) return null;
+  const upload = recorder.recordingId === recordingId ? recorder.upload : recorder.uploads?.[recordingId];
+  return upload?.failed ?? null;
+}
+var SHORT_AUDIO_MILLISECONDS = 5 * 6e4;
+function transcribingText(durationMilliseconds, msg = defaultText) {
+  if (durationMilliseconds <= SHORT_AUDIO_MILLISECONDS) {
+    return msg("meetings.detailPage.transcribingThisUsuallyTakesA");
+  }
+  return msg("meetings.detailPage.transcribingLongAudio", {
+    duration: formatDuration(durationMilliseconds, msg)
+  });
+}
+function transcriptNeedsCredits(code) {
+  return code === "insufficient_credits" || code === "allowance_exhausted" || code === "monthly_model_cost_limit";
+}
+var PROVIDER_FAILURES = /* @__PURE__ */ new Set([
+  "missing_provider_key",
+  "provider_unauthorized",
+  "provider_quota_exceeded",
+  "policy_blocked"
+]);
+var MODEL_FAILURES = /* @__PURE__ */ new Set([
+  "provider_too_large",
+  "provider_not_supported",
+  "model_unavailable"
+]);
+function transcriptFixModel(code, failed, models) {
+  const credits = transcriptNeedsCredits(code);
+  if (!code || !credits && !PROVIDER_FAILURES.has(code) && !MODEL_FAILURES.has(code)) {
+    return null;
+  }
+  const charged = (entry) => entry.chargedInCredits ?? (entry.funding === "deployment" && entry.usdPerHour !== null);
+  const rank = (entry) => entry.funding === "workspace_subscription" ? 0 : charged(entry) ? 3 : entry.usdPerHour === null ? 1 : 2;
+  const candidates = models.filter((entry) => {
+    if (!entry.available || !entry.capabilities.batch) return false;
+    if (failed && entry.providerId === failed.providerId) {
+      if (!MODEL_FAILURES.has(code) || entry.model === failed.model) return false;
+    }
+    return !credits || !charged(entry);
+  });
+  return [...candidates].sort((a, b) => rank(a) - rank(b))[0] ?? null;
+}
+function meetingStatusLabel(phase, msg = defaultText) {
+  switch (phase.kind) {
+    case "uploading":
+      return { label: msg("meetings.recordings.inProgress"), tone: "progress" };
+    case "transcribing":
+      return { label: msg("meetings.recordings.transcribing"), tone: "progress" };
+    case "failed":
+      return { label: msg("meetings.recordings.transcriptFailed"), tone: "danger" };
+    case "no_transcript":
+      return { label: msg("meetings.recordings.noTranscript"), tone: "neutral" };
+    case "ready":
+      return null;
+  }
+}
+function transcriptErrorText(code, msg = defaultText, model) {
+  switch (code) {
+    case "missing_provider_key": {
+      if (!model) return msg("meetings.recordings.errorMissingProviderKey");
+      const names = { modelName: model.modelName, providerName: model.providerName };
+      if (model.funding === "deployment") {
+        return model.pinned ? msg("meetings.recordings.errorMissingProviderKeyForDeploymentPinned", names) : msg("meetings.recordings.errorMissingProviderKeyForDeployment", names);
+      }
+      return model.pinned ? msg("meetings.recordings.errorMissingProviderKeyForPinned", names) : msg("meetings.recordings.errorMissingProviderKeyFor", names);
+    }
+    case "provider_unauthorized":
+      return msg("meetings.recordings.errorProviderUnauthorized");
+    case "provider_quota_exceeded":
+      return msg("meetings.recordings.errorProviderQuotaExceeded");
+    case "provider_too_large":
+      return msg("meetings.recordings.errorProviderTooLarge");
+    case "provider_not_supported":
+    case "model_unavailable":
+      return msg("meetings.recordings.errorModelUnavailable");
+    case "invalid_audio":
+    case "provider_invalid_audio":
+    case "ffmpeg_failed":
+      return msg("meetings.recordings.errorInvalidAudio");
+    case "storage_unavailable":
+      return msg("meetings.recordings.errorStorageUnavailable");
+    case "region_restricted":
+      return msg("inferenceRegion.notSupportedInEu");
+    case "insufficient_credits":
+      return model ? msg("meetings.recordings.errorInsufficientCreditsFor", { modelName: model.modelName }) : msg("meetings.recordings.errorInsufficientCredits");
+    case "allowance_exhausted":
+      return msg("meetings.recordings.errorAllowanceExhausted");
+    case "monthly_model_cost_limit":
+      return msg("meetings.recordings.errorMonthlyCostLimit");
+    case "policy_blocked":
+      return msg("meetings.recordings.errorPolicyBlocked");
+    case "timed_out":
+      return msg("meetings.recordings.errorTimedOut");
+    default:
+      return msg("meetings.recordings.errorUnknown");
+  }
+}
+function speakerDisplayName(label, speakers, tracks, msg = defaultText) {
+  if (!label) return msg("meetings.recordings.unknownSpeaker");
+  const speaker = speakers.find((candidate) => candidate.label === label);
+  if (speaker && speakerIsNamed(label, speakers) && speaker.name.trim()) return speaker.name;
+  return defaultSpeakerName(label, tracks, msg);
+}
+function defaultSpeakerName(label, tracks, msg = defaultText) {
+  const named = recordingSpeakerDefault(label, tracks);
+  switch (named.kind) {
+    case "speaker":
+      return msg("meetings.recordings.speakerNumber", { number: named.number });
+    case "microphone":
+      return msg("meetings.recordings.microphone");
+    case "system":
+      return msg("meetings.recordings.sharedAudio");
+    case "track":
+      return msg("meetings.recordings.trackNumber", { number: named.number });
+    case "label":
+      return named.label;
+  }
+}
+function ownerLiveLaneName(tracks, trackNumber, ownerName, msg = defaultText) {
+  if (!recordingMicrophoneIsOwner(tracks)) return null;
+  const source = tracks.find((track) => track.trackNumber === trackNumber)?.source;
+  if (source === "microphone") return ownerName;
+  if (source === "system") return msg("meetings.liveTranscript.others");
+  return null;
+}
+function speakerIsNamed(label, speakers) {
+  const speaker = speakers.find((candidate) => candidate.label === label);
+  return Boolean(speaker && (speaker.personId || speaker.source));
+}
+function speakerColorSlots(segments) {
+  const slots = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const label = segment.speakerLabel;
+    if (label && !slots.has(label)) slots.set(label, slots.size % 6 + 1);
+  }
+  return slots;
+}
+function groupTranscriptTurns(segments, maxGapMilliseconds = 3e4) {
+  const turns = [];
+  for (const segment of segments) {
+    const last = turns.at(-1);
+    if (last && last.speakerLabel === segment.speakerLabel && segment.startMilliseconds - last.endMilliseconds <= maxGapMilliseconds) {
+      last.segments.push(segment);
+      last.endMilliseconds = Math.max(last.endMilliseconds, segment.endMilliseconds);
+      continue;
+    }
+    turns.push({
+      key: segment.index,
+      speakerLabel: segment.speakerLabel,
+      startMilliseconds: segment.startMilliseconds,
+      endMilliseconds: segment.endMilliseconds,
+      segments: [segment]
+    });
+  }
+  return turns;
+}
+function activeSegmentIndex(segments, milliseconds) {
+  let low = 0;
+  let high = segments.length - 1;
+  let found = null;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    const segment = segments[middle];
+    if (segment.startMilliseconds <= milliseconds) {
+      found = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return found === null ? null : segments[found].index;
+}
+function versionSummary(version, modelName, locale) {
+  const parts = [modelName ?? version.model];
+  const languages = version.languages.map((code) => languageName(code, locale)).filter(Boolean);
+  if (languages.length > 0) parts.push(languages.join(", "));
+  return parts;
+}
+var LANGUAGE_NAMES = {
+  ar: "Arabic",
+  cs: "Czech",
+  da: "Danish",
+  de: "German",
+  el: "Greek",
+  en: "English",
+  es: "Spanish",
+  fi: "Finnish",
+  fr: "French",
+  he: "Hebrew",
+  hi: "Hindi",
+  hu: "Hungarian",
+  id: "Indonesian",
+  is: "Icelandic",
+  it: "Italian",
+  ja: "Japanese",
+  ko: "Korean",
+  nb: "Norwegian Bokm\xE5l",
+  nl: "Dutch",
+  nn: "Norwegian Nynorsk",
+  no: "Norwegian",
+  pl: "Polish",
+  pt: "Portuguese",
+  ro: "Romanian",
+  ru: "Russian",
+  sv: "Swedish",
+  th: "Thai",
+  tr: "Turkish",
+  uk: "Ukrainian",
+  vi: "Vietnamese",
+  zh: "Chinese"
+};
+var THREE_LETTER_LANGUAGES = {
+  ara: "ar",
+  ces: "cs",
+  cze: "cs",
+  dan: "da",
+  deu: "de",
+  ger: "de",
+  ell: "el",
+  gre: "el",
+  eng: "en",
+  spa: "es",
+  fin: "fi",
+  fra: "fr",
+  fre: "fr",
+  heb: "he",
+  hin: "hi",
+  hun: "hu",
+  ind: "id",
+  isl: "is",
+  ice: "is",
+  ita: "it",
+  jpn: "ja",
+  kor: "ko",
+  nob: "nb",
+  nld: "nl",
+  dut: "nl",
+  nno: "nn",
+  nor: "no",
+  pol: "pl",
+  por: "pt",
+  ron: "ro",
+  rum: "ro",
+  rus: "ru",
+  swe: "sv",
+  tha: "th",
+  tur: "tr",
+  ukr: "uk",
+  vie: "vi",
+  zho: "zh",
+  chi: "zh"
+};
+function languageName(code, locale) {
+  let tag = code;
+  try {
+    tag = Intl.getCanonicalLocales(code)[0] ?? code;
+  } catch {
+  }
+  const [primary, ...rest] = tag.split("-");
+  const twoLetter = THREE_LETTER_LANGUAGES[primary.toLowerCase()];
+  if (twoLetter) tag = [twoLetter, ...rest].join("-");
+  try {
+    const name = new Intl.DisplayNames(locale ? [locale, "en"] : ["en"], { type: "language" }).of(
+      tag
+    );
+    if (name && name !== tag) return name.charAt(0).toLocaleUpperCase(locale) + name.slice(1);
+  } catch {
+  }
+  return LANGUAGE_NAMES[tag] ?? LANGUAGE_NAMES[tag.split("-")[0]] ?? tag;
+}
+var MONTH_KEYS = [
+  "time.month.jan",
+  "time.month.feb",
+  "time.month.mar",
+  "time.month.apr",
+  "time.month.may",
+  "time.month.jun",
+  "time.month.jul",
+  "time.month.aug",
+  "time.month.sep",
+  "time.month.oct",
+  "time.month.nov",
+  "time.month.dec"
+];
+function defaultMeetingTitle(now, msg = defaultText) {
+  const month = msg(MONTH_KEYS[now.getMonth()] ?? "time.month.jan");
+  const date = msg("time.date", { day: now.getDate(), month });
+  const time = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+  return msg("meetings.recordings.defaultTitle", { date, time });
+}
+function meetingTitle(recording, msg = defaultText) {
+  const title = recording.title.trim();
+  const startedAt = new Date(recording.startedAt);
+  if (Number.isNaN(startedAt.getTime())) return title;
+  if (title && title !== serverDefaultTitle(startedAt)) return title;
+  return defaultMeetingTitle(startedAt, msg);
+}
+function serverDefaultTitle(startedAt) {
+  return `Recording ${startedAt.toISOString().slice(0, 16).replace("T", " ")} UTC`;
+}
+function groupLiveTurns(lines) {
+  const sorted = [...lines].sort(
+    (a, b) => a.startMilliseconds - b.startMilliseconds || a.trackNumber - b.trackNumber
+  );
+  const turns = [];
+  for (const line of sorted) {
+    const text = line.text.trim();
+    if (!text) continue;
+    const last = turns.at(-1);
+    if (last && last.trackNumber === line.trackNumber) {
+      last.texts.push(text);
+      continue;
+    }
+    turns.push({
+      key: `${line.trackNumber}:${line.startMilliseconds}`,
+      trackNumber: line.trackNumber,
+      startMilliseconds: line.startMilliseconds,
+      texts: [text]
+    });
+  }
+  return turns;
+}
+var LIVE_ECHO_SLACK_MILLISECONDS = 2e3;
+var LIVE_ECHO_MIN_MATCHED_WORDS = 2;
+var LIVE_ECHO_MIN_SHARE = 0.7;
+function liveWordKeys(text) {
+  return text.normalize("NFKC").toLocaleLowerCase().split(/\s+/u).map((word) => word.replace(/[^\p{L}\p{N}]+/gu, "")).filter(Boolean);
+}
+function withoutLiveMicrophoneEchoes(lines, tracks) {
+  if (!recordingMicrophoneIsOwner(tracks)) return [...lines];
+  const sourceOf = (trackNumber) => tracks.find((track) => track.trackNumber === trackNumber)?.source;
+  const computer = lines.filter((line) => sourceOf(line.trackNumber) === "system").map((line) => ({
+    start: line.startMilliseconds,
+    end: Math.max(line.startMilliseconds, line.endMilliseconds ?? line.startMilliseconds),
+    keys: new Set(liveWordKeys(line.text))
+  }));
+  if (computer.length === 0) return [...lines];
+  return lines.filter((line) => {
+    if (sourceOf(line.trackNumber) !== "microphone") return true;
+    const keys = liveWordKeys(line.text);
+    if (keys.length < LIVE_ECHO_MIN_MATCHED_WORDS) return true;
+    const start = line.startMilliseconds;
+    const end = Math.max(start, line.endMilliseconds ?? start);
+    const heard = computer.filter(
+      (other) => other.start <= end + LIVE_ECHO_SLACK_MILLISECONDS && other.end >= start - LIVE_ECHO_SLACK_MILLISECONDS
+    );
+    if (heard.length === 0) return true;
+    const matched = keys.filter((key) => heard.some((other) => other.keys.has(key))).length;
+    return !(matched >= LIVE_ECHO_MIN_MATCHED_WORDS && matched / keys.length >= LIVE_ECHO_MIN_SHARE);
+  });
+}
+function tidyLiveText(pieces) {
+  return pieces.map((piece) => piece.trim()).filter(Boolean).join(" ").replace(/\s+([.,!?;:])/g, "$1").replace(/(?:…|\.{3})(?=[.,!?;:…])/g, "").replace(/([,!?;:])\1+/g, "$1").replace(/(?<!\.)\.\.(?!\.)/g, ".").replace(/\s{2,}/g, " ");
+}
+function tidyPartialText(text) {
+  return tidyLiveText([text]).replace(/\s*(?:…|\.{3})$/, "");
+}
+
+export {
+  formatClock,
+  formatDuration,
+  meetingPhase,
+  meetingHereStatus,
+  meetingUploadFailure,
+  transcribingText,
+  transcriptNeedsCredits,
+  transcriptFixModel,
+  meetingStatusLabel,
+  transcriptErrorText,
+  speakerDisplayName,
+  defaultSpeakerName,
+  ownerLiveLaneName,
+  speakerIsNamed,
+  speakerColorSlots,
+  groupTranscriptTurns,
+  activeSegmentIndex,
+  versionSummary,
+  languageName,
+  defaultMeetingTitle,
+  meetingTitle,
+  groupLiveTurns,
+  withoutLiveMicrophoneEchoes,
+  tidyLiveText,
+  tidyPartialText
+};
+//# sourceMappingURL=chunk-2FSBSCZJ.js.map

package/dist/chunk-2I7HDP53.js

@@ -0,0 +1,199 @@
+"use client";
+import {
+  annotationNoteNeedsDisclosure
+} from "./chunk-LJUMYUBO.js";
+import {
+  annotationSourceLabel,
+  revealLoadedAnnotationSource
+} from "./chunk-5XXRHX3V.js";
+import {
+  annotationQuoteText,
+  truncateAnnotationQuote
+} from "./chunk-UNI2IXRC.js";
+import {
+  cn
+} from "./chunk-TXS65BB2.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/components/timeline-annotation-chrome.tsx
+import { useLayoutEffect, useRef, useState } from "react";
+
+// src/components/timeline-annotation-reveal-context.ts
+import { createContext, useContext } from "react";
+var TimelineAnnotationSourceRootContext = createContext(null);
+function useTimelineAnnotationSourceRoot() {
+  return useContext(TimelineAnnotationSourceRootContext);
+}
+
+// src/components/timeline-annotation-chrome.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var NOTE_MAX_HEIGHT_PX = 160;
+function autosizeNote(textarea) {
+  if (!textarea) return;
+  textarea.style.height = "auto";
+  textarea.style.height = `${Math.min(Math.max(textarea.scrollHeight, 32), NOTE_MAX_HEIGHT_PX)}px`;
+}
+function quotePreview(quote) {
+  const trimmed = quote.trim();
+  const multiline = trimmed.includes("\n");
+  return {
+    text: multiline ? trimmed : trimmed.replace(/\s+/g, " "),
+    multiline
+  };
+}
+function AnnotationQuoteSourceButton({
+  annotation,
+  lines = 2,
+  onRevealSource,
+  onUnavailable
+}) {
+  const t = useOpenGeniText();
+  const quoteText = annotationQuoteText(annotation);
+  const preview = quotePreview(quoteText);
+  const sourceLabel = annotationSourceLabel(t, annotation.source);
+  const sourceRoot = useTimelineAnnotationSourceRoot();
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      title: quoteText,
+      "aria-label": t("timelineAnnotationChrome.viewSourcelabelSourceTruncateannotationquote", {
+        sourceLabel,
+        truncateAnnotationQuote: truncateAnnotationQuote(quoteText, 88)
+      }),
+      className: "block w-full min-w-0 rounded-sm border-0 bg-transparent text-left text-og-sm leading-5 text-og-fg-muted outline-hidden transition-colors hover:text-og-fg focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:min-h-[44px]",
+      onClick: () => {
+        const revealed = onRevealSource?.(annotation.source) ?? (sourceRoot ? revealLoadedAnnotationSource(annotation.source, sourceRoot.current) : revealLoadedAnnotationSource(annotation.source));
+        onUnavailable(revealed ? null : annotation.id);
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: cn(
+              "block min-w-0 max-w-full break-words",
+              preview.multiline ? "whitespace-pre-wrap" : "whitespace-normal",
+              lines === 3 ? "line-clamp-3" : "line-clamp-2"
+            ),
+            children: preview.text
+          }
+        ),
+        /* @__PURE__ */ jsxs("span", { className: "sr-only", children: [
+          " ",
+          t("timelineAnnotationChrome.viewSource")
+        ] })
+      ]
+    }
+  );
+}
+function AnnotationAccentRow({
+  children,
+  className
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex gap-2.5", className), children: [
+    /* @__PURE__ */ jsx("div", { "aria-hidden": "true", className: "w-0.5 shrink-0 rounded-full bg-og-accent/55" }),
+    /* @__PURE__ */ jsx("div", { className: "min-w-0 flex-1", children })
+  ] });
+}
+function AnnotationNotePreview({
+  note,
+  annotationId,
+  ordinal,
+  className
+}) {
+  const t = useOpenGeniText();
+  const [expanded, setExpanded] = useState(false);
+  if (!note) return null;
+  const collapsible = annotationNoteNeedsDisclosure(note);
+  const contentId = `og-annotation-note-${annotationId}`;
+  return /* @__PURE__ */ jsxs("div", { className, children: [
+    /* @__PURE__ */ jsx(
+      "p",
+      {
+        id: contentId,
+        "data-og-annotation-note": "",
+        "data-og-annotation-note-expanded": expanded ? "true" : "false",
+        className: cn(
+          "mt-0.5 break-words whitespace-pre-wrap text-og-sm leading-5 text-og-fg",
+          !expanded && "line-clamp-4"
+        ),
+        children: note
+      }
+    ),
+    collapsible ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "mt-0.5 inline-flex min-h-7 items-center rounded-og-sm px-1 text-og-xs font-medium text-og-fg-muted outline-hidden hover:text-og-fg focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:min-h-11",
+        "aria-expanded": expanded,
+        "aria-controls": contentId,
+        "aria-label": expanded ? t("timelineAnnotationChrome.showLessAnnotationOrdinal", { ordinal }) : t("timelineAnnotationChrome.showMoreAnnotationOrdinal", { ordinal }),
+        onClick: () => setExpanded((current) => !current),
+        children: expanded ? t("timelineAnnotationChrome.showLess") : t("timelineAnnotationChrome.showMore")
+      }
+    ) : null
+  ] });
+}
+function AnnotationNoteField({
+  annotation,
+  inputRef,
+  onUpdate,
+  onCommit
+}) {
+  const t = useOpenGeniText();
+  const localRef = useRef(null);
+  const setRef = (node) => {
+    localRef.current = node;
+    inputRef?.(node);
+  };
+  useLayoutEffect(() => {
+    const textarea = localRef.current;
+    if (!textarea) return;
+    autosizeNote(textarea);
+    if (typeof ResizeObserver === "undefined") return;
+    let width = textarea.getBoundingClientRect().width;
+    const observer = new ResizeObserver(() => {
+      const nextWidth = textarea.getBoundingClientRect().width;
+      if (nextWidth === width) return;
+      width = nextWidth;
+      autosizeNote(textarea);
+    });
+    observer.observe(textarea);
+    return () => observer.disconnect();
+  }, [annotation.note]);
+  return /* @__PURE__ */ jsx(
+    "textarea",
+    {
+      ref: setRef,
+      value: annotation.note,
+      rows: 1,
+      maxLength: 2048,
+      placeholder: t("timelineAnnotationChrome.addANote"),
+      "aria-label": t("timelineAnnotationChrome.note"),
+      className: "mt-0.5 max-h-40 min-h-8 w-full resize-none overflow-y-auto break-words border-0 bg-transparent px-0 py-1 text-og-sm leading-5 text-og-fg outline-hidden placeholder:text-og-fg-subtle focus-visible:ring-0",
+      onInput: (event) => {
+        autosizeNote(event.currentTarget);
+        onUpdate(annotation.id, event.currentTarget.value);
+      },
+      onKeyDown: (event) => {
+        if (event.key !== "Enter" || event.shiftKey || event.nativeEvent.isComposing) return;
+        event.preventDefault();
+        event.stopPropagation();
+        if (event.currentTarget.value.trim().length === 0) return;
+        onCommit?.();
+      }
+    }
+  );
+}
+
+export {
+  TimelineAnnotationSourceRootContext,
+  useTimelineAnnotationSourceRoot,
+  AnnotationQuoteSourceButton,
+  AnnotationAccentRow,
+  AnnotationNotePreview,
+  AnnotationNoteField
+};
+//# sourceMappingURL=chunk-2I7HDP53.js.map

package/dist/chunk-2INLDVK3.js

@@ -0,0 +1,15 @@
+"use client";
+import {
+  ProviderRecoveryNotice
+} from "./chunk-OV6QJRT4.js";
+
+// src/app/components/session/model-recovery-notice.tsx
+import { jsx } from "react/jsx-runtime";
+function ModelRecoveryNotice({ recovery }) {
+  return /* @__PURE__ */ jsx("div", { className: "shrink-0 px-4 py-2 sm:px-6", "data-model-recovery-notice": "", children: /* @__PURE__ */ jsx(ProviderRecoveryNotice, { className: "mx-auto w-full max-w-3xl", recovery }) });
+}
+
+export {
+  ModelRecoveryNotice
+};
+//# sourceMappingURL=chunk-2INLDVK3.js.map