@floegence/floe-webapp-core 0.86.53 → 0.86.55

package/dist/chat.js

@@ -11,12 +11,12 @@ import { DEFAULT_VIRTUAL_LIST_CONFIG as w } from "./components/chat/types.js";
 import { FileBlock as W } from "./components/chat/blocks/FileBlock.js";
 import { ImageBlock as D } from "./components/chat/blocks/ImageBlock.js";
 import { MarkdownBlock as I } from "./components/chat/blocks/MarkdownBlock.js";
-import { MarkdownMedia as L } from "./components/chat/blocks/MarkdownMedia.js";
-import { MermaidBlock as y } from "./components/chat/blocks/MermaidBlock.js";
+import { MarkdownMedia as v } from "./components/chat/blocks/MarkdownMedia.js";
+import { MermaidBlock as T } from "./components/chat/blocks/MermaidBlock.js";
 import { MessageActions as b } from "./components/chat/message/MessageActions.js";
 import { MessageAvatar as H } from "./components/chat/message/MessageAvatar.js";
-import { MessageBubble as R } from "./components/chat/message/MessageBubble.js";
-import { MessageItem as V } from "./components/chat/message/MessageItem.js";
+import { MessageBubble as V } from "./components/chat/message/MessageBubble.js";
+import { MessageItem as U } from "./components/chat/message/MessageItem.js";
 import { MessageMeta as N } from "./components/chat/message/MessageMeta.js";
 import { ShellBlock as K } from "./components/chat/blocks/ShellBlock.js";
 import { StreamingCursor as j } from "./components/chat/status/StreamingCursor.js";
@@ -29,13 +29,14 @@ import { WorkingIndicator as tr } from "./components/chat/status/WorkingIndicato
 import { buildAssistantNoticeEvents as ir, createStreamEventBuilder as fr, isStreamEvent as mr } from "./components/chat/streamEvents.js";
 import { computeCodeDiff as kr, computeCodeDiffSync as dr, configureDiffWorker as pr, createDiffWorker as xr, hasDiffWorker as cr, terminateDiffWorker as lr, waitForDiffWorker as sr } from "./components/chat/hooks/useCodeDiff.js";
 import { configureMarkdownWorker as ur, createMarkdownWorker as gr, hasMarkdownWorker as hr, renderMarkdown as Cr, renderMarkdownSync as wr, terminateMarkdownWorker as Br, waitForMarkdownWorker as Wr } from "./components/chat/hooks/useMarkdown.js";
-import { configureMermaidWorker as Dr, configureSyncMermaid as Ar, renderMermaid as Ir, terminateMermaidWorker as vr, useMermaid as Lr } from "./components/chat/hooks/useMermaid.js";
-import { configureShikiWorker as yr, configureSyncHighlighter as Fr, highlightCode as br, terminateShikiWorker as Er, useCodeHighlight as Hr } from "./components/chat/hooks/useCodeHighlight.js";
-import { createInputHistoryController as Rr } from "./components/chat/input/createInputHistoryController.js";
-import { markdownMediaKind as Vr, markdownMediaPlaceholder as _r, readMarkdownMediaPlaceholder as Nr, safeMarkdownMediaURL as Gr, sandboxedMarkdownHtml as Kr } from "./components/chat/markdown/media.js";
-import { useAttachments as jr } from "./components/chat/hooks/useAttachments.js";
-import { useAutoScroll as zr } from "./components/chat/hooks/useAutoScroll.js";
-import { useVirtualList as Qr } from "./components/chat/hooks/useVirtualList.js";
+import { configureMermaidWorker as Dr, configureSyncMermaid as Ar, renderMermaid as Ir, terminateMermaidWorker as Lr, useMermaid as vr } from "./components/chat/hooks/useMermaid.js";
+import { configureShikiWorker as Tr, configureSyncHighlighter as Fr, highlightCode as br, terminateShikiWorker as Er, useCodeHighlight as Hr } from "./components/chat/hooks/useCodeHighlight.js";
+import { createInputHistoryController as Vr } from "./components/chat/input/createInputHistoryController.js";
+import { createVirtualListLayout as Ur } from "./components/chat/hooks/virtualListLayout.js";
+import { markdownMediaKind as Nr, markdownMediaPlaceholder as Gr, readMarkdownMediaPlaceholder as Kr, safeMarkdownMediaURL as Or, sandboxedMarkdownHtml as jr } from "./components/chat/markdown/media.js";
+import { useAttachments as zr } from "./components/chat/hooks/useAttachments.js";
+import { useAutoScroll as Qr } from "./components/chat/hooks/useAutoScroll.js";
+import { useVirtualList as Yr } from "./components/chat/hooks/useVirtualList.js";
 export {
   o as AttachmentPreview,
   a as BlockRenderer,
@@ -50,12 +51,12 @@ export {
   W as FileBlock,
   D as ImageBlock,
   I as MarkdownBlock,
-  L as MarkdownMedia,
-  y as MermaidBlock,
+  v as MarkdownMedia,
+  T as MermaidBlock,
   b as MessageActions,
   H as MessageAvatar,
-  R as MessageBubble,
-  V as MessageItem,
+  V as MessageBubble,
+  U as MessageItem,
   N as MessageMeta,
   K as ShellBlock,
   j as StreamingCursor,
@@ -71,35 +72,36 @@ export {
   pr as configureDiffWorker,
   ur as configureMarkdownWorker,
   Dr as configureMermaidWorker,
-  yr as configureShikiWorker,
+  Tr as configureShikiWorker,
   Fr as configureSyncHighlighter,
   Ar as configureSyncMermaid,
   xr as createDiffWorker,
-  Rr as createInputHistoryController,
+  Vr as createInputHistoryController,
   gr as createMarkdownWorker,
   fr as createStreamEventBuilder,
+  Ur as createVirtualListLayout,
   cr as hasDiffWorker,
   hr as hasMarkdownWorker,
   br as highlightCode,
   mr as isStreamEvent,
-  Vr as markdownMediaKind,
-  _r as markdownMediaPlaceholder,
-  Nr as readMarkdownMediaPlaceholder,
+  Nr as markdownMediaKind,
+  Gr as markdownMediaPlaceholder,
+  Kr as readMarkdownMediaPlaceholder,
   Cr as renderMarkdown,
   wr as renderMarkdownSync,
   Ir as renderMermaid,
-  Gr as safeMarkdownMediaURL,
-  Kr as sandboxedMarkdownHtml,
+  Or as safeMarkdownMediaURL,
+  jr as sandboxedMarkdownHtml,
   lr as terminateDiffWorker,
   Br as terminateMarkdownWorker,
-  vr as terminateMermaidWorker,
+  Lr as terminateMermaidWorker,
   Er as terminateShikiWorker,
-  jr as useAttachments,
-  zr as useAutoScroll,
+  zr as useAttachments,
+  Qr as useAutoScroll,
   p as useChatContext,
   Hr as useCodeHighlight,
-  Lr as useMermaid,
-  Qr as useVirtualList,
+  vr as useMermaid,
+  Yr as useVirtualList,
   sr as waitForDiffWorker,
   Wr as waitForMarkdownWorker
 };

package/dist/components/chat/hooks/index.d.ts

@@ -1,4 +1,4 @@
-export { useVirtualList, type UseVirtualListOptions, type UseVirtualListReturn, type VirtualItem } from './useVirtualList';
+export { useVirtualList, createVirtualListLayout, type VirtualListAnchor, type VirtualListLayout, type UseVirtualListOptions, type UseVirtualListReturn, type VirtualItem } from './useVirtualList';
 export { useCodeHighlight, highlightCode, terminateShikiWorker, configureShikiWorker, configureSyncHighlighter } from './useCodeHighlight';
 export { useMermaid, renderMermaid, terminateMermaidWorker, configureMermaidWorker, configureSyncMermaid } from './useMermaid';
 export { createMarkdownWorker, configureMarkdownWorker, hasMarkdownWorker, waitForMarkdownWorker, renderMarkdown, renderMarkdownSync, terminateMarkdownWorker, } from './useMarkdown';

package/dist/components/chat/hooks/useMarkdown.js

@@ -1,78 +1,98 @@
-import { secureRandomUUID as w } from "../../../utils/secureRandom.js";
-import { renderMarkdownToHtml as k } from "../markdown/markdown.js";
-let n = null, c = !1, u = null;
-const l = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), m = 200;
-function h() {
+import { secureRandomUUID as E } from "../../../utils/secureRandom.js";
+import { renderMarkdownToHtml as y } from "../markdown/markdown.js";
+import { createMarkdownSessionWorker as v } from "../markdown/createSessionWorker.js";
+const h = 15e3, W = 200, g = 16 * 1024 * 1024;
+let n = null, f = !1, w = null, M, d, u = 0;
+const k = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+function A() {
   if (typeof Worker > "u") return null;
   try {
-    return new Worker(new URL(
-      /* @vite-ignore */
-      "" + new URL("../../../assets/markdown.worker-CcdiAiK-.js", import.meta.url).href,
-      import.meta.url
-    ), { type: "module" });
+    return v();
   } catch {
     return null;
   }
 }
-function W(r) {
-  return n = r, c = !1, u = new Promise((t) => {
-    n.onmessage = (e) => {
-      if ("type" in e.data && e.data.type === "ready") {
-        c = !0, t();
+function c(r) {
+  const e = n;
+  n = null, f = !1, d !== void 0 && clearTimeout(d), d = void 0, M?.(r), M = void 0, w = null, e && (e.onmessage = null, e.onerror = null, e.onmessageerror = null, e.terminate());
+  for (const t of k.values())
+    clearTimeout(t.timer), t.reject(r);
+  k.clear();
+}
+function b(r) {
+  return c(new Error("Markdown worker replaced")), n = r, w = new Promise((e, t) => {
+    M = t, d = setTimeout(() => c(new Error("Markdown worker initialization timed out")), h), r.onmessage = (o) => {
+      if (n !== r) return;
+      if (!o.data || typeof o.data != "object") {
+        c(new Error("Invalid Markdown worker response"));
+        return;
+      }
+      if ("type" in o.data && o.data.type === "ready") {
+        d !== void 0 && clearTimeout(d), d = void 0, M = void 0, f = !0, e();
         return;
       }
-      const { id: o, html: d, error: i } = e.data, s = l.get(o);
-      s && (l.delete(o), i ? s.reject(new Error(i)) : s.resolve(d));
-    }, n.onerror = (e) => {
-      console.error("Markdown worker error:", e);
+      const { id: i, html: l, error: m } = o.data, s = k.get(i);
+      s && (k.delete(i), clearTimeout(s.timer), m ? s.reject(new Error(m)) : typeof l != "string" ? s.reject(new Error("Markdown worker omitted its result")) : s.resolve(l));
+    }, r.onerror = r.onmessageerror = () => {
+      n === r && c(new Error("Markdown worker failed"));
     };
-  }), u;
+  }), w.catch(() => {
+  }), w;
 }
-function g() {
+function q() {
   return !!n;
 }
-async function p() {
-  return n ? c ? !0 : u ? (await u, !0) : !1 : !1;
+async function T() {
+  return n ? f ? !0 : (await w, !!n && f) : !1;
 }
 function R(r) {
-  const t = a.get(r);
-  if (t) return t;
-  const e = k(r);
-  return f(r, e), e;
+  const e = a.get(r);
+  if (e !== void 0) return e;
+  const t = y(r);
+  return p(r, t), t;
 }
-async function U(r) {
-  const t = a.get(r);
-  if (t) return t;
-  if (!await p() || !n) {
-    const o = k(r);
-    return f(r, o), o;
-  }
-  return new Promise((o, d) => {
-    const i = w();
-    l.set(i, {
+async function z(r) {
+  const e = a.get(r);
+  if (e !== void 0) return e;
+  const t = n;
+  if (!t) return R(r);
+  if (await T(), n !== t || !f) throw new Error("Markdown worker changed during initialization");
+  return new Promise((o, i) => {
+    const l = E(), m = setTimeout(() => c(new Error("Markdown worker request timed out")), h);
+    k.set(l, {
       resolve: (s) => {
-        f(r, s), o(s);
+        p(r, s), o(s);
       },
-      reject: d
-    }), n.postMessage({ id: i, content: r });
+      reject: i,
+      timer: m
+    });
+    try {
+      t.postMessage({ id: l, content: r });
+    } catch {
+      c(new Error("Markdown worker request could not be sent"));
+    }
   });
 }
-function v() {
-  n && (n.terminate(), n = null), c = !1, u = null, l.clear(), a.clear();
+function C() {
+  c(new Error("Markdown worker closed")), a.clear(), u = 0;
 }
-function f(r, t) {
-  if (a.size >= m) {
-    const e = a.keys().next().value;
-    e && a.delete(e);
+function p(r, e) {
+  const t = (r.length + e.length) * 2;
+  if (t > g) return;
+  const o = a.get(r);
+  for (o !== void 0 && (u -= (r.length + o.length) * 2, a.delete(r)); a.size >= W || u + t > g; ) {
+    const i = a.entries().next().value;
+    if (!i) break;
+    u -= (i[0].length + i[1].length) * 2, a.delete(i[0]);
   }
-  a.set(r, t);
+  a.set(r, e), u += t;
 }
 export {
-  W as configureMarkdownWorker,
-  h as createMarkdownWorker,
-  g as hasMarkdownWorker,
-  U as renderMarkdown,
+  b as configureMarkdownWorker,
+  A as createMarkdownWorker,
+  q as hasMarkdownWorker,
+  z as renderMarkdown,
   R as renderMarkdownSync,
-  v as terminateMarkdownWorker,
-  p as waitForMarkdownWorker
+  C as terminateMarkdownWorker,
+  T as waitForMarkdownWorker
 };

package/dist/components/chat/hooks/useVirtualList.d.ts

@@ -1,16 +1,14 @@
 import { type Accessor } from 'solid-js';
 import type { VirtualListConfig } from '../types';
-export interface VirtualItem {
-    index: number;
-    start: number;
-    size: number;
-    key: string;
-}
+import { type VirtualItem, type VirtualListAnchor } from './virtualListLayout';
+export { createVirtualListLayout, type VirtualItem, type VirtualListAnchor, type VirtualListLayout } from './virtualListLayout';
 export interface UseVirtualListOptions {
     count: Accessor<number>;
     getItemKey: (index: number) => string;
     getItemHeight: (index: number) => number;
     config: VirtualListConfig;
+    /** Explicit ordered identities for prepend, eviction and same-count replacement. */
+    itemKeys?: Accessor<readonly string[]>;
 }
 export interface UseVirtualListReturn {
     containerRef: (el: HTMLElement) => void;
@@ -33,5 +31,8 @@ export interface UseVirtualListReturn {
      * Call this from a ResizeObserver for visible items.
      */
     setItemHeight: (index: number, height: number) => void;
+    setItemHeightByKey: (key: string, height: number) => void;
+    captureAnchor: () => VirtualListAnchor | undefined;
+    anchorOffset: (anchor: VirtualListAnchor) => number | undefined;
 }
 export declare function useVirtualList(options: UseVirtualListOptions): UseVirtualListReturn;

package/dist/components/chat/hooks/useVirtualList.js

@@ -1,152 +1,123 @@
-import { createSignal as b, createEffect as D, createMemo as d, onMount as G, onCleanup as J, untrack as Q } from "solid-js";
-function Z(E) {
-  const { count: c, getItemKey: w, getItemHeight: R, config: a } = E;
-  let g = null, r = null;
-  const [q, A] = b(0), [T, B] = b(0), [x, y] = b(!0);
-  let u = null, f = [], m = [];
-  const S = (t) => !Number.isFinite(t) || t <= 0 ? a.defaultItemHeight : Math.max(1, Math.round(t)), V = (t) => {
-    f = new Array(t), m = new Array(t + 1).fill(0);
-  }, F = (t, e) => {
-    for (let o = t; o < m.length; o += o & -o)
-      m[o] += e;
-  }, i = (t) => {
-    let e = 0;
-    for (let o = t; o > 0; o -= o & -o)
-      e += m[o];
-    return e;
-  }, O = (t) => {
-    let e = 1;
-    for (; e << 1 <= t; ) e <<= 1;
-    return e;
-  }, k = (t, e) => {
-    if (e <= 0 || t <= 0) return 0;
-    const o = i(e);
-    if (t >= o) return e - 1;
-    let s = 0, n = 0;
-    for (let l = O(e); l !== 0; l >>= 1) {
-      const h = s + l;
-      h <= e && n + m[h] < t && (n += m[h], s = h);
-    }
-    return Math.max(0, Math.min(e - 1, s));
-  }, [p, C] = b(0);
-  let I = !1;
-  const z = () => {
-    if (I) return;
-    I = !0;
+import { createSignal as d, createMemo as c, untrack as _, onMount as j, onCleanup as D } from "solid-js";
+import { createVirtualListLayout as G } from "./virtualListLayout.js";
+function U(A) {
+  const { count: y, getItemKey: x, getItemHeight: z, config: m } = A;
+  let f = null, r = null;
+  const [k, w] = d(0), [H, F] = d(0), [R, M] = d(!0);
+  let i = null;
+  const o = G(m.defaultItemHeight), [a, S] = d(0);
+  let T = !1, h, g, v = !1;
+  const q = () => {
+    if (v || T) return;
+    T = !0;
     const t = () => {
-      I = !1, C((e) => e + 1);
+      T = !1, h = void 0, g = void 0, !v && S((e) => e + 1);
     };
     if (typeof requestAnimationFrame > "u") {
-      setTimeout(t, 0);
+      g = setTimeout(t, 0);
       return;
     }
-    requestAnimationFrame(t);
-  }, L = (t) => {
-    V(t), Q(() => {
-      for (let e = 0; e < t; e += 1) {
-        w(e);
-        const o = S(R(e));
-        f[e] = o, F(e + 1, o);
-      }
-    }), z();
-  };
-  D(() => {
-    L(c());
-  });
-  const H = d(() => {
-    p();
-    const t = c();
-    if (t <= 0)
-      return { start: 0, end: 0 };
-    const e = q(), o = e + T(), s = k(e, t), n = k(o, t), l = Math.max(0, s - a.overscan), h = Math.min(t, n + 1 + a.overscan);
-    return { start: l, end: h };
-  }), K = d(() => {
-    const { start: t, end: e } = H(), o = [];
-    let s = i(t);
-    for (let n = t; n < e; n += 1) {
-      const l = f[n] ?? a.defaultItemHeight;
-      o.push({
-        index: n,
-        start: s,
-        size: l,
-        key: w(n)
-      }), s += l;
+    h = requestAnimationFrame(t);
+  }, u = c(() => {
+    const t = y();
+    if (!Number.isInteger(t) || t < 0) throw new Error("Virtual list count must be a non-negative integer");
+    const e = A.itemKeys?.();
+    if (e && e.length !== t) throw new Error("Virtual list keys must match count");
+    return _(() => o.reset(e ?? Array.from({ length: t }, (n, l) => x(l)), z)), {};
+  }), p = c(() => (u(), a(), o.range(k(), H(), m.overscan))), E = c(() => {
+    u(), a();
+    const { start: t, end: e } = p(), n = [];
+    let l = o.prefix(t);
+    for (let s = t; s < e; s += 1) {
+      const V = o.item(s)?.size ?? m.defaultItemHeight;
+      n.push({
+        index: s,
+        start: l,
+        size: V,
+        key: o.item(s).key
+      }), l += V;
     }
-    return o;
-  }), N = d(() => (p(), i(c()))), P = d(() => (p(), i(H().start))), j = d(() => {
-    p();
-    const t = c(), e = H().end;
-    return Math.max(0, i(t) - i(Math.min(t, e)));
-  }), M = () => {
-    if (r && u === null) {
+    return n;
+  }), K = c(() => (u(), a(), o.total())), L = c(() => (u(), a(), o.prefix(p().start))), O = c(() => {
+    u(), a();
+    const t = y(), e = p().end;
+    return Math.max(0, o.total() - o.prefix(Math.min(t, e)));
+  }), I = () => {
+    if (r && i === null) {
       if (typeof requestAnimationFrame > "u") {
         const t = r.scrollTop;
-        A(t);
-        const o = r.scrollHeight - t - r.clientHeight < 50;
-        y(o);
+        w(t);
+        const n = r.scrollHeight - t - r.clientHeight < 50;
+        M(n);
         return;
       }
-      u = requestAnimationFrame(() => {
-        if (u = null, !r) return;
+      i = requestAnimationFrame(() => {
+        if (i = null, !r) return;
         const t = r.scrollTop;
-        A(t);
-        const o = r.scrollHeight - t - r.clientHeight < 50;
-        y(o);
+        w(t);
+        const n = r.scrollHeight - t - r.clientHeight < 50;
+        M(n);
       });
     }
   };
-  let v = null;
-  return G(() => {
-    g && (v = new ResizeObserver((t) => {
+  let b = null;
+  j(() => {
+    f && (b = new ResizeObserver((t) => {
       for (const e of t)
-        B(e.contentRect.height);
-    }), v.observe(g), B(g.clientHeight)), M();
-  }), J(() => {
-    v?.disconnect(), u !== null && typeof cancelAnimationFrame < "u" && (cancelAnimationFrame(u), u = null);
-  }), {
+        F(e.contentRect.height);
+    }), b.observe(f), F(f.clientHeight)), I();
+  }), D(() => {
+    v = !0, b?.disconnect(), h !== void 0 && cancelAnimationFrame(h), g !== void 0 && clearTimeout(g), i !== null && typeof cancelAnimationFrame < "u" && (cancelAnimationFrame(i), i = null);
+  });
+  const C = (t, e = "start") => {
+    if (!r) return;
+    const n = y();
+    if (t < 0 || t >= n) return;
+    const l = o.item(t)?.size ?? m.defaultItemHeight;
+    let s;
+    switch (e) {
+      case "start":
+        s = o.prefix(t);
+        break;
+      case "center":
+        s = o.prefix(t) - H() / 2 + l / 2;
+        break;
+      case "end":
+        s = o.prefix(t + 1) - H();
+        break;
+    }
+    r.scrollTo({ top: Math.max(0, s), behavior: "smooth" });
+  }, N = () => {
+    r && r.scrollTo({ top: r.scrollHeight, behavior: "smooth" });
+  }, B = (t, e) => {
+    o.measure(t, e) && q();
+  };
+  return {
     containerRef: (t) => {
-      g = t;
+      f = t;
     },
     scrollRef: (t) => {
-      r = t, M();
-    },
-    onScroll: M,
-    virtualItems: K,
-    totalHeight: N,
-    paddingTop: P,
-    paddingBottom: j,
-    scrollToIndex: (t, e = "start") => {
-      if (!r) return;
-      const o = c();
-      if (t < 0 || t >= o) return;
-      const s = f[t] ?? a.defaultItemHeight;
-      let n;
-      switch (e) {
-        case "start":
-          n = i(t);
-          break;
-        case "center":
-          n = i(t) - T() / 2 + s / 2;
-          break;
-        case "end":
-          n = i(t + 1) - T();
-          break;
-      }
-      r.scrollTo({ top: Math.max(0, n), behavior: "smooth" });
+      r = t, I();
     },
-    scrollToBottom: () => {
-      r && r.scrollTo({ top: r.scrollHeight, behavior: "smooth" });
-    },
-    isAtBottom: x,
-    visibleRange: H,
+    onScroll: I,
+    virtualItems: E,
+    totalHeight: K,
+    paddingTop: L,
+    paddingBottom: O,
+    scrollToIndex: C,
+    scrollToBottom: N,
+    isAtBottom: R,
+    visibleRange: p,
     setItemHeight: (t, e) => {
-      const o = c();
-      if (t < 0 || t >= o) return;
-      const s = S(e), n = f[t] ?? a.defaultItemHeight;
-      s !== n && (f[t] = s, F(t + 1, s - n), z());
-    }
+      const n = o.item(t);
+      n && B(n.key, e);
+    },
+    setItemHeightByKey: B,
+    captureAnchor: () => o.anchor(r?.scrollTop ?? k()),
+    anchorOffset: (t) => o.offset(t)
   };
 }
 export {
-  Z as useVirtualList
+  G as createVirtualListLayout,
+  U as useVirtualList
 };

package/dist/components/chat/hooks/virtualListLayout.d.ts

@@ -0,0 +1,27 @@
+export interface VirtualItem {
+    index: number;
+    start: number;
+    size: number;
+    key: string;
+}
+export interface VirtualListAnchor {
+    key: string;
+    offset: number;
+}
+/** Geometry only: the host remains the sole owner of scroll writes. */
+export declare function createVirtualListLayout(defaultItemHeight: number): {
+    reset: (nextKeys: readonly string[], estimate: (index: number) => number) => void;
+    measure: (key: string, height: number) => boolean;
+    item: (index: number) => VirtualItem | undefined;
+    range: (scrollTop: number, viewportHeight: number, overscan?: number) => {
+        start: number;
+        end: number;
+    };
+    anchor: (scrollTop: number) => VirtualListAnchor | undefined;
+    offset: (anchor: VirtualListAnchor) => number | undefined;
+    prefix: (end: number) => number;
+    total: () => number;
+    count: () => number;
+    measuredCount: () => number;
+};
+export type VirtualListLayout = ReturnType<typeof createVirtualListLayout>;

package/dist/components/chat/hooks/virtualListLayout.js

@@ -0,0 +1,82 @@
+function y(m) {
+  const x = Number.isFinite(m) && m > 0 ? Math.max(1, Math.round(m)) : 80;
+  let s = [], u = [], f = [0], c = /* @__PURE__ */ new Map();
+  const l = /* @__PURE__ */ new Map(), g = (t) => Number.isFinite(t) && t > 0 ? Math.max(1, Math.round(t)) : x;
+  function h(t) {
+    let r = 0;
+    const i = Number.isFinite(t) ? Math.trunc(t) : t === 1 / 0 ? s.length : 0;
+    for (let n = Math.max(0, Math.min(s.length, i)); n > 0; n -= n & -n) r += f[n];
+    return r;
+  }
+  function M(t) {
+    if (!s.length || t <= 0) return 0;
+    let r = 0, i = 0, n = 1;
+    for (; n * 2 <= s.length; ) n *= 2;
+    for (; n > 0; n = Math.floor(n / 2)) {
+      const o = r + n;
+      o <= s.length && i + f[o] <= t && (i += f[o], r = o);
+    }
+    return Math.min(s.length - 1, r);
+  }
+  function b(t, r) {
+    const i = /* @__PURE__ */ new Map();
+    for (let e = 0; e < t.length; e++) {
+      const a = t[e];
+      if (i.has(a)) throw new Error("Virtual list keys must be unique");
+      i.set(a, e);
+    }
+    const n = t.map((e, a) => l.get(e) ?? g(r(a))), o = [0, ...n];
+    for (let e = 1; e < o.length; e++) {
+      const a = e + (e & -e);
+      a < o.length && (o[a] += o[e]);
+    }
+    s = [...t], u = n, f = o, c = i;
+    for (const e of l.keys()) c.has(e) || l.delete(e);
+  }
+  function p(t, r) {
+    const i = c.get(t);
+    if (i === void 0) return !1;
+    const n = g(r);
+    l.set(t, n);
+    const o = u[i];
+    if (n === o) return !1;
+    u[i] = n;
+    for (let e = i + 1; e < f.length; e += e & -e) f[e] += n - o;
+    return !0;
+  }
+  function N(t) {
+    if (!(t < 0 || t >= s.length || !Number.isInteger(t)))
+      return { index: t, key: s[t], start: h(t), size: u[t] };
+  }
+  function k(t, r, i = 0) {
+    if (!s.length) return { start: 0, end: 0 };
+    const n = Number.isFinite(t) ? Math.max(0, t) : 0, o = Number.isFinite(r) ? Math.max(0, r) : 0, e = Number.isFinite(i) ? Math.max(0, Math.trunc(i)) : 0;
+    return { start: Math.max(0, M(n) - e), end: Math.min(s.length, M(n + o) + 1 + e) };
+  }
+  function F(t) {
+    if (!s.length) return;
+    const r = Number.isFinite(t) ? Math.max(0, t) : 0, i = M(r);
+    return { key: s[i], offset: Math.max(0, Math.min(u[i], r - h(i))) };
+  }
+  function d(t) {
+    const r = c.get(t.key);
+    if (r === void 0) return;
+    const i = Number.isFinite(t.offset) ? t.offset : 0;
+    return h(r) + Math.max(0, Math.min(u[r], i));
+  }
+  return {
+    reset: b,
+    measure: p,
+    item: N,
+    range: k,
+    anchor: F,
+    offset: d,
+    prefix: h,
+    total: () => h(s.length),
+    count: () => s.length,
+    measuredCount: () => l.size
+  };
+}
+export {
+  y as createVirtualListLayout
+};