inline-chat-kit 0.54.1 → 0.54.3

package/CHANGELOG.md

@@ -8,6 +8,81 @@ The versions before 1.0 follow the pre-release convention: **a breaking change
 or new public API bumps the minor**, and the patch is for fixes. Anything that would break an
 existing install is called out under **Breaking**, with what to do about it.
 
+## 0.54.3 — 2026-09-13
+
+### Fixed
+
+- **The sent message flickered a pixel up and down for the whole length of
+  every answer after the first.** Measured while a second answer was written:
+  the message sat at y=100 and flipped to 101 and back thirty-one times, with
+  the room under the conversation going 418, 379, 374, 372, 362, 360, 351
+  underneath it — a new value on every frame.
+
+  It was a feedback loop. That room is part of `scrollHeight`, the scroll
+  target is clamped to `scrollHeight`, and the room was recomputed from
+  measurements on every frame: the room moved the view, the view moved the
+  measurements, and the measurements moved the room. Sized to be *exactly*
+  enough for the anchored turn to reach the anchor, the clamp sat on a knife
+  edge and a fraction of a pixel chose the side.
+
+  A floor does not drop while the thing standing on it is still standing. So
+  while a turn is anchored the room only grows, and it is recomputed the
+  moment the anchor is let go — a long answer carries some spare room until it
+  settles, and nothing carries it afterwards. Growing stays allowed, which is
+  what keeps it self-correcting: a first measurement taken before layout is
+  final is raised by the next one rather than standing for the whole answer.
+
+  After: the message decelerates into the anchor and then holds one position
+  for the rest of the answer — 473 frames at a 680px viewport, 466 at 1400px,
+  not one of them a pixel off.
+
+### Internal
+
+- **`follow-check` has a guard for it**, and it had none before: every check
+  in there measured a *transition* — where a message lands, where the view
+  comes to rest, whether it travelled — and this fault lived in the quiet
+  stretch between them, which is why it was reported three times and "fixed"
+  twice on measurements that were each true.
+
+  The window comes from `aria-busy`, which the turn already carries for
+  screen readers while its answer arrives, so it is the window the assertion
+  names rather than one inferred from the turn's height — that one ran past
+  the end of the answer and counted the settle. The fault inside it is a
+  **reversal**, because jitter is not motion, it is motion that changes its
+  mind; the arrival is required to move and is asserted elsewhere. A creep
+  never reverses, so the back half of the window has to be a single number as
+  well, and that number the anchor.
+
+  Watched failing on the fault before it was trusted: 4 reversals at both
+  heights with the room recomputing per frame, none with the floor.
+
+## 0.54.2 — 2026-09-12
+
+### Fixed
+
+- **The sent message leapt off the top of the view when an answer settled.**
+  Measured on the demo at 1100×700, at the frame the turn count went from one
+  to two: `scrollTop` 0 → 175, in a single frame, and the message that had
+  just been sent went from 100px down the view to −75.
+
+  It was not the scroll logic. `Conversation` made **exactly one** correction
+  in the whole session — a smooth one, arriving after the jump had already
+  happened. The jump was `focus()`: when an answer settles the next turn is
+  appended, its composer mounts at the bottom of the conversation and focuses
+  itself, and focusing an element brings it into view. Instantly, and without
+  asking anyone.
+
+  `preventScroll` now. Where the view goes belongs to `Conversation`, which
+  knows about anchors, tails, and whether the reader has scrolled away; focus
+  is about the keyboard. The same moment is now eight frames with a largest
+  step of 48px.
+
+  Three traces to find, because every instrument pointed at the scroll logic
+  and the scroll logic was innocent. The first two also measured the wrong
+  element — during an answer the last editable belongs to the turn being
+  written, and afterwards to a different turn entirely, so the trace read a
+  change of subject as a movement.
+
 ## 0.54.1 — 2026-09-12
 
 ### Fixed

package/dist/inline-chat-kit.js

@@ -853,7 +853,7 @@ var Ue = {
 		Le,
 		et
 	]), o(() => {
-		(e === "idle" || e === "typing") && F.current?.focus();
+		(e === "idle" || e === "typing") && F.current?.focus({ preventScroll: !0 });
 	}, [e]), o(() => {
 		let e = F.current;
 		e && (ve.current = e.scrollHeight || 17);
@@ -4950,17 +4950,18 @@ var Xr = {
 		let n = t.lastElementChild, a = n ? ei(n, e) + n.offsetHeight : ei(t, e) + t.offsetHeight - D.current;
 		return Math.max(0, a + r - e.clientHeight);
 	}, [r, i]), j = a(() => {
-		let e = S.current, t = C.current;
-		if (!e || !t) return;
-		if (i !== "auto") return ni(t, D, Math.max(0, i));
-		let a = parseFloat(getComputedStyle(e).paddingBottom) || 0, o = Math.max(0, r - a), s = t.lastElementChild, c = ti(e, O.current);
-		if (k.current = !!s && !!c, !k.current || !s || !c) return ni(t, D, o);
-		let l = ei(s, e) + s.offsetHeight - ei(c, e);
-		ni(t, D, Math.max(o, e.clientHeight - n - l - a));
+		let e = S.current, a = C.current;
+		if (!e || !a) return;
+		if (i !== "auto") return ni(a, D, Math.max(0, i));
+		let o = parseFloat(getComputedStyle(e).paddingBottom) || 0, s = Math.max(0, r - o), c = a.lastElementChild, l = ti(e, O.current);
+		if (k.current = !!c && !!l, !k.current || !c || !l) return ni(a, D, s);
+		let u = ei(c, e) + c.offsetHeight - ei(l, e), d = Math.max(s, e.clientHeight - n - u - o);
+		ni(a, D, t ? Math.max(d, D.current) : d);
 	}, [
 		i,
 		n,
-		r
+		r,
+		t
 	]), M = a(() => {
 		let e = S.current;
 		if (!e) return 0;
@@ -4996,12 +4997,20 @@ var Xr = {
 		let e = S.current, n = C.current;
 		if (!e || !n || typeof ResizeObserver > "u") return;
 		let r = () => {
-			let t = M();
+			let n = M();
 			if (N.current) {
-				if (performance.now() < N.current && Math.abs(e.scrollTop - t) > 1) return;
+				if (performance.now() < N.current && Math.abs(e.scrollTop - n) > 1) return;
 				N.current = 0;
 			}
-			e.scrollTop = t;
+			let r = n - e.scrollTop;
+			if (O.current && !t && Math.abs(r) > s && !K()) {
+				N.current = performance.now() + Qr, e.scrollTo({
+					top: n,
+					behavior: "smooth"
+				});
+				return;
+			}
+			e.scrollTop = n;
 		}, i = t != null && t !== P.current;
 		t && (P.current = t), i && !K() && Math.abs(e.scrollTop - M()) > s ? (N.current = performance.now() + Qr, e.scrollTo({
 			top: M(),