Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

fix: preserve transcript following across streamed layout changes (#1157)

Joshua France8ee51add8204
diff --git a/plugins/web-ui/src/chat.ts b/plugins/web-ui/src/chat.ts
index 3524b3c9a..9ea6e0788 100644
--- a/plugins/web-ui/src/chat.ts
+++ b/plugins/web-ui/src/chat.ts
@@ -1276,6 +1276,7 @@ export function createChatSurface(
function drawActiveChat(agent = chatState.agent, opts: { forceScroll?: boolean } = {}): void {
if (!agent || agent !== chatState.agent || !chatState.host || appState.currentView !== "chats") return;
+ transcriptViewport.beforeRender();
const currentMessages = visibleMessages(agent);
const messages = chatState.inheritedExpanded
? [...chatState.inheritedMessages, ...currentMessages]
diff --git a/plugins/web-ui/src/shell.css b/plugins/web-ui/src/shell.css
index 54fa89bb2..224394fce 100644
--- a/plugins/web-ui/src/shell.css
+++ b/plugins/web-ui/src/shell.css
@@ -1795,6 +1795,10 @@ a.chat-row-open {
.streaming-text {
position: relative;
}
+.streaming-text.live-stream {
+ overflow-anchor: none;
+}
+
.streaming-text .tok-in {
animation: tok-in 0.42s ease-out both;
}
diff --git a/plugins/web-ui/src/transcript-viewport.ts b/plugins/web-ui/src/transcript-viewport.ts
index 363905574..079005e62 100644
--- a/plugins/web-ui/src/transcript-viewport.ts
+++ b/plugins/web-ui/src/transcript-viewport.ts
@@ -7,6 +7,10 @@ export function createTranscriptViewport() {
let promptKey: string | undefined;
let expanded = false;
let lastTop = 0;
+ let lastBottom = 0;
+ let previousBottom = 0;
+ let bottomChangedAt = 0;
+ let inputBottom: number | null = null;
let observer: ResizeObserver | null = null;
let following = false;
let frame: number | null = null;
@@ -16,7 +20,12 @@ export function createTranscriptViewport() {
if (scroller) scroller.style.overflowAnchor = value ? "none" : "";
}
+ function clearInput(): void {
+ inputBottom = null;
+ }
+
function cancelFollow(): void {
+ clearInput();
setFollowing(false);
if (frame !== null) cancelAnimationFrame(frame);
frame = null;
@@ -93,17 +102,51 @@ export function createTranscriptViewport() {
function onScroll(): void {
if (!scroller) return;
const atBottom = scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop <= 1;
- if (atBottom) setFollowing(true);
+ const reachedPreviousBottom =
+ scroller.scrollTop > lastTop &&
+ (Math.abs(scroller.scrollTop - lastBottom) <= 1 ||
+ (inputBottom !== null && Math.abs(scroller.scrollTop - inputBottom) <= 1));
+ if (atBottom || reachedPreviousBottom) setFollowing(true);
else if (scroller.scrollTop < lastTop) cancelFollow();
+ if (scroller.scrollTop !== lastTop) clearInput();
lastTop = scroller.scrollTop;
+ measureBottom();
syncSticky();
}
+ function measureBottom(): void {
+ if (!scroller) return;
+ const bottom = scroller.scrollHeight - scroller.clientHeight;
+ if (bottom === lastBottom) return;
+ previousBottom = lastBottom;
+ lastBottom = bottom;
+ bottomChangedAt = performance.now();
+ }
+
+ function beforeRender(): void {
+ if (!scroller) return;
+ if (scroller.scrollTop !== lastTop) onScroll();
+ measureBottom();
+ }
+
function onWheel(event: WheelEvent): void {
- if (event.deltaY < 0) cancelFollow();
+ if (!scroller) return;
+ if (event.deltaY < 0 && scroller.scrollTop > 0) cancelFollow();
+ if (event.deltaY > 0) {
+ clearInput();
+ inputBottom = scroller.scrollHeight - scroller.clientHeight;
+ }
+ if (
+ event.deltaY > 0 &&
+ event.timeStamp < bottomChangedAt &&
+ scroller.scrollTop > lastTop &&
+ Math.abs(scroller.scrollTop - previousBottom) <= 1
+ )
+ setFollowing(true);
}
function dispose(): void {
+ clearInput();
if (frame !== null) cancelAnimationFrame(frame);
frame = null;
observer?.disconnect();
@@ -111,11 +154,13 @@ export function createTranscriptViewport() {
scroller?.removeEventListener("scroll", onScroll);
scroller?.removeEventListener("wheel", onWheel);
scroller?.removeEventListener("click", onClick);
+ scroller?.removeEventListener("pointerdown", clearInput);
+ scroller?.removeEventListener("keydown", clearInput);
scroller?.style.removeProperty("--chat-sticky-top");
scroller?.style.removeProperty("overflow-anchor");
clearPrompt();
scroller = pins = prompt = stack = content = null;
- lastTop = 0;
+ lastTop = lastBottom = previousBottom = bottomChangedAt = 0;
following = false;
}
@@ -126,12 +171,16 @@ export function createTranscriptViewport() {
dispose();
scroller = element;
lastTop = scroller?.scrollTop ?? 0;
+ lastBottom = previousBottom = scroller ? scroller.scrollHeight - scroller.clientHeight : 0;
setFollowing(false);
scroller?.addEventListener("scroll", onScroll, { passive: true });
scroller?.addEventListener("wheel", onWheel, { passive: true });
scroller?.addEventListener("click", onClick);
+ scroller?.addEventListener("pointerdown", clearInput);
+ scroller?.addEventListener("keydown", clearInput);
if (typeof ResizeObserver !== "undefined") {
observer = new ResizeObserver(() => {
+ beforeRender();
syncSticky();
follow();
});
@@ -192,5 +241,5 @@ export function createTranscriptViewport() {
});
}
- return { sync, follow, dispose };
+ return { sync, follow, beforeRender, dispose };
}
diff --git a/plugins/web-ui/test/transcript-viewport.test.ts b/plugins/web-ui/test/transcript-viewport.test.ts
index 102f5f260..0300ba286 100644
--- a/plugins/web-ui/test/transcript-viewport.test.ts
+++ b/plugins/web-ui/test/transcript-viewport.test.ts
@@ -88,6 +88,12 @@ function fixture() {
promptTop = top;
resize();
},
+ fit: () => {
+ height = 200;
+ s.scrollTop = 0;
+ s.dispatchEvent(new dom.window.Event("scroll"));
+ writes.length = 0;
+ },
grow: () => {
height += 100;
},
@@ -171,6 +177,20 @@ test("even a small upward scroll stops following; returning to the bottom resume
}
});
+test("an upward wheel that cannot move a short transcript keeps following its growth", () => {
+ const f = fixture();
+ try {
+ f.fit();
+ f.wheelUp();
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 100);
+ } finally {
+ f.close();
+ }
+});
+
test("an upward wheel cancels a queued follow before its scroll event arrives", () => {
const f = fixture();
try {
@@ -366,3 +386,216 @@ test("marginal overflow is shown in full without an expansion control", () => {
f.close();
}
});
+
+test("returning to the bottom before a streamed render resumes follow before its scroll event", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.s.scrollTop = 800;
+ f.viewport.beforeRender();
+ f.grow();
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.Event("scroll"));
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 900);
+ } finally {
+ f.close();
+ }
+});
+
+test("a pre-render check leaves readers above the bottom alone", () => {
+ const f = fixture();
+ try {
+ f.scroll(600);
+ f.s.scrollTop = 798;
+ f.viewport.beforeRender();
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 798);
+ } finally {
+ f.close();
+ }
+});
+
+test("a pre-render check respects an upward wheel whose scroll has not arrived", () => {
+ const f = fixture();
+ try {
+ f.wheelUp();
+ f.viewport.beforeRender();
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 800);
+ } finally {
+ f.close();
+ }
+});
+
+test("a pre-render check handles an upward scroll before its event", () => {
+ const f = fixture();
+ try {
+ f.s.scrollTop = 790;
+ f.viewport.beforeRender();
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 790);
+ } finally {
+ f.close();
+ }
+});
+
+test("a deferred scroll event recognizes the previous bottom after asynchronous content growth", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.s.scrollTop = 800;
+ f.grow();
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.Event("scroll"));
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 900);
+ } finally {
+ f.close();
+ }
+});
+
+test("a measured resize invalidates the previous bottom for readers who have not moved", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.grow();
+ f.resize(30, 50);
+ f.scroll(800);
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 800);
+ } finally {
+ f.close();
+ }
+});
+
+test("passing the previous bottom without reaching the new bottom does not resume follow", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.grow();
+ f.scroll(850);
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 850);
+ } finally {
+ f.close();
+ }
+});
+
+test("the changing streamed reply cannot become the browser's native scroll anchor", () => {
+ assert.match(css, /\.streaming-text\.live-stream \{\s*overflow-anchor: none;/);
+});
+
+test("a resize callback records a pending return before replacing the measured bottom", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.s.scrollTop = 800;
+ f.grow();
+ f.resize(30, 50);
+ f.flush();
+ assert.equal(f.s.scrollTop, 900);
+ } finally {
+ f.close();
+ }
+});
+
+test("asynchronous growth leaves a reader in place and advances the measured bottom", () => {
+ const f = fixture();
+ try {
+ f.scroll(600);
+ f.grow();
+ f.resize(30, 50);
+ f.flush();
+ assert.equal(f.s.scrollTop, 600);
+ f.scroll(800);
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 800);
+ } finally {
+ f.close();
+ }
+});
+
+test("a downward wheel preserves its bottom through multiple layouts before native scrolling", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.WheelEvent("wheel", { deltaY: 300 }));
+ f.grow();
+ f.resize(30, 50);
+ f.grow();
+ f.resize(30, 50);
+ f.scroll(800);
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 1000);
+ } finally {
+ f.close();
+ }
+});
+
+test("a compositor scroll can arrive before its delayed wheel event", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ const wheel = new f.s.ownerDocument.defaultView!.WheelEvent("wheel", { deltaY: 300 });
+ Object.defineProperty(wheel, "timeStamp", { value: 0 });
+ f.grow();
+ f.resize(30, 50);
+ f.s.scrollTop = 800;
+ f.s.dispatchEvent(wheel);
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.Event("scroll"));
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 900);
+ } finally {
+ f.close();
+ }
+});
+
+test("a fresh wheel after layout cannot resume at an obsolete bottom", () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.grow();
+ f.resize(30, 50);
+ f.s.scrollTop = 800;
+ const wheel = new f.s.ownerDocument.defaultView!.WheelEvent("wheel", { deltaY: 100 });
+ Object.defineProperty(wheel, "timeStamp", { value: performance.now() + 1 });
+ f.s.dispatchEvent(wheel);
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.Event("scroll"));
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 800);
+ } finally {
+ f.close();
+ }
+});
+
+for (const type of ["pointerdown", "keydown"]) {
+ test(`${type} invalidates an unfinished wheel gesture`, () => {
+ const f = fixture();
+ try {
+ f.scroll(700);
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.WheelEvent("wheel", { deltaY: 300 }));
+ f.grow();
+ f.resize(30, 50);
+ f.s.dispatchEvent(new f.s.ownerDocument.defaultView!.Event(type, { bubbles: true }));
+ f.scroll(800);
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 800);
+ } finally {
+ f.close();
+ }
+ });
+}