Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

12.4 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

// Detach the stable portal target so React retains message state, refs and handlers.
export const REACH = 2000;
const FIND_FLAG = "data-find-bar-open";
const controllers = new WeakMap<HTMLElement, MessageWindowController>();

type Row = {
  root: HTMLElement;
  holder: HTMLElement;
  content: HTMLElement;
  text: HTMLElement;
  saved: Array<[string, string, string]> | null;
  frozen: Array<[string, string, string]> | null;
};

class MessageWindowController {
  private rows = new Map<Element, Row>();
  private observer: IntersectionObserver;
  private flags: MutationObserver;
  private media = window.matchMedia("print");
  private printing = this.media.matches;
  private pointerHeld = false;
  private scrollbarHeld = false;
  private frame = 0;
  private settling = false;

  private viewport: HTMLElement;
  private adjust: ((deltaPx: number) => void) | null = null;

  constructor(viewport: HTMLElement) {
    this.viewport = viewport;
    viewport.setAttribute("data-windowed-messages", "");
    // IO records may predate a scroll or prepend; read current geometry instead.
    this.observer = new IntersectionObserver(this.update,
      { root: viewport, rootMargin: `${REACH}px 0px` });
    this.flags = new MutationObserver(this.refresh);
    this.flags.observe(document.documentElement, { attributes: true, attributeFilter: [FIND_FLAG] });
    document.addEventListener("selectionchange", this.refresh);
    document.addEventListener("keydown", this.onKeyDown, true);
    viewport.addEventListener("pointerdown", this.onPointerDown, true);
    viewport.addEventListener("focusin", this.onFocus, true);
    viewport.addEventListener("scroll", this.onScroll, { passive: true });
    window.addEventListener("pointerup", this.onPointerUp, true);
    window.addEventListener("pointermove", this.onPointerMove, { capture: true, passive: true });
    window.addEventListener("pointercancel", this.onPointerUp, true);
    window.addEventListener("blur", this.onPointerUp);
    window.addEventListener("beforeprint", this.beforePrint);
    window.addEventListener("afterprint", this.afterPrint);
    this.media.addEventListener("change", this.printChanged);
  }

  add(root: HTMLElement, holder: HTMLElement, content: HTMLElement, adjust?: (deltaPx: number) => void): () => void {
    if (adjust) this.adjust = adjust;
    const text = document.createElement("span");
    text.className = "sr-only";
    const row: Row = { root, holder, content, text, saved: null, frozen: null };
    this.rows.set(root, row);
    this.observer.observe(root);
    return () => {
      this.restore(row, false);
      this.releaseHeight(row);
      this.observer.unobserve(root);
      this.rows.delete(root);
      if (this.rows.size === 0) this.dispose();
    };
  }

  private restoreHeight(row: Row, saved: Array<[string, string, string]>) {
    for (const [name, value, priority] of saved) {
      if (value) row.root.style.setProperty(name, value, priority);
      else row.root.style.removeProperty(name);
    }
  }

  private releaseHeight(row: Row): boolean {
    if (!row.frozen) return false;
    this.restoreHeight(row, row.frozen);
    row.frozen = null;
    return true;
  }

  private restore(row: Row, freeze = this.scrollbarHeld): boolean {
    if (!row.saved) return false;
    row.text.remove();
    row.holder.append(row.content);
    // Hold the scroll range steady until the native thumb is released. The reconnected body may
    // be taller than its frozen height after a reflow, so clip it until then instead of painting
    // over the next messages; release restores the original overflow with the height.
    if (freeze) {
      const style = row.root.style;
      // A row parked again mid drag carries its first frozen snapshot, original overflow included.
      row.frozen = row.saved.some(([name]) => name === "overflow")
        ? row.saved
        : [...row.saved, ["overflow", style.getPropertyValue("overflow"), style.getPropertyPriority("overflow")]];
      style.setProperty("overflow", "hidden");
      style.setProperty("overflow", "clip");
    } else this.restoreHeight(row, row.saved);
    row.saved = null;
    row.root.removeAttribute("data-message-parked");
    return true;
  }

  // Restored rows reflow at the current width; keep the first visible row where the reader left it.
  private keepAnchor(change: () => boolean, known?: { anchor: HTMLElement | null; before: number }) {
    let anchor: HTMLElement | null = known?.anchor ?? null;
    let before = known?.before ?? 0;
    if (!known) {
      const top = this.viewport.getBoundingClientRect().top;
      for (const row of this.rows.values()) {
        const rect = row.root.getBoundingClientRect();
        if (rect.bottom > top && (anchor === null || rect.top < before)) {
          anchor = row.root;
          before = rect.top;
        }
      }
    }
    // Nothing reconnected or released: skip the layout read on this scroll.
    if (!change() || anchor === null || !anchor.isConnected) return;
    // Zero when the engine anchored natively, so this never corrects twice.
    const delta = anchor.getBoundingClientRect().top - before;
    if (Math.abs(delta) < 0.5) return;
    // The autoscroll owner applies it instantly and resyncs its follow intent; a direct write would
    // animate under scroll-smooth and read as a downward reader scroll.
    if (this.adjust) this.adjust(delta);
    else this.viewport.scrollTo({ top: this.viewport.scrollTop + delta, behavior: "instant" });
  }

  private restoreAll = () => {
    this.keepAnchor(() => {
      let changed = false;
      for (const row of this.rows.values()) {
        changed = this.restore(row, false) || changed;
        changed = this.releaseHeight(row) || changed;
      }
      return changed;
    });
  };

  private held() {
    const selection = document.getSelection();
    return this.printing || document.documentElement.hasAttribute(FIND_FLAG)
      || (selection !== null && !selection.isCollapsed && selection.rangeCount > 0
        && selection.getRangeAt(0).intersectsNode(this.viewport));
  }

  private update = () => {
    if (this.held()) {
      this.restoreAll();
      return;
    }
    const wanted = new Set<Row>();
    const bounds = this.viewport.getBoundingClientRect();
    const reach = this.scrollbarHeld ? Math.min(REACH, bounds.height) : REACH;
    // Batch layout reads before reconnecting or detaching any subtree.
    const candidates: Array<[Row, number]> = [];
    const first: { anchor: HTMLElement | null; before: number } = { anchor: null, before: 0 };
    for (const row of this.rows.values()) {
      const rect = row.root.getBoundingClientRect();
      if (rect.bottom > bounds.top && (first.anchor === null || rect.top < first.before)) {
        first.anchor = row.root;
        first.before = rect.top;
      }
      const margin = row.saved ? reach : REACH;
      // Hysteresis avoids repeated swaps on small drag reversals.
      if (rect.bottom >= bounds.top - margin && rect.top <= bounds.bottom + margin
        || row.root.contains(document.activeElement)) {
        wanted.add(row);
        continue;
      }
      if (row.saved || this.pointerHeld || this.settling) continue;
      // Embedded media must stay connected, and wide replies own horizontal scroll range.
      if (row.content.querySelector("iframe, video, audio, canvas, textarea, [contenteditable=true]")) continue;
      const height = rect.height;
      if (height > 0 && row.root.scrollWidth <= row.root.clientWidth + 1) candidates.push([row, height]);
    }
    this.keepAnchor(() => this.apply(wanted, candidates), first);
  };

  private apply(wanted: Set<Row>, candidates: Array<[Row, number]>): boolean {
    let changed = candidates.length > 0;
    for (const row of this.rows.values()) {
      if (wanted.has(row) || row.root.contains(document.activeElement)) changed = this.restore(row) || changed;
    }
    for (const [row, height] of candidates) {
      row.saved = row.frozen ?? ["height"].map((name) =>
        [name, row.root.style.getPropertyValue(name), row.root.style.getPropertyPriority(name)]);
      row.frozen = null;
      // Preserve accessible text; focus restores the rich body.
      row.text.textContent = row.content.textContent;
      row.root.style.height = `${height}px`;
      row.content.remove();
      row.holder.append(row.text);
      row.root.setAttribute("data-message-parked", "");
    }
    return changed;
  }

  private refresh = () => {
    if (this.held()) this.restoreAll();
    if (this.frame) return;
    // Let find/print code-fence layout changes settle before parking bodies.
    this.settling = true;
    this.frame = requestAnimationFrame(() => {
      this.frame = requestAnimationFrame(() => {
        this.frame = 0;
        this.settling = false;
        this.update();
      });
    });
  };

  private onScroll = () => {
    // Restore before paint, including jumps that outrun IO.
    this.update();
  };

  private onFocus = (event: FocusEvent) => {
    for (const row of this.rows.values()) {
      if (row.root.contains(event.target as Node)) this.restore(row);
    }
  };
  private onPointerDown = (event: PointerEvent) => {
    if (event.button !== 0) return;
    // Native thumb hits target the viewport; text-selection drags target descendants.
    this.scrollbarHeld = event.target === this.viewport && event.pointerType === "mouse";
    this.pointerHeld = !this.scrollbarHeld;
    if (this.scrollbarHeld && !this.held()) {
      const active = [...this.rows.values()].filter((row) => !row.saved && !row.frozen);
      const heights = active.map((row) => row.root.getBoundingClientRect().height);
      active.forEach((row, index) => {
        row.frozen = [["height", row.root.style.getPropertyValue("height"), row.root.style.getPropertyPriority("height")]];
        row.root.style.height = `${heights[index]}px`;
      });
    }
  };
  private onPointerUp = () => {
    this.pointerHeld = false;
    this.scrollbarHeld = false;
    this.keepAnchor(() => {
      let changed = false;
      for (const row of this.rows.values()) changed = this.releaseHeight(row) || changed;
      return changed;
    });
    this.refresh();
  };
  private onPointerMove = (event: PointerEvent) => {
    if ((this.pointerHeld || this.scrollbarHeld) && event.buttons === 0) this.onPointerUp();
  };
  private onKeyDown = (event: KeyboardEvent) => {
    // Reconnect before the browser's select-all default action chooses its range.
    const target = event.target as Element | null;
    if (target?.closest?.("input, textarea, [contenteditable=true]")) return;
    if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "a") this.restoreAll();
  };
  private beforePrint = () => { this.printing = true; this.restoreAll(); };
  private afterPrint = () => { this.printing = this.media.matches; this.refresh(); };
  private printChanged = () => { this.printing = this.media.matches; this.refresh(); };

  private dispose() {
    this.observer.disconnect();
    this.flags.disconnect();
    cancelAnimationFrame(this.frame);
    document.removeEventListener("selectionchange", this.refresh);
    document.removeEventListener("keydown", this.onKeyDown, true);
    this.viewport.removeEventListener("pointerdown", this.onPointerDown, true);
    this.viewport.removeEventListener("focusin", this.onFocus, true);
    this.viewport.removeEventListener("scroll", this.onScroll);
    window.removeEventListener("pointerup", this.onPointerUp, true);
    window.removeEventListener("pointermove", this.onPointerMove, true);
    window.removeEventListener("pointercancel", this.onPointerUp, true);
    window.removeEventListener("blur", this.onPointerUp);
    window.removeEventListener("beforeprint", this.beforePrint);
    window.removeEventListener("afterprint", this.afterPrint);
    this.media.removeEventListener("change", this.printChanged);
    this.viewport.removeAttribute("data-windowed-messages");
    controllers.delete(this.viewport);
  }
}

export function observeMessageWindow(
  root: HTMLElement,
  holder: HTMLElement,
  content: HTMLElement,
  adjust?: (deltaPx: number) => void,
): (() => void) | undefined {
  const viewport = root.closest<HTMLElement>(".aui-thread-viewport");
  if (!viewport || typeof IntersectionObserver === "undefined") return;
  let controller = controllers.get(viewport);
  if (!controller) {
    controller = new MessageWindowController(viewport);
    controllers.set(viewport, controller);
  }
  return controller.add(root, holder, content, adjust);
}