@adea-ai/ui 0.63.2 → 0.63.4

package/README.md

@@ -153,6 +153,28 @@ The toolbar switches theme, accent, typeface and density live, which is the
 fastest way to see how a component behaves across the catalogue rather than in
 one theme.
 
+## Transcript follow
+
+`ConversationSurface` follows streamed text, earlier-row growth, turn collapse
+and pane resizing using the KiroCrew plain-scroller decision contract. A
+deliberate upward scroll releases follow, including small moves near the bottom.
+Returning to the bottom or choosing **Jump to latest** re-arms it; the action
+does not estimate unread messages from pixel distance. Instant pins keep
+self-scroll attribution synchronized. Keyboard jumping returns focus to the
+transcript when its jump control disappears; automatic pins never move focus.
+
+`threshold` controls jump-button visibility (80px by default), independently of
+follow intent. `follow={false}` is fully inert: positioning belongs to the host,
+with no observer or mount pin. Re-enabling it explicitly re-arms at the bottom;
+it is not an automatic restore-and-resume flag. An optional `resetKey` also
+re-arms follow when that identity changes. Canonical
+session identity, durable restoration and virtualized transcript windows remain
+application-owned. `ref` and `onScroll` still reach the inner scroller.
+
+`bun run test:components` checks the built component in Chromium and WebKit.
+The `SurfaceFollowing` story exercises streaming, collapse and pane resizing;
+source/license/test provenance is recorded in `NOTICE`.
+
 ## Composer keyboard behavior
 
 `MessageComposer` preserves native IME candidate commits and suppresses sending

package/dist/NOTICE

@@ -49,6 +49,37 @@ Origin UI / coss (AGPL-3.0-or-later) was consulted for visual ideas only. No
 code, class string, or asset from that project is reproduced here, because its
 licence is incompatible with this distribution.
 
+## Plain transcript follow translated from KiroCrew
+
+`packages/ui/src/components/conversation/scroll-follow-core.ts`,
+`scroll-follow.ts` and ConversationSurface substantially translate the plain
+scroller lifecycle in `website/src/app-sdk/useChatScrollFollow.ts` and its pure
+`website/src/hooks/virtualizer/FollowController.ts` decisions, pinned at
+`283e136c0f902e965a535a7c9548c57c7504fed0`.
+
+    Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+    This product includes software developed at Amazon.com, Inc.
+    (https://www.amazon.com/). Licensed under the Apache License, Version 2.0.
+
+Retained: separate follow intent and jump visibility, synchronous scroll-up race
+fencing, direction-aware re-engagement, self-scroll attribution, DPR tolerance,
+content growth/collapse and viewport shrink/growth distinctions, instant pins,
+explicit disabled/reset behavior and content/viewport observer cleanup. Solid
+ownership replaces React refs/effects. Applications retain identity, durable
+scroll restoration and virtualized row measurement/anchor authority.
+
+The jump label follows `website/src/app-sdk/ChatScrollChrome.tsx`'s action-only
+contract; pixel distance cannot establish an unread message count. The existing
+shared button appearance and configurable 80px visibility default are retained.
+Keyboard jumping returns focus to the focusable transcript as its jump control
+disappears; this hardens a donor edge case without moving focus during automatic
+pins. No donor edge-fade styling, React runtime, virtualizer, asset, font or session
+store is copied. Tests translate applicable cases from
+`website/src/test/useChatScrollFollow.test.tsx` and `FollowController.test.ts`;
+Bun/browser integration and deterministic bounded grids replace React/jsdom,
+Vitest and fast-check without adding dependencies. The full Chat product
+composition and application adoption remain separate gates.
+
 ## Composer IME input ownership translated from KiroCrew
 
 `packages/ui/src/components/conversation/ime-guard.ts` and its MessageComposer

package/dist/components/conversation/conversation-surface.d.ts

@@ -10,7 +10,7 @@ import type { ComponentProps, JSX } from 'solid-js';
  *     to the end by an arriving message, and that is the single most common way a
  *     chat surface is made unusable.
  *   - **Offer a way back.** Once the reader is not at the bottom, a control appears
- *     that returns them and says how much they have missed.
+ *     that returns them. Pixel distance cannot prove an unread message count.
  *   - **`overscroll-contain`.** The transcript scrolls to its end and stops, rather
  *     than dragging the pane behind it — which in a desktop shell means the whole
  *     window moves.
@@ -18,6 +18,10 @@ import type { ComponentProps, JSX } from 'solid-js';
 export type ConversationSurfaceProps = ComponentProps<'div'> & {
     /** How far from the bottom still counts as "at the bottom", in px. */
     threshold?: number;
+    /** Disable automatic positioning while the host owns scroll restoration. */
+    follow?: boolean;
+    /** Optional conversation identity: changing it re-arms follow at the bottom. */
+    resetKey?: string;
     /** Rendered above the transcript when there is nothing in it. */
     empty?: JSX.Element;
     /** A header that scrolls with the transcript, e.g. a day divider or a banner. */

package/dist/components/conversation/conversation-surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conversation-surface.d.ts","sourceRoot":"","sources":["../../../src/components/conversation/conversation-surface.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAKnD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,wBAAwB,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IAC7D,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,iEAAiE;IACjE,KAAK,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;IACnB,iFAAiF;IACjF,MAAM,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;CACrB,CAAA;AAOD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,eAsElE"}
+{"version":3,"file":"conversation-surface.d.ts","sourceRoot":"","sources":["../../../src/components/conversation/conversation-surface.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAMnD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,wBAAwB,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IAC7D,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iEAAiE;IACjE,KAAK,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;IACnB,iFAAiF;IACjF,MAAM,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;CACrB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,eAmElE"}

package/dist/components/conversation/conversation-surface.js

@@ -1,63 +1,50 @@
 import { cn } from "../../lib/utils.js";
 import { Button } from "../ui/button/button.js";
-import { className, createComponent, effect, insert, memo, spread, template, use } from "solid-js/web";
+import { createScrollFollow } from "./scroll-follow.js";
+import { className, createComponent, effect, insert, mergeProps, spread, template, use } from "solid-js/web";
 import { ArrowDown } from "lucide-solid";
-import { Show, createSignal, onCleanup, splitProps } from "solid-js";
+import { Show, splitProps } from "solid-js";
 //#region src/components/conversation/conversation-surface.tsx
 var _tmpl$ = /*#__PURE__*/ template(`<div class="pointer-events-none absolute inset-x-0 bottom-3 flex justify-center">`);
-var _tmpl$2 = /*#__PURE__*/ template(`<div data-slot=conversation-surface><div class="min-h-0 flex-1 overflow-y-auto overscroll-contain">`);
+var _tmpl$2 = /*#__PURE__*/ template(`<div data-slot=conversation-surface><div class="min-h-0 flex-1 overflow-y-auto overscroll-contain"><div data-slot=conversation-content>`);
 var _tmpl$3 = /*#__PURE__*/ template(`<div class=p-4>`);
-/** How far the reader is from the end of the transcript, in px. */
-function distanceFromBottom(element) {
-	return element.scrollHeight - element.scrollTop - element.clientHeight;
-}
 function ConversationSurface(props) {
 	const [local, rest] = splitProps(props, [
 		"class",
 		"threshold",
+		"follow",
+		"resetKey",
 		"empty",
 		"header",
-		"children"
+		"children",
+		"onScroll",
+		"ref",
+		"tabindex"
 	]);
-	const [atBottom, setAtBottom] = createSignal(true);
-	const [missed, setMissed] = createSignal(0);
-	let scroller;
-	const onScroll = () => {
-		if (!scroller) return;
-		const distance = distanceFromBottom(scroller);
-		const threshold = local.threshold ?? 80;
-		setAtBottom(distance <= threshold);
-		setMissed(distance <= threshold ? 0 : Math.round(distance / 96));
-	};
-	const jumpToLatest = () => {
-		scroller?.scrollTo({
-			top: scroller.scrollHeight,
-			behavior: "smooth"
-		});
-		setAtBottom(true);
-		setMissed(0);
-	};
-	const observer = () => {
-		if (!scroller) return;
-		const mutation = new MutationObserver(() => {
-			if (atBottom()) scroller?.scrollTo({ top: scroller.scrollHeight });
-			else onScroll();
-		});
-		mutation.observe(scroller, {
-			childList: true,
-			subtree: true
-		});
-		onCleanup(() => mutation.disconnect());
+	const follow = createScrollFollow({
+		enabled: () => local.follow !== false,
+		resetKey: () => local.resetKey,
+		threshold: () => local.threshold ?? 80
+	});
+	const onScroll = (event) => {
+		follow.onScroll();
+		const handler = local.onScroll;
+		if (typeof handler === "function") handler(event);
+		else if (handler) handler[0](handler[1], event);
 	};
 	return (() => {
-		var _el$ = _tmpl$2(), _el$2 = _el$.firstChild;
+		var _el$ = _tmpl$2(), _el$2 = _el$.firstChild, _el$3 = _el$2.firstChild;
 		_el$2.addEventListener("scroll", onScroll);
 		use((element) => {
-			scroller = element;
-			observer();
+			follow.bindScroller(element);
+			if (typeof local.ref === "function") local.ref(element);
 		}, _el$2);
-		spread(_el$2, rest, false, true);
-		insert(_el$2, createComponent(Show, {
+		spread(_el$2, mergeProps({ get tabindex() {
+			return local.tabindex ?? 0;
+		} }, rest), false, true);
+		var _ref$ = follow.bindContent;
+		typeof _ref$ === "function" ? use(_ref$, _el$3) : follow.bindContent = _el$3;
+		insert(_el$3, createComponent(Show, {
 			get when() {
 				return local.header;
 			},
@@ -65,15 +52,15 @@ function ConversationSurface(props) {
 				return local.header;
 			}
 		}), null);
-		insert(_el$2, createComponent(Show, {
+		insert(_el$3, createComponent(Show, {
 			get when() {
 				return local.children;
 			},
 			get fallback() {
 				return (() => {
-					var _el$4 = _tmpl$3();
-					insert(_el$4, () => local.empty);
-					return _el$4;
+					var _el$5 = _tmpl$3();
+					insert(_el$5, () => local.empty);
+					return _el$5;
 				})();
 			},
 			get children() {
@@ -82,30 +69,23 @@ function ConversationSurface(props) {
 		}), null);
 		insert(_el$, createComponent(Show, {
 			get when() {
-				return !atBottom();
+				return !follow.atBottom();
 			},
 			get children() {
-				var _el$3 = _tmpl$();
-				insert(_el$3, createComponent(Button, {
+				var _el$4 = _tmpl$();
+				insert(_el$4, createComponent(Button, {
+					type: "button",
 					size: "sm",
 					variant: "secondary",
 					"class": "pointer-events-auto gap-1.5 shadow-md",
-					onClick: jumpToLatest,
+					get onClick() {
+						return follow.jump;
+					},
 					get children() {
-						return [createComponent(ArrowDown, {}), createComponent(Show, {
-							get when() {
-								return missed() > 0;
-							},
-							get fallback() {
-								return "Jump to latest";
-							},
-							get children() {
-								return [memo(() => missed()), " new"];
-							}
-						})];
+						return [createComponent(ArrowDown, {}), "Jump to latest"];
 					}
 				}));
-				return _el$3;
+				return _el$4;
 			}
 		}), null);
 		effect(() => className(_el$, cn("relative flex min-h-0 flex-1 flex-col", local.class)));

package/dist/components/conversation/conversation-surface.js.map

@@ -1 +1 @@
-{"version":3,"file":"conversation-surface.js","names":["ArrowDown","ComponentProps","JSX","Show","createSignal","onCleanup","splitProps","cn","Button","ConversationSurfaceProps","threshold","empty","Element","header","distanceFromBottom","element","HTMLDivElement","scrollHeight","scrollTop","clientHeight","ConversationSurface","props","local","rest","atBottom","setAtBottom","missed","setMissed","scroller","onScroll","distance","Math","round","jumpToLatest","scrollTo","top","behavior","observer","mutation","MutationObserver","observe","childList","subtree","disconnect","_el$","_tmpl$2","_el$2","firstChild","addEventListener","_$use","_$spread","_$insert","_$createComponent","when","children","fallback","_el$4","_tmpl$3","_el$3","_tmpl$","size","variant","onClick","_$memo","_$effect","_$className","class","_$createComponent","_$memo","_$className"],"sources":["../../../src/components/conversation/conversation-surface.tsx"],"sourcesContent":["import { ArrowDown } from 'lucide-solid'\nimport type { ComponentProps, JSX } from 'solid-js'\nimport { Show, createSignal, onCleanup, splitProps } from 'solid-js'\nimport { cn } from '#lib/utils'\nimport { Button } from '../ui/button/button'\n\n/**\n * ConversationSurface.\n *\n * The scrolling transcript. Its job is small and it is the difference between a\n * transcript that stays readable as it grows and one that fights the reader:\n *\n *   - **Stick to the bottom.** New messages scroll into view only when the reader is\n *     already at the bottom. Someone reading back through history must not be yanked\n *     to the end by an arriving message, and that is the single most common way a\n *     chat surface is made unusable.\n *   - **Offer a way back.** Once the reader is not at the bottom, a control appears\n *     that returns them and says how much they have missed.\n *   - **`overscroll-contain`.** The transcript scrolls to its end and stops, rather\n *     than dragging the pane behind it — which in a desktop shell means the whole\n *     window moves.\n */\nexport type ConversationSurfaceProps = ComponentProps<'div'> & {\n  /** How far from the bottom still counts as \"at the bottom\", in px. */\n  threshold?: number\n  /** Rendered above the transcript when there is nothing in it. */\n  empty?: JSX.Element\n  /** A header that scrolls with the transcript, e.g. a day divider or a banner. */\n  header?: JSX.Element\n}\n\n/** How far the reader is from the end of the transcript, in px. */\nfunction distanceFromBottom(element: HTMLDivElement): number {\n  return element.scrollHeight - element.scrollTop - element.clientHeight\n}\n\nexport function ConversationSurface(props: ConversationSurfaceProps) {\n  const [local, rest] = splitProps(props, ['class', 'threshold', 'empty', 'header', 'children'])\n\n  const [atBottom, setAtBottom] = createSignal(true)\n  const [missed, setMissed] = createSignal(0)\n  let scroller: HTMLDivElement | undefined\n\n  const onScroll = () => {\n    if (!scroller) return\n    const distance = distanceFromBottom(scroller)\n    const threshold = local.threshold ?? 80\n    setAtBottom(distance <= threshold)\n    setMissed(distance <= threshold ? 0 : Math.round(distance / 96))\n  }\n\n  const jumpToLatest = () => {\n    scroller?.scrollTo({ top: scroller.scrollHeight, behavior: 'smooth' })\n    setAtBottom(true)\n    setMissed(0)\n  }\n\n  // An arriving message while the reader is at the bottom should follow it. While\n  // they are not, it must not.\n  const observer = () => {\n    if (!scroller) return\n    const mutation = new MutationObserver(() => {\n      if (atBottom()) scroller?.scrollTo({ top: scroller.scrollHeight })\n      else onScroll()\n    })\n    mutation.observe(scroller, { childList: true, subtree: true })\n    onCleanup(() => mutation.disconnect())\n  }\n\n  return (\n    <div\n      data-slot=\"conversation-surface\"\n      class={cn('relative flex min-h-0 flex-1 flex-col', local.class)}\n    >\n      <div\n        ref={(element) => {\n          scroller = element\n          observer()\n        }}\n        onScroll={onScroll}\n        class=\"min-h-0 flex-1 overflow-y-auto overscroll-contain\"\n        {...rest}\n      >\n        <Show when={local.header}>{local.header}</Show>\n        <Show when={local.children} fallback={<div class=\"p-4\">{local.empty}</div>}>\n          {local.children}\n        </Show>\n      </div>\n\n      <Show when={!atBottom()}>\n        <div class=\"pointer-events-none absolute inset-x-0 bottom-3 flex justify-center\">\n          <Button\n            size=\"sm\"\n            variant=\"secondary\"\n            class=\"pointer-events-auto gap-1.5 shadow-md\"\n            onClick={jumpToLatest}\n          >\n            <ArrowDown />\n            <Show when={missed() > 0} fallback={<>Jump to latest</>}>\n              {missed()} new\n            </Show>\n          </Button>\n        </div>\n      </Show>\n    </div>\n  )\n}\n"],"mappings":";;;;;;;;;;AAgCA,SAASc,mBAAmBC,SAAiC;CAC3D,OAAOA,QAAQE,eAAeF,QAAQG,YAAYH,QAAQI;AAC5D;AAEA,SAAgBC,oBAAoBC,OAAiC;CACnE,MAAM,CAACC,OAAOC,QAAQjB,WAAWe,OAAO;EAAC;EAAS;EAAa;EAAS;EAAU;CAAU,CAAC;CAE7F,MAAM,CAACG,UAAUC,eAAerB,aAAa,IAAI;CACjD,MAAM,CAACsB,QAAQC,aAAavB,aAAa,CAAC;CAC1C,IAAIwB;CAEJ,MAAMC,iBAAiB;EACrB,IAAI,CAACD,UAAU;EACf,MAAME,WAAWhB,mBAAmBc,QAAQ;EAC5C,MAAMlB,YAAYY,MAAMZ,aAAa;EACrCe,YAAYK,YAAYpB,SAAS;EACjCiB,UAAUG,YAAYpB,YAAY,IAAIqB,KAAKC,MAAMF,WAAW,EAAE,CAAC;CACjE;CAEA,MAAMG,qBAAqB;EACzBL,UAAUM,SAAS;GAAEC,KAAKP,SAASX;GAAcmB,UAAU;EAAS,CAAC;EACrEX,YAAY,IAAI;EAChBE,UAAU,CAAC;CACb;CAIA,MAAMU,iBAAiB;EACrB,IAAI,CAACT,UAAU;EACf,MAAMU,WAAW,IAAIC,uBAAuB;GAC1C,IAAIf,SAAS,GAAGI,UAAUM,SAAS,EAAEC,KAAKP,SAASX,aAAa,CAAC;QAC5DY,SAAS;EAChB,CAAC;EACDS,SAASE,QAAQZ,UAAU;GAAEa,WAAW;GAAMC,SAAS;EAAK,CAAC;EAC7DrC,gBAAgBiC,SAASK,WAAW,CAAC;CACvC;CAEA,cAAA;EAAA,IAAAC,OAAAC,QAAA,GAAAC,QAAAF,KAAAG;EAAAD,MAAAE,iBAAA,UAUgBnB,QAAQ;EAAAoB,KAJZlC,YAAY;GAChBa,WAAWb;GACXsB,SAAS;EACX,GAACS,KAAA;EAAAI,OAAAJ,OAGGvB,MAAI,OAAA,IAAA;EAAA4B,OAAAL,OAAAM,gBAEPjD,MAAI;GAAA,IAACkD,OAAI;IAAA,OAAE/B,MAAMT;GAAM;GAAA,IAAAyC,WAAA;IAAA,OAAGhC,MAAMT;GAAM;EAAA,CAAA,GAAA,IAAA;EAAAsC,OAAAL,OAAAM,gBACtCjD,MAAI;GAAA,IAACkD,OAAI;IAAA,OAAE/B,MAAMgC;GAAQ;GAAA,IAAEC,WAAQ;IAAA,cAAA;KAAA,IAAAC,QAAAC,QAAA;KAAAN,OAAAK,aAAoBlC,MAAMX,KAAK;KAAA,OAAA6C;IAAA,EAAA,CAAA;GAAA;GAAA,IAAAF,WAAA;IAAA,OAChEhC,MAAMgC;GAAQ;EAAA,CAAA,GAAA,IAAA;EAAAH,OAAAP,MAAAQ,gBAIlBjD,MAAI;GAAA,IAACkD,OAAI;IAAA,OAAE,CAAC7B,SAAS;GAAC;GAAA,IAAA8B,WAAA;IAAA,IAAAI,QAAAC,OAAA;IAAAR,OAAAO,OAAAN,gBAElB5C,QAAM;KACLoD,MAAI;KACJC,SAAO;KAAA,SAAA;KAEPC,SAAS7B;KAAY,IAAAqB,WAAA;MAAA,OAAA,CAAAF,gBAEpBpD,WAAS,CAAA,CAAA,GAAAoD,gBACTjD,MAAI;OAAA,IAACkD,OAAI;QAAA,OAAE3B,OAAO,IAAI;OAAC;OAAA,IAAE6B,WAAQ;QAAA,OAAA;OAAA;OAAA,IAAAD,WAAA;QAAA,OAAA,CAAAS,WAC/BrC,OAAO,CAAC,GAAA,MAAA;OAAA;MAAA,CAAA,CAAA;KAAA;IAAA,CAAA,CAAA;IAAA,OAAAgC;GAAA;EAAA,CAAA,GAAA,IAAA;EAAAM,aAAAC,UAAArB,MA3BVrC,GAAG,yCAAyCe,MAAM4C,KAAK,CAAC,CAAA;EAAA,OAAAtB;CAAA,EAAA,CAAA;AAkCrE"}
+{"version":3,"file":"conversation-surface.js","names":["ArrowDown","ComponentProps","JSX","Show","splitProps","cn","Button","createScrollFollow","ConversationSurfaceProps","threshold","follow","resetKey","empty","Element","header","ConversationSurface","props","local","rest","enabled","onScroll","EventHandlerUnion","HTMLDivElement","Event","event","handler","_el$","_tmpl$2","_el$2","firstChild","_el$3","addEventListener","_$use","element","bindScroller","ref","_$spread","_$mergeProps","tabindex","_ref$","bindContent","_$insert","_$createComponent","when","children","fallback","_el$5","_tmpl$3","atBottom","_el$4","_tmpl$","type","size","variant","onClick","jump","_$effect","_$className","class","_$mergeProps","_$use","_$createComponent","_$className"],"sources":["../../../src/components/conversation/conversation-surface.tsx"],"sourcesContent":["import { ArrowDown } from 'lucide-solid'\nimport type { ComponentProps, JSX } from 'solid-js'\nimport { Show, splitProps } from 'solid-js'\nimport { cn } from '#lib/utils'\nimport { Button } from '../ui/button/button'\nimport { createScrollFollow } from './scroll-follow'\n\n/**\n * ConversationSurface.\n *\n * The scrolling transcript. Its job is small and it is the difference between a\n * transcript that stays readable as it grows and one that fights the reader:\n *\n *   - **Stick to the bottom.** New messages scroll into view only when the reader is\n *     already at the bottom. Someone reading back through history must not be yanked\n *     to the end by an arriving message, and that is the single most common way a\n *     chat surface is made unusable.\n *   - **Offer a way back.** Once the reader is not at the bottom, a control appears\n *     that returns them. Pixel distance cannot prove an unread message count.\n *   - **`overscroll-contain`.** The transcript scrolls to its end and stops, rather\n *     than dragging the pane behind it — which in a desktop shell means the whole\n *     window moves.\n */\nexport type ConversationSurfaceProps = ComponentProps<'div'> & {\n  /** How far from the bottom still counts as \"at the bottom\", in px. */\n  threshold?: number\n  /** Disable automatic positioning while the host owns scroll restoration. */\n  follow?: boolean\n  /** Optional conversation identity: changing it re-arms follow at the bottom. */\n  resetKey?: string\n  /** Rendered above the transcript when there is nothing in it. */\n  empty?: JSX.Element\n  /** A header that scrolls with the transcript, e.g. a day divider or a banner. */\n  header?: JSX.Element\n}\n\nexport function ConversationSurface(props: ConversationSurfaceProps) {\n  const [local, rest] = splitProps(props, [\n    'class',\n    'threshold',\n    'follow',\n    'resetKey',\n    'empty',\n    'header',\n    'children',\n    'onScroll',\n    'ref',\n    'tabindex',\n  ])\n  // Kobalte provides the control's semantics; transcript follow is a native\n  // geometry contract. KiroCrew's plain-scroller controller handles streaming,\n  // content collapse and pane resizing without treating them as user consent.\n  const follow = createScrollFollow({\n    enabled: () => local.follow !== false,\n    resetKey: () => local.resetKey,\n    threshold: () => local.threshold ?? 80,\n  })\n  const onScroll: JSX.EventHandlerUnion<HTMLDivElement, Event> = (event) => {\n    follow.onScroll()\n    const handler = local.onScroll\n    if (typeof handler === 'function') handler(event)\n    else if (handler) handler[0](handler[1], event)\n  }\n\n  return (\n    <div\n      data-slot=\"conversation-surface\"\n      class={cn('relative flex min-h-0 flex-1 flex-col', local.class)}\n    >\n      <div\n        ref={(element) => {\n          follow.bindScroller(element)\n          if (typeof local.ref === 'function') local.ref(element)\n        }}\n        onScroll={onScroll}\n        tabindex={local.tabindex ?? 0}\n        class=\"min-h-0 flex-1 overflow-y-auto overscroll-contain\"\n        {...rest}\n      >\n        <div ref={follow.bindContent} data-slot=\"conversation-content\">\n          <Show when={local.header}>{local.header}</Show>\n          <Show when={local.children} fallback={<div class=\"p-4\">{local.empty}</div>}>\n            {local.children}\n          </Show>\n        </div>\n      </div>\n\n      <Show when={!follow.atBottom()}>\n        <div class=\"pointer-events-none absolute inset-x-0 bottom-3 flex justify-center\">\n          <Button\n            type=\"button\"\n            size=\"sm\"\n            variant=\"secondary\"\n            class=\"pointer-events-auto gap-1.5 shadow-md\"\n            onClick={follow.jump}\n          >\n            <ArrowDown />\n            Jump to latest\n          </Button>\n        </div>\n      </Show>\n    </div>\n  )\n}\n"],"mappings":";;;;;;;;;;AAoCA,SAAgBe,oBAAoBC,OAAiC;CACnE,MAAM,CAACC,OAAOC,QAAQd,WAAWY,OAAO;EACtC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CAAU,CACX;CAID,MAAMN,SAASH,mBAAmB;EAChCY,eAAeF,MAAMP,WAAW;EAChCC,gBAAgBM,MAAMN;EACtBF,iBAAiBQ,MAAMR,aAAa;CACtC,CAAC;CACD,MAAMW,YAA0DI,UAAU;EACxEd,OAAOU,SAAS;EAChB,MAAMK,UAAUR,MAAMG;EACtB,IAAI,OAAOK,YAAY,YAAYA,QAAQD,KAAK;OAC3C,IAAIC,SAASA,QAAQ,EAAE,CAACA,QAAQ,IAAID,KAAK;CAChD;CAEA,cAAA;EAAA,IAAAE,OAAAC,QAAA,GAAAC,QAAAF,KAAAG,YAAAC,QAAAF,MAAAC;EAAAD,MAAAG,iBAAA,UAUgBX,QAAQ;EAAAY,KAJZC,YAAY;GAChBvB,OAAOwB,aAAaD,OAAO;GAC3B,IAAI,OAAOhB,MAAMkB,QAAQ,YAAYlB,MAAMkB,IAAIF,OAAO;EACxD,GAACL,KAAA;EAAAQ,OAAAR,OAAAS,WAAA,EAAA,IAEDC,WAAQ;GAAA,OAAErB,MAAMqB,YAAY;EAAC,EAAA,GAEzBpB,IAAI,GAAA,OAAA,IAAA;EAAA,IAAAqB,QAEE7B,OAAO8B;EAAW,OAAAD,UAAA,aAAAP,IAAAO,OAAAT,KAAA,IAAlBpB,OAAO8B,cAAWV;EAAAW,OAAAX,OAAAY,gBACzBvC,MAAI;GAAA,IAACwC,OAAI;IAAA,OAAE1B,MAAMH;GAAM;GAAA,IAAA8B,WAAA;IAAA,OAAG3B,MAAMH;GAAM;EAAA,CAAA,GAAA,IAAA;EAAA2B,OAAAX,OAAAY,gBACtCvC,MAAI;GAAA,IAACwC,OAAI;IAAA,OAAE1B,MAAM2B;GAAQ;GAAA,IAAEC,WAAQ;IAAA,cAAA;KAAA,IAAAC,QAAAC,QAAA;KAAAN,OAAAK,aAAoB7B,MAAML,KAAK;KAAA,OAAAkC;IAAA,EAAA,CAAA;GAAA;GAAA,IAAAF,WAAA;IAAA,OAChE3B,MAAM2B;GAAQ;EAAA,CAAA,GAAA,IAAA;EAAAH,OAAAf,MAAAgB,gBAKpBvC,MAAI;GAAA,IAACwC,OAAI;IAAA,OAAE,CAACjC,OAAOsC,SAAS;GAAC;GAAA,IAAAJ,WAAA;IAAA,IAAAK,QAAAC,OAAA;IAAAT,OAAAQ,OAAAP,gBAEzBpC,QAAM;KACL6C,MAAI;KACJC,MAAI;KACJC,SAAO;KAAA,SAAA;KAAA,IAEPC,UAAO;MAAA,OAAE5C,OAAO6C;KAAI;KAAA,IAAAX,WAAA;MAAA,OAAA,CAAAF,gBAEnB1C,WAAS,CAAA,CAAA,GAAA,gBAAA;KAAA;IAAA,CAAA,CAAA;IAAA,OAAAiD;GAAA;EAAA,CAAA,GAAA,IAAA;EAAAO,aAAAC,UAAA/B,MA7BTrB,GAAG,yCAAyCY,MAAMyC,KAAK,CAAC,CAAA;EAAA,OAAAhC;CAAA,EAAA,CAAA;AAoCrE"}

package/dist/components/conversation/scroll-follow-core.d.ts

@@ -0,0 +1,181 @@
+/** Default distance (px) from the bottom within which `isAtBottom` is true. */
+export declare const DEFAULT_BOTTOM_THRESHOLD = 100;
+/**
+ * Tolerance (px) for treating a scroll position as "the same" as a value we
+ * wrote programmatically. Covers sub-pixel rounding and 1px momentum overshoot.
+ * Must stay small so a deliberate user scroll of even a few px is still seen as
+ * a user scroll.
+ */
+export declare const SELF_SCROLL_EPSILON = 2;
+/**
+ * "At the bottom" tolerance (px) for deciding whether an auto-pin still has
+ * work to do. A flat 0.5 is UNDER one device pixel at fractional device-pixel
+ * ratios (0.67 CSS px at 150% zoom, 0.8 at 125%): the scroller's resting
+ * maximum scrollTop lands on a fractional value, so `|scrollTop - target|`
+ * stays just above 0.5 even when the viewport is visually pinned to the
+ * bottom — making the pin re-fire on every ResizeObserver tick. Scaling the
+ * epsilon to the device pixel (never below 1 CSS px) absorbs that fractional
+ * resting error. `devicePixelRatio` is read defensively so a jsdom / SSR
+ * environment that leaves it undefined falls back to 1 (→ 1.5px).
+ */
+export declare function atBottomEpsilon(): number;
+/** Live scroll geometry snapshot read from the scroller element. */
+export interface ScrollGeom {
+    scrollTop: number;
+    scrollHeight: number;
+    clientHeight: number;
+}
+/** scrollTop that places the viewport exactly at the bottom (never negative). */
+export declare function bottomTarget(geom: ScrollGeom): number;
+/** Pixels between the current scroll position and the bottom. */
+export declare function distanceFromBottom(geom: ScrollGeom): number;
+/** Whether the scroller is within `threshold` px of the bottom. */
+export declare function computeAtBottom(geom: ScrollGeom, threshold: number): boolean;
+/**
+ * Recognise a `scroll` event caused by our own programmatic write rather than
+ * by the user. `lastWriteTop < 0` means "we have not written this session", so
+ * any scroll is treated as the user's.
+ */
+export declare function isSelfScroll(scrollTop: number, lastWriteTop: number, epsilon?: number): boolean;
+/**
+ * Distance (px) from the true bottom within which a user scroll RE-ENGAGES
+ * follow. Deliberately much tighter than DEFAULT_BOTTOM_THRESHOLD: that 100px
+ * band drives the jump-to-bottom pill's visibility, and reusing it for follow
+ * meant a deliberate 3-99px scroll-up kept `stick` armed — the next content
+ * change then yanked the reader back to the bottom. Re-engaging only when the
+ * user has returned essentially to the bottom keeps "scrolled up to read"
+ * positions belonging to the user.
+ */
+export declare const FOLLOW_REENGAGE_PX = 16;
+/**
+ * Direction-aware `stick` decision for a *user-initiated* scroll (self-scrolls
+ * filtered out by the caller via `isSelfScroll`):
+ *
+ *   1. At the true bottom (within the DPR-aware epsilon) → follow. This also
+ *      absorbs the layout engine's clamp: a mid-stream content SHRINK drops
+ *      scrollTop (which reads as an upward move) but lands exactly at the new
+ *      bottom — releasing there froze streaming follow for the rest of the
+ *      turn.
+ *   2. Any other upward move → release, regardless of distance from the
+ *      bottom. The scroll position now belongs to the user; only returning to
+ *      the bottom (3) re-engages.
+ *   3. A genuine DOWNWARD move that arrives within FOLLOW_REENGAGE_PX of the
+ *      bottom → re-engage. A neutral event inside the band does NOT: that is
+ *      how content collapsing under a still reader re-armed follow.
+ *   4. Otherwise (downward/neutral, still away from the bottom) → keep the
+ *      previous state.
+ *
+ * `prevScrollTop < 0` means "no prior observation this session". Direction is
+ * unknowable then, so the decision is position-only and CONSERVATIVE: follow
+ * only within the re-engage band. Keeping a stale `stick` on an unattributable
+ * away-from-bottom scroll is how a reader gets yanked.
+ */
+export declare function resolveUserScrollStick(args: {
+    stick: boolean;
+    followOutput: boolean;
+    scrollTop: number;
+    prevScrollTop: number;
+    geom: ScrollGeom;
+    /** Change in the scroller's own height since the previous scroll event.
+     *
+     *  Positive = the viewport GREW (the composer shrank under a deletion, the
+     *  keyboard closed). That growth lowers the maximum scrollTop, so the engine
+     *  clamps any reader parked closer to the bottom than the growth — with no
+     *  application write anywhere. The clamp then arrives here as an ordinary
+     *  scroll event sitting at distance ~0, which rule 1 below used to read as
+     *  "the reader came back to the bottom" and re-arm follow for someone who
+     *  never touched the scroller. The next turn to start then took them to the
+     *  end. Rule 1 exists to absorb a CONTENT-shrink clamp mid-stream, and content
+     *  shrink moves `scrollHeight`, not `clientHeight` — so the two are
+     *  distinguishable, and this is the delta that tells them apart. */
+    viewportGrowth?: number;
+}): boolean;
+/** Result of an automatic (RO / append) pin evaluation. */
+export interface AutoPinResult {
+    /** Whether to write `el.scrollTop = target` now. */
+    pin: boolean;
+    /** Next value for `stick` (released to false if the user scrolled up). */
+    stick: boolean;
+    /** The bottom scrollTop the caller should write when `pin` is true. */
+    target: number;
+}
+/**
+ * Decide an automatic pin at the moment content changed (RO callback / append
+ * layout effect / its follow-up rAF), reading LIVE geometry.
+ *
+ *   - Not sticking → never pin.
+ *   - Sticking but the user has scrolled up since our last write
+ *     (`scrollTop < lastWriteTop - epsilon`) → release stick, don't pin.
+ *     This is the synchronous, race-proof guard.
+ *   - Otherwise → pin to the bottom (only actually move if not already there).
+ *
+ * `lastWriteTop < 0` disables the scroll-up guard (used right after a slot
+ * switch, before we have written anything this session).
+ *
+ * `viewportShrink` (px, default 0) is how much the SCROLLER'S OWN BOX has
+ * shrunk since that reference was recorded — chrome mounting below the
+ * transcript (a queue band, an attachment strip, a tip card), often
+ * spring-animated over several frames. Our own shrink inflates
+ * `distanceFromBottom` with no user input, so without this allowance the
+ * distance guard reads it as "meaningfully away from the bottom". Paired with
+ * a content SHRINK in the same commit window — a tail-row remount clamping
+ * scrollTop below `lastWriteTop` — that produced a full user-scroll-up
+ * signature out of two of our own layout changes: follow released mid
+ * animation and the content settled a card-height low. Judging the distance
+ * against the box we were last a bottom FOR keeps the guard measuring the
+ * user's move rather than our own. Only the shrink's own pixels are forgiven,
+ * so a genuine drag inside the same tick still releases.
+ */
+export declare function evaluateAutoPin(args: {
+    stick: boolean;
+    geom: ScrollGeom;
+    lastWriteTop: number;
+    epsilon?: number;
+    viewportShrink?: number;
+    /** Is a turn actually producing output right now?
+     *
+     *  Follow means "keep me at the end of a LIVE turn". With nothing running there
+     *  is no output to follow, so a reader sitting above the bottom is not
+     *  following — and an automatic pin there is a yank with no cause, reported
+     *  from a phone as the transcript springing back after scrolling up about a
+     *  hundred pixels with nothing streaming.
+     *
+     *  Defaults to `true` = assume a run is live, which keeps the behaviour of a
+     *  caller that has no run signal to give (the app-SDK chat surface). The chat
+     *  transcript passes the real thing. */
+    runActive?: boolean;
+    /** Is an anchor restore currently OWNING the scroll position?
+     *
+     *  A restore places the reader at an absolute offset and then re-lands it as
+     *  measurements arrive. An automatic pin during that window is a second owner
+     *  writing the same scroller, and the two fight: captured on a phone as
+     *  `WRITE autopin 3091->4245` answered by `WRITE settle 4245->3091`, twice in
+     *  120ms, 1,154px each way. The settle won those rounds, but only because its
+     *  budget had not expired yet -- which is why the same switch sometimes landed
+     *  at the bottom and sometimes did not.
+     *
+     *  Released rather than merely skipped, for the reason the idle branch below
+     *  gives: skipping leaves follow armed, so the next growth yanks the reader
+     *  from wherever the restore just put them. */
+    restoreGate?: boolean;
+    /** Has hardware input -- wheel / touch / pointer / a scrolling key -- reached
+     *  the scroller since we last placed the reader at the bottom?
+     *
+     *  False means the reader has done nothing, so a gap that opened while they
+     *  rest on our last write was opened by content -- a row settling from its
+     *  estimate, a code-block stand-in swapping for the highlighted block, the
+     *  top spacer repricing -- and is a gap WE owe them, not one they chose.
+     *
+     *  The idle rule below cannot tell those apart from distance alone, and it
+     *  errs toward release, which was invisible wherever the browser's native
+     *  scroll anchoring quietly carried the reader through the growth. WebKit has
+     *  no scroll anchoring at all, so on an iPhone every entry into an idle
+     *  session paid the whole post-pin reprice as a displacement and then had
+     *  follow released on top of it: the transcript opened a viewport or more
+     *  above the end with nothing streaming to bring it back.
+     *
+     *  Defaults to `true` = assume the reader may have moved, which is the
+     *  release-leaning legacy behaviour for a caller that has no input signal. */
+    readerMovedSinceWrite?: boolean;
+}): AutoPinResult;
+//# sourceMappingURL=scroll-follow-core.d.ts.map

package/dist/components/conversation/scroll-follow-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-follow-core.d.ts","sourceRoot":"","sources":["../../../src/components/conversation/scroll-follow-core.ts"],"names":[],"mappings":"AAqBA,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAQxC;AAED,oEAAoE;AACpE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAErD;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAE3D;AAED,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,MAA4B,GACpC,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,UAAU,CAAA;IAChB;;;;;;;;;;;wEAWoE;IACpE,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CA4BV;AAED,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,GAAG,EAAE,OAAO,CAAA;IACZ,0EAA0E;IAC1E,KAAK,EAAE,OAAO,CAAA;IACd,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,UAAU,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;;4CAUwC;IACxC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;;;;;;;;;mDAY+C;IAC/C,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;;;;;;;;;;;;;;;kFAiB8E;IAC9E,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,GAAG,aAAa,CAsDhB"}

package/dist/components/conversation/scroll-follow-core.js

@@ -0,0 +1,139 @@
+/**
+* "At the bottom" tolerance (px) for deciding whether an auto-pin still has
+* work to do. A flat 0.5 is UNDER one device pixel at fractional device-pixel
+* ratios (0.67 CSS px at 150% zoom, 0.8 at 125%): the scroller's resting
+* maximum scrollTop lands on a fractional value, so `|scrollTop - target|`
+* stays just above 0.5 even when the viewport is visually pinned to the
+* bottom — making the pin re-fire on every ResizeObserver tick. Scaling the
+* epsilon to the device pixel (never below 1 CSS px) absorbs that fractional
+* resting error. `devicePixelRatio` is read defensively so a jsdom / SSR
+* environment that leaves it undefined falls back to 1 (→ 1.5px).
+*/
+function atBottomEpsilon() {
+	const dpr = typeof window !== "undefined" && typeof window.devicePixelRatio === "number" && window.devicePixelRatio > 0 ? window.devicePixelRatio : 1;
+	return Math.max(1, 1 / dpr + .5);
+}
+/** scrollTop that places the viewport exactly at the bottom (never negative). */
+function bottomTarget(geom) {
+	return Math.max(0, geom.scrollHeight - geom.clientHeight);
+}
+/** Pixels between the current scroll position and the bottom. */
+function distanceFromBottom(geom) {
+	return geom.scrollHeight - geom.scrollTop - geom.clientHeight;
+}
+/** Whether the scroller is within `threshold` px of the bottom. */
+function computeAtBottom(geom, threshold) {
+	return distanceFromBottom(geom) <= threshold;
+}
+/**
+* Recognise a `scroll` event caused by our own programmatic write rather than
+* by the user. `lastWriteTop < 0` means "we have not written this session", so
+* any scroll is treated as the user's.
+*/
+function isSelfScroll(scrollTop, lastWriteTop, epsilon = 2) {
+	return lastWriteTop >= 0 && Math.abs(scrollTop - lastWriteTop) <= epsilon;
+}
+/**
+* Direction-aware `stick` decision for a *user-initiated* scroll (self-scrolls
+* filtered out by the caller via `isSelfScroll`):
+*
+*   1. At the true bottom (within the DPR-aware epsilon) → follow. This also
+*      absorbs the layout engine's clamp: a mid-stream content SHRINK drops
+*      scrollTop (which reads as an upward move) but lands exactly at the new
+*      bottom — releasing there froze streaming follow for the rest of the
+*      turn.
+*   2. Any other upward move → release, regardless of distance from the
+*      bottom. The scroll position now belongs to the user; only returning to
+*      the bottom (3) re-engages.
+*   3. A genuine DOWNWARD move that arrives within FOLLOW_REENGAGE_PX of the
+*      bottom → re-engage. A neutral event inside the band does NOT: that is
+*      how content collapsing under a still reader re-armed follow.
+*   4. Otherwise (downward/neutral, still away from the bottom) → keep the
+*      previous state.
+*
+* `prevScrollTop < 0` means "no prior observation this session". Direction is
+* unknowable then, so the decision is position-only and CONSERVATIVE: follow
+* only within the re-engage band. Keeping a stale `stick` on an unattributable
+* away-from-bottom scroll is how a reader gets yanked.
+*/
+function resolveUserScrollStick(args) {
+	const { stick, followOutput, scrollTop, prevScrollTop, geom } = args;
+	if (!followOutput) return false;
+	const dist = distanceFromBottom(geom);
+	const clampedByViewport = (args.viewportGrowth ?? 0) > atBottomEpsilon() && scrollTop <= prevScrollTop + atBottomEpsilon();
+	if (dist <= atBottomEpsilon()) return clampedByViewport ? stick : true;
+	if (prevScrollTop < 0) return dist <= 16;
+	if (scrollTop < prevScrollTop - .5) return false;
+	if (scrollTop > prevScrollTop + .5 && dist <= 16) return true;
+	return stick;
+}
+/**
+* Decide an automatic pin at the moment content changed (RO callback / append
+* layout effect / its follow-up rAF), reading LIVE geometry.
+*
+*   - Not sticking → never pin.
+*   - Sticking but the user has scrolled up since our last write
+*     (`scrollTop < lastWriteTop - epsilon`) → release stick, don't pin.
+*     This is the synchronous, race-proof guard.
+*   - Otherwise → pin to the bottom (only actually move if not already there).
+*
+* `lastWriteTop < 0` disables the scroll-up guard (used right after a slot
+* switch, before we have written anything this session).
+*
+* `viewportShrink` (px, default 0) is how much the SCROLLER'S OWN BOX has
+* shrunk since that reference was recorded — chrome mounting below the
+* transcript (a queue band, an attachment strip, a tip card), often
+* spring-animated over several frames. Our own shrink inflates
+* `distanceFromBottom` with no user input, so without this allowance the
+* distance guard reads it as "meaningfully away from the bottom". Paired with
+* a content SHRINK in the same commit window — a tail-row remount clamping
+* scrollTop below `lastWriteTop` — that produced a full user-scroll-up
+* signature out of two of our own layout changes: follow released mid
+* animation and the content settled a card-height low. Judging the distance
+* against the box we were last a bottom FOR keeps the guard measuring the
+* user's move rather than our own. Only the shrink's own pixels are forgiven,
+* so a genuine drag inside the same tick still releases.
+*/
+function evaluateAutoPin(args) {
+	const { stick, geom, lastWriteTop } = args;
+	const epsilon = args.epsilon ?? 2;
+	const viewportShrink = Math.max(0, args.viewportShrink ?? 0);
+	const runActive = args.runActive ?? true;
+	const readerMovedSinceWrite = args.readerMovedSinceWrite ?? true;
+	const target = bottomTarget(geom);
+	if (args.restoreGate) return {
+		pin: false,
+		stick: false,
+		target
+	};
+	if (!stick) return {
+		pin: false,
+		stick: false,
+		target
+	};
+	const restingOnOurWrite = lastWriteTop >= 0 && Math.abs(geom.scrollTop - lastWriteTop) <= epsilon;
+	if (!readerMovedSinceWrite && restingOnOurWrite) return {
+		pin: distanceFromBottom(geom) > atBottomEpsilon(),
+		stick: true,
+		target
+	};
+	if (!runActive && distanceFromBottom(geom) > atBottomEpsilon()) return {
+		pin: false,
+		stick: false,
+		target
+	};
+	if (lastWriteTop >= 0 && geom.scrollTop < lastWriteTop - epsilon && distanceFromBottom(geom) - viewportShrink > epsilon) return {
+		pin: false,
+		stick: false,
+		target
+	};
+	return {
+		pin: Math.abs(geom.scrollTop - target) > atBottomEpsilon(),
+		stick: true,
+		target
+	};
+}
+//#endregion
+export { atBottomEpsilon, bottomTarget, computeAtBottom, distanceFromBottom, evaluateAutoPin, isSelfScroll, resolveUserScrollStick };
+
+//# sourceMappingURL=scroll-follow-core.js.map