@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/board-types.ts

@@ -0,0 +1,96 @@
+/**
+ * 会话看板类型定义（客户端/服务端共用，SDK-free）。
+ * 只存布局与状态标记 —— 会话内容仍由 .jsonl 与 /api/sessions 提供。
+ */
+
+/** 系统看板固定 id：运行中（跨项目自动聚合，不可改名/删除）。 */
+export const SYSTEM_RUNNING_BOARD_ID = "__running__";
+
+export interface BoardInfo {
+  id: string;
+  projectKey: string;
+  name: string;
+  isSystem: boolean;
+  /** 任务型看板：非空时即任务 id（看板 id = 任务 id）；手动看板为 null */
+  taskId: string | null;
+  /** 项目内手动排序（系统看板恒置顶） */
+  sortOrder: number;
+  created: number;
+  updated: number;
+  /** 节点数（列表展示用，不落库） */
+  nodeCount: number;
+}
+
+export type BoardNodeKind = "session" | "shape" | "taskcard";
+
+export interface BoardNode {
+  id: string;
+  boardId: string;
+  kind: BoardNodeKind;
+  /** sessionId（kind=session）；失效时 refId 仍保留但 session 不存在 */
+  refId: string | null;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  expanded: boolean;
+  props: Record<string, unknown>;
+  created: number;
+  updated: number;
+}
+
+export interface BoardEdge {
+  id: string;
+  boardId: string;
+  fromId: string;
+  toId: string;
+  label: string | null;
+  color: string | null;
+  dashed: boolean;
+  created: number;
+  updated: number;
+}
+
+export interface BoardView {
+  boardId: string;
+  cameraX: number;
+  cameraY: number;
+  cameraZ: number;
+  updated: number;
+}
+
+/** GET /api/boards/[id]/canvas 响应（整张画布） */
+export interface BoardCanvas {
+  board: BoardInfo;
+  nodes: BoardNode[];
+  edges: BoardEdge[];
+  view: BoardView | null;
+}
+
+/** 运行中会话细分状态（GET /api/agent/running 扩展） */
+export type RunningPhase = "waiting_model" | "running_tools" | "running_command" | "waiting_input";
+
+export interface RunningSessionState {
+  phase: RunningPhase;
+  /** 当前模型 `provider/modelId`（可能为空） */
+  model: string | null;
+  /** 本次运行开始时间（ms epoch；未知为 0） */
+  startedAt: number;
+}
+
+export interface RunningSnapshot {
+  runningSessionIds: string[];
+  /** 细分状态：只含运行中的会话 id */
+  states: Record<string, RunningSessionState>;
+  /** 任务卡状态：调度器活跃态卡（running/review/waiting_reply），前端按 boardId 过滤本画布后更新徽章 */
+  taskCards: TaskCardRunningState[];
+}
+
+/** 任务卡运行状态（轮询器透传给前端，供看板卡片自动刷新 execStatus 徽章） */
+export interface TaskCardRunningState {
+  cardId: string;
+  boardId: string;
+  number: number;
+  name: string;
+  execStatus: string;
+}

package/lib/board-utils.ts

@@ -0,0 +1,17 @@
+/** 看板纯函数工具（SDK-free，浏览器 + node 测试均可用）。 */
+
+/**
+ * 刚结束卡片 30s 保留判定：phase=just-ended 且 endedAt 超过窗口则移除。
+ * @param phase 卡片当前阶段
+ * @param endedAt 结束时刻（ms epoch）；0 = 未知，不判定
+ * @param nowTs 当前时刻（ms epoch）
+ * @param windowMs 保留窗口（默认 30s）
+ */
+export function shouldRemoveEndedCard(
+  phase: string,
+  endedAt: number,
+  nowTs: number,
+  windowMs = 30_000,
+): boolean {
+  return phase === "just-ended" && endedAt > 0 && nowTs - endedAt > windowMs;
+}

package/lib/bounded-form-data.test.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./bounded-form-data.ts");
+}
+
+function multipartBody(boundary, value) {
+  return `--${boundary}\r\nContent-Disposition: form-data; name="value"\r\n\r\n${value}\r\n--${boundary}--\r\n`;
+}
+
+test("rejects a declared oversized request before reading its body", async () => {
+  const { parseFormDataWithinLimit, RequestBodyTooLargeError } = await loadSubject();
+  const request = new Request("http://localhost/upload", {
+    method: "POST",
+    headers: { "content-length": "99", "content-type": "multipart/form-data; boundary=test" },
+    body: multipartBody("test", "small"),
+  });
+
+  await assert.rejects(() => parseFormDataWithinLimit(request, 10), RequestBodyTooLargeError);
+});
+
+test("stops a chunked request once its body exceeds the limit", async () => {
+  const { parseFormDataWithinLimit, RequestBodyTooLargeError } = await loadSubject();
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode("1234"));
+      controller.enqueue(new TextEncoder().encode("5678"));
+      controller.close();
+    },
+  });
+  const request = new Request("http://localhost/upload", {
+    method: "POST",
+    headers: { "content-type": "multipart/form-data; boundary=test" },
+    body: stream,
+    duplex: "half",
+  });
+
+  await assert.rejects(() => parseFormDataWithinLimit(request, 6), RequestBodyTooLargeError);
+});
+
+test("parses multipart data inside the request limit", async () => {
+  const { parseFormDataWithinLimit } = await loadSubject();
+  const boundary = "test";
+  const body = multipartBody(boundary, "small");
+  const request = new Request("http://localhost/upload", {
+    method: "POST",
+    headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+    body,
+  });
+
+  const formData = await parseFormDataWithinLimit(request, body.length + 1);
+  assert.equal(formData.get("value"), "small");
+});

package/lib/bounded-form-data.ts

@@ -0,0 +1,49 @@
+export class RequestBodyTooLargeError extends Error {
+  constructor() {
+    super("Request body exceeds the allowed size");
+  }
+}
+
+function declaredContentLength(request: Request): number | null {
+  const value = request.headers.get("content-length");
+  if (!value || !/^\d+$/.test(value)) return null;
+  const length = Number(value);
+  return Number.isSafeInteger(length) ? length : null;
+}
+
+/**
+ * Parse multipart data only after constraining the complete wire body. This
+ * bounds chunked requests too, where Content-Length is unavailable or false.
+ */
+export async function parseFormDataWithinLimit(request: Request, maxBytes: number): Promise<FormData> {
+  const declared = declaredContentLength(request);
+  if (declared !== null && declared > maxBytes) {
+    throw new RequestBodyTooLargeError();
+  }
+
+  const reader = request.body?.getReader();
+  if (!reader) return request.formData();
+
+  const chunks: BlobPart[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (size + value.byteLength > maxBytes) {
+        await reader.cancel().catch(() => {});
+        throw new RequestBodyTooLargeError();
+      }
+      size += value.byteLength;
+      const chunk = new Uint8Array(value.byteLength);
+      chunk.set(value);
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const contentType = request.headers.get("content-type");
+  const headers = contentType ? { "content-type": contentType } : undefined;
+  return new Response(new Blob(chunks), { headers }).formData();
+}

package/lib/browser-notifications.test.mjs

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./browser-notifications.ts");
+}
+
+test("uses a service worker notification when a registration is available", async () => {
+  const { showBrowserNotification } = await loadSubject();
+  const shown = [];
+  let constructorCalled = false;
+
+  const delivery = await showBrowserNotification({
+    title: "Session complete",
+    body: "Task finished.",
+    sessionUrl: "/?session=session-1",
+    tag: "session-complete:session-1",
+    onClick: () => assert.fail("service worker owns the click handler"),
+  }, {
+    createWindowNotification: () => {
+      constructorCalled = true;
+      throw new Error("unexpected constructor call");
+    },
+    getServiceWorkerRegistration: async () => ({
+      showNotification: async (title, options) => shown.push({ title, options }),
+    }),
+  });
+
+  assert.equal(delivery, "service-worker");
+  assert.equal(constructorCalled, false);
+  assert.deepEqual(shown, [{
+    title: "Session complete",
+    options: {
+      body: "Task finished.",
+      tag: "session-complete:session-1",
+      data: { url: "/?session=session-1" },
+    },
+  }]);
+});
+
+test("falls back to a page notification and wires its click handler", async () => {
+  const { showBrowserNotification } = await loadSubject();
+  let notificationOptions;
+  let clicked = false;
+  let closed = false;
+  const notification = {
+    onclick: null,
+    close: () => { closed = true; },
+  };
+
+  const delivery = await showBrowserNotification({
+    title: "Session complete",
+    body: "Task finished.",
+    sessionUrl: "/?session=session-1",
+    onClick: () => { clicked = true; },
+  }, {
+    createWindowNotification: (title, options) => {
+      notificationOptions = { title, options };
+      return notification;
+    },
+    getServiceWorkerRegistration: async () => {
+      throw new Error("service worker unavailable");
+    },
+  });
+
+  assert.equal(delivery, "window");
+  assert.deepEqual(notificationOptions, {
+    title: "Session complete",
+    options: { body: "Task finished." },
+  });
+
+  notification.onclick();
+  assert.equal(closed, true);
+  assert.equal(clicked, true);
+});
+
+test("silently skips notification when neither delivery mechanism works", async () => {
+  const { showBrowserNotification } = await loadSubject();
+
+  const delivery = await showBrowserNotification({
+    title: "Session complete",
+    body: "Task finished.",
+    sessionUrl: "/",
+    onClick: () => {},
+  }, {
+    createWindowNotification: () => {
+      throw new TypeError("Illegal constructor");
+    },
+    getServiceWorkerRegistration: null,
+  });
+
+  assert.equal(delivery, null);
+});
+
+test("shows notifications when the page is hidden", async () => {
+  const { shouldShowBrowserNotification } = await loadSubject();
+  let focusChecked = false;
+
+  assert.equal(shouldShowBrowserNotification({
+    visibilityState: "hidden",
+    hasFocus: () => {
+      focusChecked = true;
+      return true;
+    },
+  }), true);
+  assert.equal(focusChecked, false);
+});
+
+test("shows notifications when the visible page is unfocused", async () => {
+  const { shouldShowBrowserNotification } = await loadSubject();
+
+  assert.equal(shouldShowBrowserNotification({
+    visibilityState: "visible",
+    hasFocus: () => false,
+  }), true);
+});
+
+test("skips notifications only when the visible page is focused", async () => {
+  const { shouldShowBrowserNotification } = await loadSubject();
+
+  assert.equal(shouldShowBrowserNotification({
+    visibilityState: "visible",
+    hasFocus: () => true,
+  }), false);
+});
+
+test("claims only blocking extension requests and deduplicates their ids", async () => {
+  const { claimExtensionAttentionNotification } = await loadSubject();
+  const notifiedIds = new Set();
+  const confirmRequest = {
+    type: "extension_ui_request",
+    id: "confirm-1",
+    method: "confirm",
+    title: "Approve",
+    message: "Continue?",
+  };
+
+  assert.equal(claimExtensionAttentionNotification(confirmRequest, notifiedIds), true);
+  assert.equal(claimExtensionAttentionNotification(confirmRequest, notifiedIds), false);
+  for (const request of [
+    { type: "extension_ui_request", id: "select-1", method: "select", title: "Choose", options: ["A"] },
+    { type: "extension_ui_request", id: "input-1", method: "input", title: "Enter value" },
+    { type: "extension_ui_request", id: "editor-1", method: "editor", title: "Edit value" },
+  ]) {
+    assert.equal(claimExtensionAttentionNotification(request, notifiedIds), true);
+  }
+  assert.equal(claimExtensionAttentionNotification({
+    type: "extension_ui_request",
+    id: "notice-1",
+    method: "notify",
+    message: "Informational",
+  }, notifiedIds), false);
+  assert.equal(claimExtensionAttentionNotification({
+    type: "extension_ui_request",
+    id: "custom-closed",
+    method: "custom",
+    lines: [],
+    closed: true,
+  }, notifiedIds), false);
+  assert.equal(claimExtensionAttentionNotification({
+    type: "extension_ui_request",
+    id: "custom-open",
+    method: "custom",
+    lines: ["Waiting for input"],
+  }, notifiedIds), true);
+  assert.deepEqual([...notifiedIds], ["confirm-1", "select-1", "input-1", "editor-1", "custom-open"]);
+});

package/lib/browser-notifications.ts

@@ -0,0 +1,104 @@
+import type { BlockingExtensionUiRequest, ExtensionUiRequest } from "./types";
+
+interface WindowNotificationLike {
+  onclick: Notification["onclick"];
+  close: () => void;
+}
+
+interface ServiceWorkerRegistrationLike {
+  showNotification: (title: string, options?: NotificationOptions) => Promise<void>;
+}
+
+export interface BrowserNotificationEnvironment {
+  createWindowNotification: (title: string, options?: NotificationOptions) => WindowNotificationLike;
+  getServiceWorkerRegistration: (() => Promise<ServiceWorkerRegistrationLike | undefined>) | null;
+}
+
+export interface BrowserNotificationOptions {
+  title: string;
+  body: string;
+  sessionUrl: string;
+  onClick: () => void;
+  tag?: string;
+}
+
+export type NotificationDelivery = "service-worker" | "window" | null;
+
+type DocumentAttentionState = Pick<Document, "visibilityState" | "hasFocus">;
+
+export function shouldShowBrowserNotification(
+  attentionState: DocumentAttentionState = document,
+): boolean {
+  return attentionState.visibilityState !== "visible" || !attentionState.hasFocus();
+}
+
+export function isBlockingExtensionUiRequest(
+  request: ExtensionUiRequest,
+): request is BlockingExtensionUiRequest {
+  switch (request.method) {
+    case "select":
+    case "confirm":
+    case "input":
+    case "editor":
+      return true;
+    case "custom":
+      return request.closed !== true;
+    default:
+      return false;
+  }
+}
+
+export function claimExtensionAttentionNotification(
+  request: ExtensionUiRequest,
+  notifiedRequestIds: Set<string>,
+): request is BlockingExtensionUiRequest {
+  if (!isBlockingExtensionUiRequest(request) || notifiedRequestIds.has(request.id)) return false;
+  notifiedRequestIds.add(request.id);
+  return true;
+}
+
+function getBrowserEnvironment(): BrowserNotificationEnvironment {
+  return {
+    createWindowNotification: (title, options) => new Notification(title, options),
+    getServiceWorkerRegistration: "serviceWorker" in navigator
+      ? () => navigator.serviceWorker.getRegistration()
+      : null,
+  };
+}
+
+export async function showBrowserNotification(
+  options: BrowserNotificationOptions,
+  environment: BrowserNotificationEnvironment = getBrowserEnvironment(),
+): Promise<NotificationDelivery> {
+  const notificationOptions: NotificationOptions = {
+    body: options.body,
+    ...(options.tag ? { tag: options.tag } : {}),
+  };
+
+  if (environment.getServiceWorkerRegistration) {
+    try {
+      const registration = await environment.getServiceWorkerRegistration();
+      if (registration) {
+        await registration.showNotification(options.title, {
+          ...notificationOptions,
+          data: { url: options.sessionUrl },
+        });
+        return "service-worker";
+      }
+    } catch {
+      // Fall back to a page notification where the constructor is supported.
+    }
+  }
+
+  try {
+    const notification = environment.createWindowNotification(options.title, notificationOptions);
+    notification.onclick = () => {
+      notification.close();
+      options.onClick();
+    };
+    return "window";
+  } catch {
+    // Most mobile browsers expose Notification but require service-worker delivery.
+    return null;
+  }
+}

package/lib/chat-lazy-load.test.mjs

@@ -0,0 +1,140 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+async function loadSubject() {
+  return import("./chat-lazy-load.ts");
+}
+
+test("shows only the last visible render items", async () => {
+  const { getVisibleRenderWindow } = await loadSubject();
+  assert.deepEqual(getVisibleRenderWindow(200, 50), { startIndex: 150, hasMore: true });
+});
+
+test("shows all render items when the visible count reaches the total", async () => {
+  const { getVisibleRenderWindow } = await loadSubject();
+  assert.deepEqual(getVisibleRenderWindow(30, 50), { startIndex: 0, hasMore: false });
+  assert.deepEqual(getVisibleRenderWindow(50, 50), { startIndex: 0, hasMore: false });
+  assert.deepEqual(getVisibleRenderWindow(0, 50), { startIndex: 0, hasMore: false });
+});
+
+test("continues paging when render items outnumber source messages", async () => {
+  const { getNextVisibleCount, getVisibleRenderWindow } = await loadSubject();
+  let visibleCount = 50;
+
+  visibleCount = getNextVisibleCount(visibleCount);
+  assert.deepEqual(getVisibleRenderWindow(120, visibleCount), { startIndex: 20, hasMore: true });
+
+  visibleCount = getNextVisibleCount(visibleCount);
+  assert.deepEqual(getVisibleRenderWindow(120, visibleCount), { startIndex: 0, hasMore: false });
+});
+
+test("restores the viewport after prepending content", async () => {
+  const { captureScrollDistance, restoreScrollTop } = await loadSubject();
+  const savedDistance = captureScrollDistance(2000, 500);
+
+  assert.equal(savedDistance, 1500);
+  assert.equal(restoreScrollTop(2500, savedDistance), 1000);
+});
+
+test("restores top and bottom boundary positions", async () => {
+  const { captureScrollDistance, restoreScrollTop } = await loadSubject();
+  assert.equal(restoreScrollTop(3000, captureScrollDistance(2000, 0)), 1000);
+  assert.equal(restoreScrollTop(3000, captureScrollDistance(2000, 2000)), 3000);
+});
+
+test("treats only the real message tail as live-follow attached", async () => {
+  const {
+    CHAT_SCROLL_REATTACH_TOLERANCE,
+    CHAT_SCROLL_TAIL_TOLERANCE,
+    getLiveFollowAttached,
+    isScrollAtTail,
+  } = await loadSubject();
+
+  assert.equal(CHAT_SCROLL_TAIL_TOLERANCE, 8);
+  assert.equal(CHAT_SCROLL_REATTACH_TOLERANCE, 96);
+  assert.deepEqual(
+    [392, 391.99, 400].map((scrollTop) => isScrollAtTail(scrollTop, 600, 1000)),
+    [true, false, true],
+  );
+  assert.equal(isScrollAtTail(0, 600, 400), true);
+
+  // Layout growth alone must not detach a view that was already following.
+  assert.equal(getLiveFollowAttached(true, 400, 400, 600, 1040), true);
+  // Any upward movement outside the strict tail tolerance detaches, even inside
+  // the wider downward-only reattach window.
+  assert.equal(getLiveFollowAttached(true, 400, 380, 600, 1000), false);
+  assert.equal(getLiveFollowAttached(false, 380, 370, 600, 1000), false);
+  // A detached view stays detached until downward movement enters the reattach window.
+  assert.equal(getLiveFollowAttached(false, 280, 303, 600, 1000), false);
+  assert.equal(getLiveFollowAttached(false, 303, 304, 600, 1000), true);
+  // Reaching the old tail still reattaches after one to four new rendered lines.
+  for (const lines of [1, 2, 3, 4]) {
+    assert.equal(getLiveFollowAttached(false, 380, 400, 600, 1000 + lines * 24), true);
+  }
+  assert.equal(getLiveFollowAttached(false, 380, 400, 600, 1120), false);
+  // Streaming growth without downward user movement must not reattach.
+  assert.equal(getLiveFollowAttached(false, 400, 400, 600, 1096), false);
+  assert.equal(getLiveFollowAttached(false, 391, 392, 600, 1000), true);
+});
+
+test("prompt anchor spacer uses the rendered content end", async () => {
+  const { getPromptAnchorSpacerHeight } = await loadSubject();
+  const initial = getPromptAnchorSpacerHeight(400, 700, 600);
+  const afterRender = getPromptAnchorSpacerHeight(400, 700, 600);
+
+  assert.equal(initial, 300);
+  assert.equal(afterRender, initial);
+});
+
+test("prompt anchor spacer includes the viewport deficit for short conversations", async () => {
+  const { getPromptAnchorSpacerHeight } = await loadSubject();
+  const targetTop = 168;
+  const clientHeight = 579;
+
+  let contentHeight = 411;
+  let spacerHeight = getPromptAnchorSpacerHeight(targetTop, contentHeight, clientHeight);
+  assert.equal(spacerHeight, 336);
+  assert.equal(contentHeight + spacerHeight - clientHeight, targetTop);
+
+  contentHeight += 24;
+  spacerHeight = getPromptAnchorSpacerHeight(targetTop, contentHeight, clientHeight);
+  assert.equal(spacerHeight, 312);
+  assert.equal(contentHeight + spacerHeight - clientHeight, targetTop);
+});
+
+test("prompt anchor spacer clamps at zero once content can reach the target", async () => {
+  const { getPromptAnchorSpacerHeight } = await loadSubject();
+  assert.equal(getPromptAnchorSpacerHeight(100, 750, 600), 0);
+  assert.equal(getPromptAnchorSpacerHeight(-20, 200, 600), 0);
+});
+
+test("prompt anchor spacer rounds fractional layout measurements up", async () => {
+  const { getPromptAnchorSpacerHeight } = await loadSubject();
+  assert.equal(getPromptAnchorSpacerHeight(400.25, 700, 600), 301);
+});
+
+test("streaming content consumes the prompt anchor before advancing the tail", async () => {
+  const { getPromptAnchorSpacerHeight } = await loadSubject();
+  const targetTop = 400;
+  const clientHeight = 600;
+
+  let contentHeight = 700;
+  let spacerHeight = getPromptAnchorSpacerHeight(targetTop, contentHeight, clientHeight);
+  assert.equal(spacerHeight, 300);
+  assert.equal(contentHeight + spacerHeight - clientHeight, targetTop);
+
+  contentHeight += 120;
+  spacerHeight = getPromptAnchorSpacerHeight(targetTop, contentHeight, clientHeight);
+  assert.equal(spacerHeight, 180);
+  assert.equal(contentHeight + spacerHeight - clientHeight, targetTop);
+
+  contentHeight += 180;
+  spacerHeight = getPromptAnchorSpacerHeight(targetTop, contentHeight, clientHeight);
+  assert.equal(spacerHeight, 0);
+  assert.equal(contentHeight - clientHeight, targetTop);
+
+  contentHeight += 40;
+  spacerHeight = getPromptAnchorSpacerHeight(targetTop, contentHeight, clientHeight);
+  assert.equal(spacerHeight, 0);
+  assert.equal(contentHeight - clientHeight, targetTop + 40);
+});

package/lib/chat-lazy-load.ts

@@ -0,0 +1,64 @@
+export const VISIBLE_PAGE_SIZE = 50;
+export const CHAT_SCROLL_TAIL_TOLERANCE = 8;
+export const CHAT_SCROLL_REATTACH_TOLERANCE = 96;
+
+export function getVisibleRenderWindow(totalCount: number, visibleCount: number): {
+  startIndex: number;
+  hasMore: boolean;
+} {
+  const clampedVisibleCount = Math.min(Math.max(visibleCount, 0), Math.max(totalCount, 0));
+  const startIndex = Math.max(0, totalCount - clampedVisibleCount);
+  return { startIndex, hasMore: startIndex > 0 };
+}
+
+export function getNextVisibleCount(currentVisibleCount: number, pageSize = VISIBLE_PAGE_SIZE): number {
+  return currentVisibleCount + pageSize;
+}
+
+export function captureScrollDistance(scrollHeight: number, scrollTop: number): number {
+  return scrollHeight - scrollTop;
+}
+
+export function restoreScrollTop(scrollHeight: number, savedDistance: number): number {
+  return Math.max(0, scrollHeight - savedDistance);
+}
+
+export function isScrollAtTail(
+  scrollTop: number,
+  clientHeight: number,
+  scrollHeight: number,
+  tolerance = CHAT_SCROLL_TAIL_TOLERANCE,
+): boolean {
+  return scrollTop + clientHeight >= scrollHeight - tolerance;
+}
+
+export function getLiveFollowAttached(
+  wasAttached: boolean,
+  previousScrollTop: number,
+  scrollTop: number,
+  clientHeight: number,
+  scrollHeight: number,
+  reattachTolerance = CHAT_SCROLL_REATTACH_TOLERANCE,
+): boolean {
+  if (isScrollAtTail(scrollTop, clientHeight, scrollHeight)) return true;
+  if (scrollTop < previousScrollTop) return false;
+  if (
+    !wasAttached
+    && scrollTop > previousScrollTop
+    && isScrollAtTail(scrollTop, clientHeight, scrollHeight, reattachTolerance)
+  ) return true;
+  return wasAttached;
+}
+
+export function getPromptAnchorSpacerHeight(
+  targetTop: number,
+  contentEnd: number,
+  clientHeight: number,
+): number {
+  const clampedTargetTop = Math.max(0, targetTop);
+  if (clampedTargetTop === 0) return 0;
+
+  return Math.max(0, Math.ceil(
+    clampedTargetTop + clientHeight - Math.max(0, contentEnd),
+  ));
+}