Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

fix: coordinate sticky prompts and transcript following

Josh France46dfbe485c0b
diff --git a/plugins/web-ui/src/chat.ts b/plugins/web-ui/src/chat.ts
index db70c1658..6362630a9 100644
--- a/plugins/web-ui/src/chat.ts
+++ b/plugins/web-ui/src/chat.ts
@@ -130,6 +130,8 @@ import { tip } from "./tooltip";
import { workSeconds, workedLabel } from "./work-duration";
import { decorateTextCodeBlocks, normalizePlainTextFences } from "./text-code";
+import { createTranscriptViewport } from "./transcript-viewport";
+
installMarkdownSanitizer();
const detachedAgents = new WeakSet<Agent>();
@@ -188,6 +190,7 @@ export function createChatSurface(
dependencies: { fetchTranscript?: typeof fetchTranscript; openSession?: typeof openSession } = {},
): ChatSurface {
const runSlot = createRunSlot();
+ const transcriptViewport = createTranscriptViewport();
const transcriptFetcher = dependencies.fetchTranscript ?? fetchTranscript;
const sessionOpener = dependencies.openSession ?? openSession;
@@ -281,6 +284,7 @@ export function createChatSurface(
let readOnlyView: { id: string; threadRef: string; session: CoreSession; anchorSeq: number | null } | null = null;
function teardownActiveChat(): void {
+ transcriptViewport.dispose();
forkOriginController.invalidateRefresh();
readOnlyView = null;
preserveOutgoingWorkingDot(null);
@@ -467,7 +471,6 @@ export function createChatSurface(
});
});
- stickToBottom = true;
container.replaceChildren(chatState.host);
const opening = startProactiveOpenerIfNew(agent, threadRef, normalStreamFn, onWork, sessionId, scopeId, messages);
drawActiveChat(agent, { forceScroll: true });
@@ -1024,7 +1027,10 @@ export function createChatSurface(
`,
host,
);
- requestAnimationFrame(() => decorateTextCodeBlocks(host));
+ requestAnimationFrame(() => {
+ decorateTextCodeBlocks(host);
+ if (host.isConnected) transcriptViewport.sync(host.querySelector<HTMLElement>(".chat-scroll"));
+ });
};
readonlyRedraw = draw;
draw();
@@ -1263,7 +1269,7 @@ export function createChatSurface(
}
${glanceTier || ctx.pane ? nothing : sessionTopbar()}
${glanceTier ? paneGlance(agent, messages, glanceTier) : nothing}
- <section class="chat-scroll" @scroll=${onTranscriptScroll}>
+ <section class="chat-scroll">
${pinnedStrip()}
<div class="message-stack ${emptyChat ? "empty-stack" : ""}">
${inheritedHeader()} ${chatState.earlierCount > 0 ? earlierNotice(agent) : nothing} ${messageContent}
@@ -2657,34 +2663,13 @@ export function createChatSurface(
return fileChip(file.name, file.sizeBytes, href);
}
- let stickToBottom = true;
-
- function onTranscriptScroll(e: Event): void {
- const s = e.currentTarget as HTMLElement;
- stickToBottom = s.scrollHeight - s.scrollTop - s.clientHeight <= 120;
- }
-
function scrollToBottom(): void {
- stickToBottom = true;
scrollTranscript(true);
}
function scrollTranscript(force = false): void {
- const scroller = ctx.container()?.querySelector<HTMLElement>(".chat-scroll");
- if (!scroller) return;
- if (!force && !stickToBottom) return;
- requestAnimationFrame(() => {
- if (force) {
- const prev = scroller.style.scrollBehavior;
- scroller.style.scrollBehavior = "auto";
- scroller.scrollTop = scroller.scrollHeight;
- requestAnimationFrame(() => {
- scroller.style.scrollBehavior = prev;
- });
- return;
- }
- scroller.scrollTop = scroller.scrollHeight;
- });
+ transcriptViewport.sync(ctx.container()?.querySelector<HTMLElement>(".chat-scroll") ?? null);
+ transcriptViewport.follow(force);
}
redrawHooks.add(redrawForConnector);
diff --git a/plugins/web-ui/src/composer.ts b/plugins/web-ui/src/composer.ts
index 1fe33dad1..a93be0d87 100644
--- a/plugins/web-ui/src/composer.ts
+++ b/plugins/web-ui/src/composer.ts
@@ -1869,10 +1869,14 @@ export function createComposerSurface(ctx: ConvCtx): ComposerSurface {
}
if (ta.value === autosizedValue) return;
autosizedValue = ta.value;
+ const wrap = ta.closest<HTMLElement>(".composer-wrap");
+ const wrapHeight = wrap?.style.height ?? "";
+ if (wrap) wrap.style.height = `${wrap.getBoundingClientRect().height}px`;
ta.style.height = "auto";
const cap = parseFloat(getComputedStyle(ta).maxHeight) || 180;
const content = ta.scrollHeight;
ta.style.height = `${Math.min(cap, Math.max(ctx.pane ? 0 : 48, content))}px`;
+ if (wrap) wrap.style.height = wrapHeight;
if (content > cap) {
ta.style.overflowY = "auto";
} else {
diff --git a/plugins/web-ui/src/shell.css b/plugins/web-ui/src/shell.css
index c2b5c0f1d..71b8c377b 100644
--- a/plugins/web-ui/src/shell.css
+++ b/plugins/web-ui/src/shell.css
@@ -1320,7 +1320,7 @@ a.chat-row-open {
scrollbar-gutter: stable;
padding: var(--chat-scroll-pad-top) var(--chat-pad) var(--chat-scroll-pad-bottom);
- scroll-behavior: smooth;
+ scroll-behavior: auto;
}
.fork-origin-row {
@@ -1393,7 +1393,7 @@ a.chat-row-open {
}
.pinned-strip.expanded {
padding: 6px 10px;
- max-height: min(38vh, 240px);
+ max-height: min(38cqh, 240px);
overflow-y: auto;
}
.pinned-strip-head {
@@ -1530,7 +1530,7 @@ a.chat-row-open {
}
.message-stack .user-row:not(:has(~ .user-row)) {
position: sticky;
- top: calc(-1 * var(--chat-scroll-pad-top, 0px));
+ top: var(--chat-sticky-top, 0px);
z-index: 3;
padding-top: 14px;
margin-top: -14px;
@@ -1539,11 +1539,26 @@ a.chat-row-open {
pointer-events: none;
}
+.message-stack .user-row.sticky-disabled {
+ position: relative;
+ top: auto;
+}
+
.message-stack .user-row:not(:has(~ .user-row)) > .user-bubble {
pointer-events: auto;
+ transition: box-shadow 120ms ease;
+}
+
+.message-stack .user-row.stuck > .user-bubble {
box-shadow: var(--chat-surface-shadow);
}
+@media (prefers-reduced-motion: reduce) {
+ .message-stack .user-row > .user-bubble {
+ transition: none;
+ }
+}
+
.assistant-row + .user-row {
margin-top: 10px;
}
diff --git a/plugins/web-ui/src/transcript-viewport.ts b/plugins/web-ui/src/transcript-viewport.ts
new file mode 100644
index 000000000..5f4803b96
--- /dev/null
+++ b/plugins/web-ui/src/transcript-viewport.ts
@@ -0,0 +1,136 @@
+export function createTranscriptViewport() {
+ let scroller: HTMLElement | null = null;
+ let pins: HTMLElement | null = null;
+ let prompt: HTMLElement | null = null;
+ let stack: HTMLElement | null = null;
+ let lastTop = 0;
+ let observer: ResizeObserver | null = null;
+ let following = false;
+ let frame: number | null = null;
+
+ function setFollowing(value: boolean): void {
+ following = value;
+ if (scroller) scroller.style.overflowAnchor = value ? "none" : "";
+ }
+
+ function cancelFollow(): void {
+ setFollowing(false);
+ if (frame !== null) cancelAnimationFrame(frame);
+ frame = null;
+ }
+
+ function syncSticky(): void {
+ if (!scroller) return;
+ const top = pins?.getBoundingClientRect().height ?? 0;
+ scroller.style.setProperty("--chat-sticky-top", `${top}px`);
+ const style = getComputedStyle(scroller);
+ const paddingTop = parseFloat(style.paddingTop) || 0;
+ const paddingBottom = parseFloat(style.paddingBottom) || 0;
+ const promptMargin = prompt ? parseFloat(getComputedStyle(prompt).marginBottom) || 0 : 0;
+ const canStick =
+ !!prompt &&
+ prompt.getBoundingClientRect().height + promptMargin + top + paddingTop + paddingBottom <= scroller.clientHeight;
+ prompt?.classList.toggle("sticky-disabled", !canStick);
+ prompt?.classList.toggle(
+ "stuck",
+ canStick &&
+ scroller.scrollTop > 0 &&
+ prompt.getBoundingClientRect().top <=
+ scroller.getBoundingClientRect().top + scroller.clientTop + paddingTop + top + 0.5,
+ );
+ }
+
+ function onScroll(): void {
+ if (!scroller) return;
+ const atBottom = scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop <= 1;
+ if (atBottom) setFollowing(true);
+ else if (scroller.scrollTop < lastTop) cancelFollow();
+ lastTop = scroller.scrollTop;
+ syncSticky();
+ }
+
+ function onWheel(event: WheelEvent): void {
+ if (event.deltaY < 0) cancelFollow();
+ }
+
+ function dispose(): void {
+ if (frame !== null) cancelAnimationFrame(frame);
+ frame = null;
+ observer?.disconnect();
+ observer = null;
+ scroller?.removeEventListener("scroll", onScroll);
+ scroller?.removeEventListener("wheel", onWheel);
+ scroller?.style.removeProperty("--chat-sticky-top");
+ scroller?.style.removeProperty("overflow-anchor");
+ prompt?.classList.remove("stuck", "sticky-disabled");
+ scroller = pins = prompt = stack = null;
+ lastTop = 0;
+ following = false;
+ }
+
+ function sync(element: HTMLElement | null): void {
+ let changed = false;
+ if (scroller !== element) {
+ changed = true;
+ dispose();
+ scroller = element;
+ lastTop = scroller?.scrollTop ?? 0;
+ setFollowing(false);
+ scroller?.addEventListener("scroll", onScroll, { passive: true });
+ scroller?.addEventListener("wheel", onWheel, { passive: true });
+ if (typeof ResizeObserver !== "undefined") {
+ observer = new ResizeObserver(() => {
+ syncSticky();
+ follow();
+ });
+ if (scroller) observer.observe(scroller);
+ }
+ }
+ const nextStack = scroller?.querySelector<HTMLElement>(".message-stack") ?? null;
+ if (stack !== nextStack) {
+ changed = true;
+ if (stack) observer?.unobserve(stack);
+ stack = nextStack;
+ if (stack) observer?.observe(stack);
+ }
+ const nextPins = scroller?.querySelector<HTMLElement>(".pinned-strip") ?? null;
+ const nextPrompt = scroller?.querySelector<HTMLElement>(".message-stack .user-row:not(:has(~ .user-row))") ?? null;
+ if (pins !== nextPins) {
+ changed = true;
+ if (pins) observer?.unobserve(pins);
+ pins = nextPins;
+ if (pins) observer?.observe(pins);
+ }
+ if (prompt !== nextPrompt) {
+ changed = true;
+ prompt?.classList.remove("stuck", "sticky-disabled");
+ if (prompt) observer?.unobserve(prompt);
+ prompt = nextPrompt;
+ if (prompt) observer?.observe(prompt);
+ }
+ if (changed) syncSticky();
+ }
+
+ function follow(force = false): void {
+ if (force) {
+ setFollowing(true);
+ lastTop = scroller?.scrollTop ?? 0;
+ if (frame !== null) cancelAnimationFrame(frame);
+ frame = null;
+ }
+ if (!scroller || !following || frame !== null) return;
+ const element = scroller;
+ const priorTop = element.scrollTop;
+ frame = requestAnimationFrame(() => {
+ frame = null;
+ if (element !== scroller || !element.isConnected || !following) return;
+ if (element.scrollTop < priorTop && element.scrollHeight - element.clientHeight - element.scrollTop > 1)
+ return cancelFollow();
+ element.scrollTop = element.scrollHeight;
+ lastTop = scroller?.scrollTop ?? 0;
+ syncSticky();
+ });
+ }
+
+ return { sync, follow, dispose };
+}
diff --git a/plugins/web-ui/test/chat-elevation.test.ts b/plugins/web-ui/test/chat-elevation.test.ts
index 14efcd2a2..0995004b3 100644
--- a/plugins/web-ui/test/chat-elevation.test.ts
+++ b/plugins/web-ui/test/chat-elevation.test.ts
@@ -11,18 +11,17 @@ test("transcript edges do not blur or mask the response", () => {
});
test("the pinned prompt and composer have elevated solid surfaces", () => {
- const pinned =
- css.match(/\.message-stack \.user-row:not\(:has\(~ \.user-row\)\) > \.user-bubble \{[^}]*\}/)?.[0] ?? "";
+ const pinned = css.match(/\.message-stack \.user-row\.stuck > \.user-bubble \{[^}]*\}/)?.[0] ?? "";
const composer = css.match(/^\.composer-wrap \{[^}]*\}/m)?.[0] ?? "";
assert.match(pinned, /box-shadow: var\(--chat-surface-shadow\);/);
assert.match(composer, /background: var\(--background\);/);
assert.match(composer, /box-shadow: var\(--chat-surface-shadow\);/);
});
-test("prompt elevation is shared by every transcript without scroll-handler state", () => {
+test("prompt elevation uses the shared surface shadow only while stuck", () => {
const root = css.match(/:root \{[^}]*\}/)?.[0] ?? "";
const chat = readFileSync(new URL("../src/chat.ts", import.meta.url), "utf8");
assert.match(root, /--chat-surface-shadow:/);
- assert.doesNotMatch(css, /\.user-row\.stuck/);
+ assert.match(css, /\.user-row\.stuck/);
assert.doesNotMatch(chat, /markStuckUserRow/);
});
diff --git a/plugins/web-ui/test/css-vars.test.ts b/plugins/web-ui/test/css-vars.test.ts
index 800ce2b28..1f521d41e 100644
--- a/plugins/web-ui/test/css-vars.test.ts
+++ b/plugins/web-ui/test/css-vars.test.ts
@@ -35,7 +35,7 @@ test("every drop zone the canvas renders has a positioning rule in shell.css", (
test("only the elevated chat surfaces paint a shadow", () => {
const elevated = [
".pinned-strip",
- ".message-stack .user-row:not(:has(~ .user-row)) > .user-bubble",
+ ".message-stack .user-row.stuck > .user-bubble",
".composer-wrap",
];
const rules = shellCss.replace(/\/\*[\s\S]*?\*\//g, "");
diff --git a/plugins/web-ui/test/layout-thrash.test.ts b/plugins/web-ui/test/layout-thrash.test.ts
index a26fdc142..15843a473 100644
--- a/plugins/web-ui/test/layout-thrash.test.ts
+++ b/plugins/web-ui/test/layout-thrash.test.ts
@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
import test from "node:test";
const composer = readFileSync(new URL("../src/composer.ts", import.meta.url), "utf8");
+const viewport = readFileSync(new URL("../src/transcript-viewport.ts", import.meta.url), "utf8");
const chat = readFileSync(new URL("../src/chat.ts", import.meta.url), "utf8");
test("resizeComposer skips the forced-reflow measure pass when the draft value is unchanged", () => {
@@ -20,25 +21,32 @@ test("a box-size change re-arms the composer measure via ResizeObserver (fires a
assert.match(composer, /autosizeObserver\.unobserve\(autosizedTa\)/, "the replaced input must be unobserved");
});
-test("scrollTranscript's skip path performs zero layout reads", () => {
- const fn = chat.match(/function scrollTranscript\(force = false\): void \{[\s\S]*?\n\}/)?.[0] ?? "";
- const beforeRaf = fn.slice(0, fn.indexOf("requestAnimationFrame"));
- for (const read of ["scrollHeight", "clientHeight", "scrollTop -", "getBoundingClientRect"]) {
- assert.ok(!beforeRaf.includes(read), `no sync layout read before the rAF: found ${read}`);
- }
- assert.match(fn, /if \(!force && !stickToBottom\) return;/);
+test("bottom-follow's skip path performs zero layout reads", () => {
+ const fn = viewport.slice(viewport.indexOf(" function follow("));
+ const skip = fn.indexOf("if (!scroller || !following || frame !== null) return;");
+ const firstRead = fn.indexOf("const priorTop = element.scrollTop;");
+ assert.ok(skip >= 0 && skip < firstRead);
+ assert.match(viewport, /if \(changed\) syncSticky\(\);/);
});
-test("bottom-stickiness is tracked by the scroller's own scroll listener, and a fresh mount starts pinned", () => {
- assert.match(chat, /class="chat-scroll" @scroll=\$\{onTranscriptScroll\}/);
- assert.match(chat, /stickToBottom = s\.scrollHeight - s\.scrollTop - s\.clientHeight <= 120;/);
- assert.match(chat, /let stickToBottom = true;/);
+test("bottom-follow belongs to each scroller, and fresh mounts start pinned", () => {
+ assert.match(viewport, /addEventListener\("scroll", onScroll/);
+ assert.match(viewport, /const atBottom = scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop <= 1;/);
+ assert.match(viewport, /if \(force\) \{\s*setFollowing\(true\);/);
});
-test("revealing a transcript re-arms auto-follow; read-only mounts start at the end except pagination", () => {
- assert.match(chat, /function scrollToBottom\(\): void \{\s*stickToBottom = true;\s*scrollTranscript\(true\);/);
+test("revealing a transcript re-arms follow; read-only mounts start at the end except pagination", () => {
+ assert.match(chat, /function scrollToBottom\(\): void \{\s*scrollTranscript\(true\);/);
assert.match(chat, /if \(!sameSession\) scrollToBottom\(\);/);
- assert.match(chat, /const scroller = ctx\.container\(\)\?\.querySelector/);
+ assert.match(chat, /transcriptViewport.follow\(force\);/);
+});
+
+test("composer measurement holds its outer height instead of temporarily resizing the transcript", () => {
+ const fn = composer.slice(composer.indexOf(" function resizeComposer("));
+ const lock = fn.indexOf("wrap.style.height = `${wrap.getBoundingClientRect().height}px`");
+ const measure = fn.indexOf('ta.style.height = "auto"');
+ const release = fn.indexOf("wrap.style.height = wrapHeight");
+ assert.ok(lock >= 0 && lock < measure && release > measure);
});
test("both pagination paths adjust their anchor without smooth scrolling", () => {
diff --git a/plugins/web-ui/test/transcript-viewport.test.ts b/plugins/web-ui/test/transcript-viewport.test.ts
new file mode 100644
index 000000000..b11f4772c
--- /dev/null
+++ b/plugins/web-ui/test/transcript-viewport.test.ts
@@ -0,0 +1,262 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+
+const css = readFileSync(new URL("../src/shell.css", import.meta.url), "utf8");
+const chat = readFileSync(new URL("../src/chat.ts", import.meta.url), "utf8");
+
+test("only an actually stuck prompt gets elevation", () => {
+ const normal =
+ css.match(/\.message-stack \.user-row:not\(:has\(~ \.user-row\)\) > \.user-bubble \{[^}]*\}/)?.[0] ?? "";
+ assert.doesNotMatch(normal, /box-shadow: var/);
+ assert.match(css, /\.user-row\.stuck > \.user-bubble/);
+});
+
+test("prompt offset reserves the pane's measured pins height", () => {
+ assert.match(css, /top: var\(--chat-sticky-top, 0px\)/);
+ assert.match(css, /max-height: min\(38cqh, 240px\)/);
+});
+
+test("stream following never uses smooth scrolling or a near-bottom zone", () => {
+ const scroller = css.match(/\.chat-scroll \{[^}]*\}/)?.[0] ?? "";
+ assert.doesNotMatch(scroller, /scroll-behavior: smooth/);
+ assert.doesNotMatch(chat, /<= 120/);
+});
+
+import { JSDOM } from "jsdom";
+import { createTranscriptViewport } from "../src/transcript-viewport.ts";
+
+function fixture() {
+ const dom = new JSDOM(
+ '<section><div class="pinned-strip"></div><div class="message-stack"><article class="user-row"></article></div></section>',
+ );
+ const s = dom.window.document.querySelector("section")!;
+ const pins = s.querySelector<HTMLElement>(".pinned-strip")!;
+ const prompt = s.querySelector<HTMLElement>(".user-row")!;
+ let height = 1000;
+ let pinsHeight = 30;
+ let promptTop = 50;
+ Object.defineProperties(s, { scrollHeight: { get: () => height }, clientHeight: { value: 200 } });
+ s.scrollTop = 800;
+ s.getBoundingClientRect = () => ({ top: 20 }) as DOMRect;
+ pins.getBoundingClientRect = () => ({ height: pinsHeight }) as DOMRect;
+ prompt.getBoundingClientRect = () => ({ top: promptTop, height: 50 }) as DOMRect;
+ const writes: number[] = [];
+ let top = s.scrollTop;
+ Object.defineProperty(s, "scrollTop", {
+ get: () => top,
+ set: (value: number) => {
+ writes.push(value);
+ top = Math.min(value, height - 200);
+ },
+ });
+ const frames = new Map<number, FrameRequestCallback>();
+ let id = 0;
+ let resize = () => {};
+ const restore = ["requestAnimationFrame", "cancelAnimationFrame", "ResizeObserver", "getComputedStyle"].map(
+ (key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)] as const,
+ );
+ Object.assign(globalThis, {
+ getComputedStyle: dom.window.getComputedStyle.bind(dom.window),
+ requestAnimationFrame: (cb: FrameRequestCallback) => {
+ frames.set(++id, cb);
+ return id;
+ },
+ cancelAnimationFrame: (n: number) => frames.delete(n),
+ ResizeObserver: class {
+ constructor(cb: () => void) {
+ resize = cb;
+ }
+ observe() {}
+ unobserve() {}
+ disconnect() {}
+ },
+ });
+ const viewport = createTranscriptViewport();
+ viewport.sync(s);
+ viewport.follow(true);
+ for (const cb of frames.values()) cb(0);
+ frames.clear();
+ writes.length = 0;
+ return {
+ s,
+ prompt,
+ viewport,
+ writes,
+ resize: (pinHeight: number, top: number) => {
+ pinsHeight = pinHeight;
+ promptTop = top;
+ resize();
+ },
+ grow: () => {
+ height += 100;
+ },
+ scroll: (top: number) => {
+ s.scrollTop = top;
+ s.dispatchEvent(new dom.window.Event("scroll"));
+ },
+ wheelUp: () => s.dispatchEvent(new dom.window.WheelEvent("wheel", { deltaY: -1 })),
+ flush: () => {
+ const pending = [...frames.values()];
+ frames.clear();
+ for (const cb of pending) cb(0);
+ },
+ close: () => {
+ viewport.dispose();
+ dom.window.close();
+ for (const [key, descriptor] of restore) {
+ if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+ else Reflect.deleteProperty(globalThis, key);
+ }
+ },
+ };
+}
+
+test("a bottom-pinned stream follows growth instantly and coalesces frames", () => {
+ const f = fixture();
+ try {
+ f.grow();
+ f.viewport.follow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 900);
+ assert.deepEqual(f.writes, [1100]);
+ } finally {
+ f.close();
+ }
+});
+
+test("even a small upward scroll stops following; returning to the bottom resumes it", () => {
+ const f = fixture();
+ try {
+ f.scroll(798);
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 798);
+ assert.deepEqual(f.writes, [798]);
+ f.scroll(900);
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 1000);
+ } finally {
+ f.close();
+ }
+});
+
+test("an upward wheel cancels a queued follow before its scroll event arrives", () => {
+ const f = fixture();
+ try {
+ f.grow();
+ f.viewport.follow();
+ f.wheelUp();
+ f.flush();
+ assert.equal(f.writes.length, 0);
+ } finally {
+ f.close();
+ }
+});
+
+test("scrolling between scheduling and painting cannot be overwritten", () => {
+ const f = fixture();
+ try {
+ f.grow();
+ f.viewport.follow();
+ f.s.scrollTop -= 10;
+ f.flush();
+ assert.deepEqual(f.writes, [790]);
+ } finally {
+ f.close();
+ }
+});
+
+test("only reaching the sticky edge elevates the prompt; pin resizes update the edge", () => {
+ const f = fixture();
+ try {
+ f.resize(30, 200);
+ assert.equal(f.prompt.classList.contains("stuck"), false);
+ f.resize(30, 50);
+ assert.equal(f.prompt.classList.contains("stuck"), true);
+ f.resize(90, 110);
+ assert.equal(f.s.style.getPropertyValue("--chat-sticky-top"), "90px");
+ assert.equal(f.prompt.classList.contains("stuck"), true);
+ f.scroll(0);
+ assert.equal(f.prompt.classList.contains("stuck"), false);
+ } finally {
+ f.close();
+ }
+});
+
+test("disposing cancels queued work and clears sticky presentation", () => {
+ const f = fixture();
+ try {
+ f.viewport.follow();
+ f.viewport.dispose();
+ f.flush();
+ assert.equal(f.writes.length, 0);
+ assert.equal(f.prompt.classList.contains("stuck"), false);
+ assert.equal(f.s.style.getPropertyValue("--chat-sticky-top"), "");
+ } finally {
+ f.close();
+ }
+});
+
+test("native scroll anchoring is restored when the reader leaves the bottom", () => {
+ const f = fixture();
+ try {
+ assert.equal(f.s.style.overflowAnchor, "none");
+ f.scroll(700);
+ assert.equal(f.s.style.overflowAnchor, "");
+ f.scroll(800);
+ assert.equal(f.s.style.overflowAnchor, "none");
+ } finally {
+ f.close();
+ }
+});
+
+test("replacing a scroller does not arm follow without an explicit fresh-session jump", () => {
+ const f = fixture();
+ try {
+ f.viewport.dispose();
+ f.viewport.sync(f.s);
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.writes.length, 0);
+ f.viewport.follow(true);
+ f.flush();
+ assert.equal(f.writes.length, 1);
+ } finally {
+ f.close();
+ }
+});
+
+test("redrawing unchanged nodes while reading performs no layout reads", () => {
+ const f = fixture();
+ try {
+ f.scroll(600);
+ f.s.getBoundingClientRect = () => {
+ throw new Error("unexpected layout read");
+ };
+ f.viewport.sync(f.s);
+ f.viewport.follow();
+ f.flush();
+ assert.deepEqual(f.writes, [600]);
+ } finally {
+ f.close();
+ }
+});
+
+test("a prompt stays in flow when pins leave too little room, and can stick again after resizing", () => {
+ const f = fixture();
+ try {
+ f.resize(160, 180);
+ assert.equal(f.prompt.classList.contains("sticky-disabled"), true);
+ assert.equal(f.prompt.classList.contains("stuck"), false);
+ f.resize(30, 50);
+ assert.equal(f.prompt.classList.contains("sticky-disabled"), false);
+ assert.equal(f.prompt.classList.contains("stuck"), true);
+ } finally {
+ f.close();
+ }
+});