@ash-qw/dsh-theme-prts 0.1.91

package/src/client/conversation-scale-adapter.js

@@ -0,0 +1,2243 @@
+import { CONVERSATION_SCALE_FOCUS_CONTRAST_DEFAULT, CONVERSATION_SCALE_FOCUS_CONTRAST_MAX, CONVERSATION_SCALE_FOCUS_CONTRAST_MIN } from './preferences.js'
+
+export const CONVERSATION_USER_TURN_SELECTOR = [
+  '[data-chat-flow-kind="user"]',
+  '[data-chat-flow-kind="user-step"]',
+  '[data-message-role="user"]',
+].join(',')
+
+export const CONVERSATION_SCALE_SPACING = 8
+export const CONVERSATION_SCALE_BASE_LENGTHS = Object.freeze([24, 18, 14, 10, 6])
+export const CONVERSATION_SCALE_CONTRAST_DELTAS = Object.freeze([5, -3, -4, -4, -3])
+
+export function resolveConversationScaleLengths(value = CONVERSATION_SCALE_FOCUS_CONTRAST_DEFAULT) {
+  const numeric = Number(value)
+  const contrast = Number.isFinite(numeric)
+    ? Math.min(CONVERSATION_SCALE_FOCUS_CONTRAST_MAX, Math.max(CONVERSATION_SCALE_FOCUS_CONTRAST_MIN, numeric))
+    : CONVERSATION_SCALE_FOCUS_CONTRAST_DEFAULT
+  const ratio = contrast / CONVERSATION_SCALE_FOCUS_CONTRAST_MAX
+  return CONVERSATION_SCALE_BASE_LENGTHS.map((length, index) =>
+    Math.round(length + CONVERSATION_SCALE_CONTRAST_DELTAS[index] * ratio))
+}
+
+export const CONVERSATION_SCALE_LENGTHS = Object.freeze(resolveConversationScaleLengths())
+export const CONVERSATION_SCALE_WAVE_DURATION = 140
+
+export const CONVERSATION_JUMP_BOTTOM_THRESHOLD = 25
+export const CONVERSATION_JUMP_SMOOTH_VIEWPORT_LIMIT = 1.5
+export const CONVERSATION_JUMP_SETTLE_MAX_DISTANCE = 88
+export const CONVERSATION_JUMP_SETTLE_VIEWPORT_RATIO = .12
+export const CONVERSATION_JUMP_SETTLE_DURATION = 180
+export const CONVERSATION_JUMP_VERIFY_DURATION = 900
+export const CONVERSATION_HISTORY_PAGE_LIMIT = 10
+export const CONVERSATION_HISTORY_TIME_LIMIT = 8000
+
+const ASSISTANT_SELECTOR = '[data-chat-flow-kind="assistant-step"], [data-message-role="assistant"]'
+const FORMAL_ANSWER_SELECTOR = '[data-prts-ai-surface], [data-markdown], [data-slot*="markdown" i], .markdown-body'
+const AUXILIARY_SELECTOR = '[data-chat-flow-kind*="reason" i], [data-chat-flow-kind*="tool" i], [data-slot*="reason" i], [data-slot*="tool" i], [data-role*="reason" i], [data-role*="tool" i]'
+const STREAMING_SELECTOR = '[aria-busy="true"], [data-streaming], [data-status*="stream" i], [data-state*="stream" i]'
+const CONVERSATION_THIRD_PARTY_OVERLAY_SELECTOR = [
+  '[data-shell-overlay] [data-plugin]:not([data-plugin="dsh-theme-prts"])',
+  '[data-slot="shell.overlay"] [data-plugin]:not([data-plugin="dsh-theme-prts"])',
+].join(', ')
+const CONVERSATION_BLOCKING_OVERLAY_SELECTOR = [
+  '[role="dialog"]',
+  '[aria-modal="true"]',
+  'dialog[open]',
+  '[data-prts-floating-glass="dialog"]',
+  '[data-prts-floating-scrim]',
+  '[data-slot*="dialog" i]',
+  '[data-slot*="modal" i]',
+  '[class*="_dialog"]',
+  '[class*="_modal"]',
+  '[class*="_scrim"]',
+  '[class*="_backdrop"]',
+].join(', ')
+const CONVERSATION_OVERLAY_SELECTOR = [
+  CONVERSATION_THIRD_PARTY_OVERLAY_SELECTOR,
+  '[role="dialog"]',
+  '[role="menu"]',
+  '[role="listbox"]',
+  '[popover]',
+  '[data-prts-floating-glass]',
+  '[aria-modal="true"]',
+  'dialog[open]',
+  '[data-slot*="dialog" i]',
+  '[data-slot*="modal" i]',
+  '[data-prts-floating-scrim]',
+  '[class*="_dialog"]',
+  '[class*="_modal"]',
+  '[class*="_scrim"]',
+  '[class*="_backdrop"]',
+].join(', ')
+const CONVERSATION_PORTAL_ROOT_SELECTOR = [
+  '[role="presentation"]',
+  '[class*="_portal_"]',
+  '[data-floating-ui-portal]',
+  '[data-radix-portal]',
+].join(', ')
+const PREVIEW_REMOVE_SELECTOR = [
+  '[hidden]',
+  '[aria-hidden="true"]',
+  'button',
+  '[role="toolbar"]',
+  '[data-slot*="toolbar" i]',
+  '[data-slot*="action" i]',
+  '[data-slot*="sentinel" i]',
+  'script',
+  'style',
+].join(',')
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg'
+const MINIMUM_TURNS = 2
+export const CONVERSATION_SCALE_WIDTH = 32
+export const CONVERSATION_SCALE_CONTENT_GAP = 12
+export const CONVERSATION_SCALE_PREVIEW_WIDTH = 360
+export const CONVERSATION_SCALE_PREVIEW_GAP = 8
+export const CONVERSATION_SCALE_RIGHT_GAP = 12
+export const CONVERSATION_SCALE_HYSTERESIS = 16
+export const CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE = 96
+const SCALE_WIDTH = CONVERSATION_SCALE_WIDTH
+const PREVIEW_WIDTH = CONVERSATION_SCALE_PREVIEW_WIDTH
+const PREVIEW_GAP = CONVERSATION_SCALE_PREVIEW_GAP
+const PREVIEW_FALLBACK_HEIGHT = 128
+const PREVIEW_DELAY = 100
+const HISTORY_TRIGGER_HEIGHT = CONVERSATION_SCALE_SPACING
+const PREVIEW_REFRESH_INTERVAL = 100
+const PREVIEW_TOUCH_DURATION = 1200
+const SNAP_DELAY = 110
+const TOUCH_WAVE_DURATION = 620
+const HISTORY_PAGE_SETTLE_LIMIT = 4000
+let scaleInstanceSeed = 0
+
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value))
+}
+
+export function resolveConversationScaleGeometry({
+  operationWidth,
+  contentLeft,
+  maximumDistance = CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE,
+  previouslyHidden = false,
+} = {}) {
+  const width = Number(operationWidth)
+  const content = Number(contentLeft)
+  const maximum = Number(maximumDistance)
+  if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(content) || content <= 0) {
+    return { visible: false, reason: 'unmeasured' }
+  }
+  const recovery = previouslyHidden ? CONVERSATION_SCALE_HYSTERESIS : 0
+  const minimumCorridor = CONVERSATION_SCALE_WIDTH + CONVERSATION_SCALE_CONTENT_GAP * 2 + recovery
+  if (content < minimumCorridor) return { visible: false, reason: 'corridor' }
+  const configuredLeft = clamp(
+    Number.isFinite(maximum) ? maximum : CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE,
+    CONVERSATION_SCALE_CONTENT_GAP,
+    Math.max(CONVERSATION_SCALE_CONTENT_GAP, width - CONVERSATION_SCALE_WIDTH - CONVERSATION_SCALE_RIGHT_GAP),
+  )
+  const centered = configuredLeft + CONVERSATION_SCALE_WIDTH + CONVERSATION_SCALE_CONTENT_GAP > content
+  const left = centered ? (content - CONVERSATION_SCALE_WIDTH) / 2 : configuredLeft
+  const previewRight = left
+    + CONVERSATION_SCALE_WIDTH
+    + CONVERSATION_SCALE_PREVIEW_GAP
+    + CONVERSATION_SCALE_PREVIEW_WIDTH
+    + CONVERSATION_SCALE_RIGHT_GAP
+    + recovery
+  if (previewRight > width) return { visible: false, reason: 'preview', left, centered }
+  return { visible: true, reason: 'ready', left, centered }
+}
+
+
+export function resolveConversationScaleCalibrationState({
+  operationWidth,
+  contentLeft,
+  maximumDistance = CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE,
+  turnCount = 0,
+  drawerMode,
+  viewportWidth,
+  previouslyHidden = false,
+} = {}) {
+  const numeric = Number(maximumDistance)
+  const normalizedMaximum = Number.isFinite(numeric)
+    ? clamp(Math.round(numeric / 8) * 8, 16, 240)
+    : CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE
+  const resolution = drawerMode === 'overlay'
+    ? { visible: false, reason: 'drawer' }
+    : Number(viewportWidth) <= 640
+      ? { visible: false, reason: 'phone' }
+      : resolveConversationScaleGeometry({
+        operationWidth,
+        contentLeft,
+        maximumDistance: normalizedMaximum,
+        previouslyHidden,
+      })
+  if (!resolution.visible) return {
+    ...resolution,
+    mode: 'hidden',
+    maximumDistance: normalizedMaximum,
+  }
+  if (Number(turnCount) < MINIMUM_TURNS) return {
+    visible: false,
+    reason: 'turns',
+    mode: 'hidden',
+    maximumDistance: normalizedMaximum,
+    left: resolution.left,
+    centered: resolution.centered,
+  }
+  return {
+    ...resolution,
+    mode: resolution.centered ? 'centered' : 'configured',
+    maximumDistance: normalizedMaximum,
+  }
+}
+
+function visible(node) {
+  return node && !node.hidden && node.getAttribute('aria-hidden') !== 'true'
+}
+
+function follows(first, second) {
+  return Boolean(first?.compareDocumentPosition?.(second) & 4)
+}
+
+function truncateText(value, limit) {
+  const characters = Array.from(value)
+  return characters.length > limit ? `${characters.slice(0, limit).join('')}…` : value
+}
+
+function attachmentSummary(node) {
+  const named = node?.querySelector?.('[data-file-name], [download], img[alt]')
+  const name = named?.getAttribute('data-file-name')
+    || named?.getAttribute('download')
+    || named?.getAttribute('alt')
+  if (name?.trim()) return `${named?.matches('img') ? '图片' : '附件'} · ${name.trim()}`
+  if (node?.querySelector?.('img, [data-file], [data-attachment], input[type="file"]')) return '附件消息'
+  return ''
+}
+
+export function sanitizeConversationPreviewNode(node, limit = 360) {
+  if (!node) return ''
+  const clone = node.cloneNode(true)
+  for (const removable of clone.querySelectorAll?.(PREVIEW_REMOVE_SELECTOR) || []) removable.remove()
+  for (const block of clone.querySelectorAll?.('pre') || []) {
+    const firstLine = block.textContent?.split(/\r?\n/).map(line => line.trim()).find(Boolean) || ''
+    block.textContent = firstLine ? `代码：${firstLine}` : '代码'
+  }
+  const text = clone.textContent?.replace(/\s+/g, ' ').trim() || attachmentSummary(node)
+  return truncateText(text, limit)
+}
+
+export function collectConversationTurns(scroller) {
+  if (!scroller) return []
+  return Array.from(scroller.querySelectorAll(CONVERSATION_USER_TURN_SELECTOR)).filter(node => {
+    if (!visible(node) || node.closest('[data-prts-conversation-scale], [data-prts-conversation-preview]')) return false
+    const parent = node.parentElement?.closest?.(CONVERSATION_USER_TURN_SELECTOR)
+    return !parent || !scroller.contains(parent)
+  })
+}
+
+function hasClassSuffix(node, suffix) {
+  return [...(node?.classList ?? [])].some(token => token.endsWith(suffix))
+}
+
+export function findConversationOlderButton(root) {
+  for (const button of root?.querySelectorAll?.('button') ?? []) {
+    for (let current = button.parentElement; current && root.contains(current); current = current.parentElement) {
+      if (hasClassSuffix(current, '_older')) return button
+    }
+  }
+  return null
+}
+
+export function resolveConversationHistorySnapshot(sessions) {
+  try {
+    const listSnapshot = sessions?.list?.getSnapshot?.()
+    const current = listSnapshot?.current
+      ?? listSnapshot?.currentId
+      ?? listSnapshot?.currentSessionId
+    if (current === undefined || current === null) return {}
+    const binding = sessions?.binding?.(current)
+    const session = binding?.session
+    const snapshot = session?.getSnapshot?.() ?? binding?.getSnapshot?.()
+    return { key: current, hasMore: snapshot?.hasMore === true, loading: snapshot?.loadingOlder === true }
+  } catch {
+    return {}
+  }
+}
+
+function collectAssistantCandidates(scroller, turn, nextTurn) {
+  return Array.from(scroller?.querySelectorAll?.(ASSISTANT_SELECTOR) || []).filter(node => {
+    if (!visible(node)) return false
+    const parent = node.parentElement?.closest?.(ASSISTANT_SELECTOR)
+    if (parent && scroller.contains(parent)) return false
+    if (!follows(turn, node)) return false
+    return !nextTurn || follows(node, nextTurn)
+  })
+}
+
+function formalBodies(candidate) {
+  const bodies = []
+  if (candidate.matches?.(FORMAL_ANSWER_SELECTOR)) bodies.push(candidate)
+  bodies.push(...candidate.querySelectorAll?.(FORMAL_ANSWER_SELECTOR) || [])
+  return bodies.filter(body => !body.closest?.(AUXILIARY_SELECTOR))
+}
+
+export function getConversationTurnPreview(scroller, turns, index) {
+  const turn = turns?.[index]
+  if (!turn) return { question: '', answer: '尚无有效回复', state: 'empty', answerSource: undefined }
+  const nextTurn = turns[index + 1]
+  const questionSource = turn.querySelector?.('[class$="_bubble"], [data-message-role="user"]') || turn
+  const question = sanitizeConversationPreviewNode(questionSource, 180) || attachmentSummary(turn) || '附件消息'
+  const candidates = collectAssistantCandidates(scroller, turn, nextTurn)
+
+  for (const candidate of candidates) {
+    for (const body of formalBodies(candidate)) {
+      const answer = sanitizeConversationPreviewNode(body, 420)
+      if (answer) return { question, answer, state: 'answer', answerSource: body }
+    }
+  }
+
+  for (const candidate of candidates) {
+    const answer = sanitizeConversationPreviewNode(candidate, 420)
+    if (answer) return { question, answer, state: 'fallback', answerSource: candidate }
+  }
+
+  const streaming = candidates.some(candidate => candidate.matches?.(STREAMING_SELECTOR) || candidate.querySelector?.(STREAMING_SELECTOR))
+  return {
+    question,
+    answer: streaming ? '正在生成…' : '尚无有效回复',
+    state: streaming ? 'streaming' : 'empty',
+    answerSource: candidates[0],
+  }
+}
+
+export function getConversationScaleLayout(count, height, requestedOffset = 0) {
+  const safeCount = Math.max(0, Math.floor(Number(count) || 0))
+  const safeHeight = Math.max(1, Number(height) || 1)
+  const span = Math.max(0, safeCount - 1) * CONVERSATION_SCALE_SPACING
+  const usableHeight = Math.max(0, safeHeight - 1)
+  const maxOffset = Math.max(0, span - usableHeight)
+  const offset = clamp(Number(requestedOffset) || 0, 0, maxOffset)
+  const start = .5 + (maxOffset === 0 ? (usableHeight - span) / 2 : 0)
+  const positions = Array.from({ length: safeCount }, (_, index) =>
+    start + index * CONVERSATION_SCALE_SPACING - offset)
+  return { count: safeCount, height: safeHeight, span, maxOffset, offset, start, positions }
+}
+
+export function conversationScaleWaveLength(distance, lengths = CONVERSATION_SCALE_LENGTHS) {
+  const safeDistance = Math.abs(Number(distance) || 0)
+  const lower = Math.floor(safeDistance)
+  if (lower >= lengths.length - 1) return lengths.at(-1)
+  const progress = safeDistance - lower
+  const from = lengths[lower]
+  const to = lengths[lower + 1]
+  return from + (to - from) * progress
+}
+
+export function visibleConversationTickRange(layout, buffer = 2) {
+  if (!layout?.count) return { minimum: 0, maximum: -1 }
+  const padding = Math.max(0, Math.floor(Number(buffer) || 0))
+  const minimum = Math.max(
+    0,
+    Math.ceil((layout.offset - layout.start) / CONVERSATION_SCALE_SPACING) - padding,
+  )
+  const maximum = Math.min(
+    layout.count - 1,
+    Math.floor((layout.height - .5 + layout.offset - layout.start) / CONVERSATION_SCALE_SPACING) + padding,
+  )
+  return { minimum, maximum }
+}
+
+export function nearestVisibleConversationTick(layout, localY) {
+  if (!layout?.count) return -1
+  const minimum = Math.max(0, Math.ceil((layout.offset - layout.start) / CONVERSATION_SCALE_SPACING))
+  const maximum = Math.min(
+    layout.count - 1,
+    Math.floor((layout.height - .5 + layout.offset - layout.start) / CONVERSATION_SCALE_SPACING),
+  )
+  if (maximum < minimum) return -1
+  const raw = Math.round((Number(localY) + layout.offset - layout.start) / CONVERSATION_SCALE_SPACING)
+  return clamp(raw, minimum, maximum)
+}
+
+export function snapConversationScaleOffset(offset, maximum) {
+  return clamp(
+    Math.round((Number(offset) || 0) / CONVERSATION_SCALE_SPACING) * CONVERSATION_SCALE_SPACING,
+    0,
+    Math.max(0, Number(maximum) || 0),
+  )
+}
+
+export function shouldFollowConversationScaleBottom(offset, maximum) {
+  return Math.max(0, Number(maximum) || 0) - (Number(offset) || 0) <= 1
+}
+
+export function calculateConversationJumpTop({
+  scrollTop,
+  scrollHeight,
+  clientHeight,
+  turnTop,
+  visibleTop,
+  visibleHeight,
+}) {
+  const target = (Number(scrollTop) || 0)
+    + (Number(turnTop) || 0)
+    - (Number(visibleTop) || 0)
+    - Math.max(0, Number(visibleHeight) || 0) * .28
+  return clamp(target, 0, Math.max(0, (Number(scrollHeight) || 0) - (Number(clientHeight) || 0)))
+}
+
+export function resolveConversationJumpBehavior(distance, viewportHeight, prefersReducedMotion = false) {
+  if (prefersReducedMotion) return 'auto'
+  const height = Math.max(0, Number(viewportHeight) || 0)
+  const delta = Math.abs(Number(distance) || 0)
+  return height > 0 && delta <= height * CONVERSATION_JUMP_SMOOTH_VIEWPORT_LIMIT ? 'smooth' : 'auto'
+}
+
+export function resolveConversationJumpSettle(distance, viewportHeight, prefersReducedMotion = false) {
+  if (prefersReducedMotion || resolveConversationJumpBehavior(distance, viewportHeight) === 'smooth') {
+    return { offset: 0, duration: 0 }
+  }
+  const height = Math.max(0, Number(viewportHeight) || 0)
+  const delta = Number(distance) || 0
+  if (height <= 0 || Math.abs(delta) <= 2) return { offset: 0, duration: 0 }
+  const offset = Math.sign(delta) * Math.min(
+    Math.abs(delta),
+    CONVERSATION_JUMP_SETTLE_MAX_DISTANCE,
+    height * CONVERSATION_JUMP_SETTLE_VIEWPORT_RATIO,
+  )
+  return { offset, duration: CONVERSATION_JUMP_SETTLE_DURATION }
+}
+
+function scrollConversationTo(scroller, top, behavior) {
+  if (typeof scroller?.scrollTo === 'function') scroller.scrollTo({ top, behavior })
+  else if (scroller) scroller.scrollTop = top
+}
+
+export async function performConversationJump({
+  scroller,
+  getTargetTop,
+  prefersReducedMotion = false,
+  requestFrame = callback => globalThis.requestAnimationFrame?.(callback) ?? globalThis.setTimeout?.(callback, 16),
+  now = () => globalThis.performance?.now?.() ?? Date.now(),
+  cancelled = () => false,
+  onFrame = () => {},
+} = {}) {
+  if (!scroller || typeof getTargetTop !== 'function') return false
+  const nextFrame = () => new Promise(resolve => requestFrame(timestamp => {
+    resolve(Number.isFinite(timestamp) ? timestamp : now())
+  }))
+  const targetTop = () => {
+    const raw = getTargetTop()
+    if (raw === null || raw === undefined) return null
+    const value = Number(raw)
+    return Number.isFinite(value) ? value : null
+  }
+
+  let top = targetTop()
+  if (top === null) return false
+  const floor = Math.max(0, Number(scroller.scrollHeight) - Number(scroller.clientHeight))
+  const bottomDistance = floor - Number(scroller.scrollTop)
+  if (bottomDistance <= CONVERSATION_JUMP_BOTTOM_THRESHOLD && top < Number(scroller.scrollTop)) {
+    scroller.scrollTop = Math.max(0, Number(scroller.scrollTop) - 1)
+    await nextFrame()
+    if (cancelled()) return null
+    top = targetTop()
+    if (top === null) return false
+  }
+
+  const distance = top - Number(scroller.scrollTop)
+  const behavior = resolveConversationJumpBehavior(distance, scroller.clientHeight, prefersReducedMotion)
+  const settle = resolveConversationJumpSettle(distance, scroller.clientHeight, prefersReducedMotion)
+  if (settle.duration > 0) {
+    const limit = () => Math.max(0, Number(scroller.scrollHeight) - Number(scroller.clientHeight))
+    const beforeTarget = clamp(top - settle.offset, 0, limit())
+    scrollConversationTo(scroller, beforeTarget, 'auto')
+    await nextFrame()
+    if (cancelled()) return null
+    const from = Number(scroller.scrollTop)
+    const startedAt = now()
+    let progress = 0
+    while (progress < 1) {
+      const timestamp = await nextFrame()
+      if (cancelled()) return null
+      progress = Math.min(1, (timestamp - startedAt) / settle.duration)
+      const eased = 1 - (1 - progress) ** 3
+      const liveTarget = targetTop()
+      if (liveTarget === null) return false
+      scroller.scrollTop = from + (liveTarget - from) * eased
+      onFrame()
+    }
+  } else {
+    scrollConversationTo(scroller, top, behavior)
+    onFrame()
+  }
+
+  let stableFrames = 0
+  let verificationFrames = 0
+  const verificationStartedAt = now()
+  while (now() - verificationStartedAt < CONVERSATION_JUMP_VERIFY_DURATION && verificationFrames < 72) {
+    await nextFrame()
+    verificationFrames += 1
+    if (cancelled()) return null
+    const liveTarget = targetTop()
+    if (liveTarget === null) return false
+    stableFrames = Math.abs(Number(scroller.scrollTop) - liveTarget) <= 2 ? stableFrames + 1 : 0
+    if (stableFrames >= 2) return true
+  }
+
+  top = targetTop()
+  if (top === null) return false
+  scrollConversationTo(scroller, top, 'auto')
+  await nextFrame()
+  await nextFrame()
+  if (cancelled()) return null
+  const correctedTarget = targetTop()
+  return correctedTarget !== null && Math.abs(Number(scroller.scrollTop) - correctedTarget) <= 2
+}
+
+export function buildConversationScalePaths(layout, interactionIndex = -1, animation, lengths = CONVERSATION_SCALE_LENGTHS) {
+  const gray = []
+  const yellow = []
+  const history = []
+  const hovering = interactionIndex >= 0 && interactionIndex < layout.count
+  const animatedCenter = Number.isFinite(animation?.center) ? animation.center : interactionIndex
+  const animatedIntensity = animation
+    ? clamp(Number(animation.intensity) || 0, 0, 1)
+    : hovering ? 1 : 0
+  const restingLength = lengths.at(-1)
+  const { minimum, maximum } = visibleConversationTickRange(layout)
+  for (let index = minimum; index <= maximum; index += 1) {
+    const rawY = layout.start + index * CONVERSATION_SCALE_SPACING - layout.offset
+    if (rawY < .5 || rawY > layout.height - .5) continue
+    const y = Number(rawY.toFixed(2))
+    const waveLength = conversationScaleWaveLength(Math.abs(index - animatedCenter), lengths)
+    if (animation?.historyAvailable && index === 0) {
+      const selected = interactionIndex === 0
+      const intensity = selected ? animatedIntensity : 0
+      const restingFirstEnd = 2 + restingLength
+      const restingSecondStart = restingFirstEnd + 4
+      const restingSecondEnd = restingSecondStart + restingLength
+      const firstEnd = Number((
+        restingFirstEnd + (14 - restingFirstEnd) * intensity
+      ).toFixed(2))
+      const secondStart = Number((
+        restingSecondStart + (16 - restingSecondStart) * intensity
+      ).toFixed(2))
+      const secondEnd = Number((
+        restingSecondEnd + (30 - restingSecondEnd) * intensity
+      ).toFixed(2))
+      history.push(`M2 ${y}H${firstEnd}M${secondStart} ${y}H${secondEnd}`)
+      continue
+    }
+    const length = restingLength + (waveLength - restingLength) * animatedIntensity
+    const command = `M2 ${y}H${Number((2 + length).toFixed(2))}`
+    const accented = hovering ? index === interactionIndex : index === layout.count - 1
+    ;(accented ? yellow : gray).push(command)
+  }
+  return { gray: gray.join(''), yellow: yellow.join(''), history: history.join('') }
+}
+
+function createPreview(document, id) {
+  const preview = document.createElement('aside')
+  preview.id = id
+  preview.setAttribute('data-prts-conversation-preview', '')
+  preview.setAttribute('data-prts-owned-conversation-preview', '')
+  preview.setAttribute('role', 'tooltip')
+  preview.setAttribute('aria-hidden', 'true')
+  const connector = document.createElement('span')
+  connector.setAttribute('data-prts-conversation-preview-connector', '')
+  connector.setAttribute('aria-hidden', 'true')
+  const body = document.createElement('div')
+  body.setAttribute('data-prts-conversation-preview-body', '')
+  const question = document.createElement('div')
+  question.setAttribute('data-prts-conversation-preview-row', 'question')
+  const questionLabel = document.createElement('b')
+  questionLabel.textContent = 'Q'
+  const questionText = document.createElement('span')
+  questionText.setAttribute('data-prts-conversation-preview-question', '')
+  question.append(questionLabel, questionText)
+  const answer = document.createElement('div')
+  answer.setAttribute('data-prts-conversation-preview-row', 'answer')
+  const answerLabel = document.createElement('b')
+  answerLabel.textContent = 'A'
+  const answerText = document.createElement('span')
+  answerText.setAttribute('data-prts-conversation-preview-answer', '')
+  answer.append(answerLabel, answerText)
+  body.append(question, answer)
+  preview.append(connector, body)
+  preview._prtsBody = body
+  preview._prtsQuestion = questionText
+  preview._prtsAnswer = answerText
+  return preview
+}
+
+function createScale(document) {
+  const instance = ++scaleInstanceSeed
+  const maskId = `prts-conversation-scale-fade-${instance}`
+  const previewId = `prts-conversation-preview-${instance}`
+  const historyTooltipId = `prts-conversation-history-tooltip-${instance}`
+  const scale = document.createElement('div')
+  scale.setAttribute('data-prts-conversation-scale', '')
+  scale.setAttribute('data-prts-owned-conversation-scale', '')
+  scale.setAttribute('role', 'slider')
+  scale.setAttribute('aria-label', '会话刻度导航')
+  scale.setAttribute('aria-orientation', 'vertical')
+  scale.tabIndex = 0
+
+  const svg = document.createElementNS(SVG_NAMESPACE, 'svg')
+  svg.setAttribute('data-prts-conversation-scale-svg', '')
+  svg.setAttribute('aria-hidden', 'true')
+  svg.setAttribute('preserveAspectRatio', 'none')
+  const defs = document.createElementNS(SVG_NAMESPACE, 'defs')
+  const gradient = document.createElementNS(SVG_NAMESPACE, 'linearGradient')
+  gradient.id = `${maskId}-gradient`
+  gradient.setAttribute('gradientUnits', 'userSpaceOnUse')
+  gradient.setAttribute('x1', '0')
+  gradient.setAttribute('y1', '0')
+  gradient.setAttribute('x2', '0')
+  gradient.setAttribute('y2', '24')
+  const transparent = document.createElementNS(SVG_NAMESPACE, 'stop')
+  transparent.setAttribute('offset', '0')
+  transparent.setAttribute('stop-color', 'white')
+  transparent.setAttribute('stop-opacity', '0')
+  const opaque = document.createElementNS(SVG_NAMESPACE, 'stop')
+  opaque.setAttribute('offset', '1')
+  opaque.setAttribute('stop-color', 'white')
+  gradient.append(transparent, opaque)
+  const mask = document.createElementNS(SVG_NAMESPACE, 'mask')
+  mask.id = maskId
+  mask.setAttribute('maskUnits', 'userSpaceOnUse')
+  mask.setAttribute('x', '0')
+  mask.setAttribute('y', '0')
+  mask.setAttribute('width', String(SCALE_WIDTH))
+  const maskRect = document.createElementNS(SVG_NAMESPACE, 'rect')
+  maskRect.setAttribute('x', '0')
+  maskRect.setAttribute('y', '0')
+  maskRect.setAttribute('width', String(SCALE_WIDTH))
+  maskRect.setAttribute('fill', `url(#${gradient.id})`)
+  mask.append(maskRect)
+  defs.append(gradient, mask)
+  const marks = document.createElementNS(SVG_NAMESPACE, 'g')
+  marks.setAttribute('data-prts-conversation-scale-marks', '')
+  const gray = document.createElementNS(SVG_NAMESPACE, 'path')
+  gray.setAttribute('data-prts-conversation-scale-gray', '')
+  const yellow = document.createElementNS(SVG_NAMESPACE, 'path')
+  yellow.setAttribute('data-prts-conversation-scale-accent', '')
+  const history = document.createElementNS(SVG_NAMESPACE, 'path')
+  history.setAttribute('data-prts-conversation-scale-history', '')
+  marks.append(gray, yellow, history)
+  const hit = document.createElementNS(SVG_NAMESPACE, 'rect')
+  hit.setAttribute('data-prts-conversation-scale-hit', '')
+  hit.setAttribute('x', '0')
+  hit.setAttribute('y', '0')
+  hit.setAttribute('width', String(SCALE_WIDTH))
+  hit.setAttribute('fill', 'transparent')
+  svg.append(defs, marks, hit)
+  scale.append(svg)
+  scale._prtsSvg = svg
+  scale._prtsMarks = marks
+  scale._prtsMask = mask
+  scale._prtsMaskRect = maskRect
+  scale._prtsMaskId = maskId
+  scale._prtsGray = gray
+  scale._prtsAccent = yellow
+  scale._prtsHistory = history
+  scale._prtsHit = hit
+  scale._prtsPreview = createPreview(document, previewId)
+  const historyStatus = document.createElement('div')
+  historyStatus.setAttribute('data-prts-conversation-history-status', '')
+  historyStatus.setAttribute('role', 'status')
+  historyStatus.setAttribute('aria-live', 'polite')
+  historyStatus.hidden = true
+  const historyText = document.createElement('span')
+  historyText.setAttribute('data-prts-conversation-history-text', '')
+  const historyAction = document.createElement('button')
+  historyAction.type = 'button'
+  historyAction.setAttribute('data-prts-conversation-history-action', '')
+  historyStatus.append(historyText, historyAction)
+  const historyHint = document.createElement('div')
+  historyHint.setAttribute('data-prts-conversation-history-hint', '')
+  historyHint.setAttribute('data-prts-owned-conversation-scale', '')
+  historyHint.hidden = true
+  const historyTrigger = document.createElement('button')
+  historyTrigger.type = 'button'
+  historyTrigger.tabIndex = -1
+  historyTrigger.setAttribute('data-prts-conversation-history-trigger', '')
+  historyTrigger.setAttribute('aria-label', '载入更早内容并前往会话开头')
+  const historyTooltip = document.createElement('div')
+  historyTooltip.id = historyTooltipId
+  historyTooltip.setAttribute('data-prts-conversation-history-tooltip', '')
+  historyTooltip.setAttribute('role', 'tooltip')
+  historyTooltip.setAttribute('aria-hidden', 'true')
+  historyTooltip.hidden = true
+  const historyTooltipConnector = document.createElement('span')
+  historyTooltipConnector.setAttribute('data-prts-conversation-history-tooltip-connector', '')
+  historyTooltipConnector.setAttribute('aria-hidden', 'true')
+  const historyTooltipBody = document.createElement('div')
+  historyTooltipBody.setAttribute('data-prts-conversation-preview-body', '')
+  historyTooltipBody.setAttribute('data-prts-conversation-history-tooltip-body', '')
+  const historyTooltipHeader = document.createElement('div')
+  historyTooltipHeader.setAttribute('data-prts-conversation-preview-row', 'question')
+  const historyTooltipHeaderLabel = document.createElement('b')
+  historyTooltipHeaderLabel.textContent = 'H'
+  const historyTooltipHeaderText = document.createElement('span')
+  historyTooltipHeaderText.setAttribute('data-prts-conversation-history-tooltip-label', '')
+  historyTooltipHeaderText.textContent = '历史断点'
+  historyTooltipHeader.append(historyTooltipHeaderLabel, historyTooltipHeaderText)
+  const historyTooltipDetail = document.createElement('div')
+  historyTooltipDetail.setAttribute('data-prts-conversation-preview-row', 'answer')
+  const historyTooltipDetailLabel = document.createElement('b')
+  historyTooltipDetailLabel.textContent = '↥'
+  const historyTooltipContent = document.createElement('div')
+  historyTooltipContent.setAttribute('data-prts-conversation-history-tooltip-content', '')
+  const historyTooltipTitle = document.createElement('strong')
+  historyTooltipTitle.textContent = '更早内容尚未加载'
+  const historyTooltipDescription = document.createElement('span')
+  historyTooltipDescription.textContent = '点击断点，载入历史并前往会话开头'
+  historyTooltipContent.append(historyTooltipTitle, historyTooltipDescription)
+  historyTooltipDetail.append(historyTooltipDetailLabel, historyTooltipContent)
+  historyTooltipBody.append(historyTooltipHeader, historyTooltipDetail)
+  historyTooltip.append(historyTooltipConnector, historyTooltipBody)
+  historyHint.append(historyTrigger, historyTooltip)
+  scale._prtsHistoryStatus = historyStatus
+  scale._prtsHistoryText = historyText
+  scale._prtsHistoryAction = historyAction
+  scale._prtsHistoryHint = historyHint
+  scale._prtsHistoryTrigger = historyTrigger
+  scale._prtsHistoryTooltip = historyTooltip
+  return scale
+}
+
+export function createConversationScaleAdapter({ document, window, sessions }) {
+  let operation
+  let scroller
+  let composer
+  let scale
+  let preview
+  let historyStatus
+  let historyHint
+  let mutationObserver
+  let resizeObserver
+  let previewObserver
+  let previewSource
+  let frame
+  let waveFrame
+  let snapTimer
+  let touchTimer
+  let previewDelayTimer
+  let previewHideTimer
+  let previewRefreshTimer
+  let turns = []
+  let resizeSettleTimer
+  let resizeActive = false
+  let layout
+  let geometry
+  let scaleOffset = 0
+  let previousMaximum = 0
+  let followBottom = true
+  let cursorIndex = 0
+  let hoverIndex = -1
+  let previewIndex = -1
+  let pendingPreviewIndex = -1
+  let keyboardActive = false
+  let pointerInside = false
+  let pointerStart
+  let lastDirectJump = 0
+  let jumpRequest = 0
+  let historyRequest = 0
+  let historyMutationRevision = 0
+  let historyAvailable = false
+  let historyPhase = 'idle'
+  let historyPages = 0
+  let historyMessage = ''
+  let historySessionKey
+  let historyHintHovered = false
+  let scanPending = false
+  let fullScanPending = false
+  let pendingMutations = []
+  let obstructionDirty = true
+  const overlayCandidates = new Set()
+  let overlayScanPending = false
+  let scaleObstructed = false
+  let scaleBlockingObstructed = false
+  let scaleSpaceObstructed = true
+  let maximumDistance = CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE
+  let focusContrast = CONVERSATION_SCALE_FOCUS_CONTRAST_DEFAULT
+  let scaleLengths = resolveConversationScaleLengths(focusContrast)
+  let contentLeft
+  let geometryDirty = true
+  let observedOperationWidth
+  let observedOperationHeight
+  let started = false
+  let failed = false
+  let waveCenter = 0
+  let waveIntensity = 0
+  let waveStartCenter = 0
+  let waveStartIntensity = 0
+  let waveTargetCenter = 0
+  let waveTargetIntensity = 0
+  let waveStartedAt = 0
+
+  const requestFrame = callback => window?.requestAnimationFrame?.(callback) ?? window?.setTimeout?.(callback, 0)
+  const cancelFrame = id => {
+    if (id === undefined) return
+    if (window?.cancelAnimationFrame) window.cancelAnimationFrame(id)
+    else window?.clearTimeout?.(id)
+  }
+  const currentTime = timestamp => Number.isFinite(timestamp)
+    ? timestamp
+    : window?.performance?.now?.() ?? Date.now()
+
+  function reducedMotion() {
+    return window?.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches
+      || document.documentElement.dataset.prtsMotion === 'reduced'
+  }
+
+  function sampleWave(timestamp = currentTime()) {
+    if (waveFrame === undefined) return
+    const progress = clamp((currentTime(timestamp) - waveStartedAt) / CONVERSATION_SCALE_WAVE_DURATION, 0, 1)
+    const eased = 1 - (1 - progress) ** 3
+    waveCenter = waveStartCenter + (waveTargetCenter - waveStartCenter) * eased
+    waveIntensity = waveStartIntensity + (waveTargetIntensity - waveStartIntensity) * eased
+  }
+
+  function animateWave(timestamp) {
+    waveFrame = undefined
+    if (!started || failed) return
+    const time = currentTime(timestamp)
+    const progress = clamp((time - waveStartedAt) / CONVERSATION_SCALE_WAVE_DURATION, 0, 1)
+    const eased = 1 - (1 - progress) ** 3
+    waveCenter = waveStartCenter + (waveTargetCenter - waveStartCenter) * eased
+    waveIntensity = waveStartIntensity + (waveTargetIntensity - waveStartIntensity) * eased
+    schedule()
+    if (progress < 1) waveFrame = requestFrame(animateWave)
+  }
+
+  function retargetWave(index) {
+    const time = currentTime()
+    sampleWave(time)
+    cancelFrame(waveFrame)
+    waveFrame = undefined
+    waveStartCenter = waveCenter
+    waveStartIntensity = waveIntensity
+    waveTargetCenter = index >= 0 ? index : waveCenter
+    waveTargetIntensity = index >= 0 ? 1 : 0
+    waveStartedAt = time
+    if (reducedMotion()) {
+      waveCenter = waveTargetCenter
+      waveIntensity = waveTargetIntensity
+      schedule()
+      return
+    }
+    waveFrame = requestFrame(animateWave)
+  }
+
+  function resetWave() {
+    cancelFrame(waveFrame)
+    waveFrame = undefined
+    waveCenter = 0
+    waveIntensity = 0
+    waveStartCenter = 0
+    waveStartIntensity = 0
+    waveTargetCenter = 0
+    waveTargetIntensity = 0
+    waveStartedAt = 0
+  }
+
+  function cancelJump() {
+    jumpRequest += 1
+  }
+
+  function historyPrefix() {
+    return historyAvailable ? 1 : 0
+  }
+
+  function scaleItemCount() {
+    return turns.length + historyPrefix()
+  }
+
+  function scaleToTurnIndex(index) {
+    return index - historyPrefix()
+  }
+
+  function turnToScaleIndex(index) {
+    return index + historyPrefix()
+  }
+
+  function syncHistoryStatus() {
+    if (!historyStatus || !scale) return
+    const visible = historyPhase === 'loading' || historyPhase === 'paused' || historyPhase === 'error'
+    historyStatus.hidden = !visible
+    historyStatus.dataset.prtsHistoryPhase = historyPhase
+    scale.dataset.prtsHistoryPhase = historyPhase
+    scale.toggleAttribute('data-prts-conversation-history-available', historyAvailable)
+    if (!visible) {
+      syncHistoryHint()
+      return
+    }
+    const page = historyPhase === 'loading' ? historyPages + 1 : historyPages
+    const fallback = historyPhase === 'loading'
+      ? `正在载入更早内容 · 第 ${page} 页`
+      : historyPhase === 'error'
+        ? historyMessage || '更早内容载入失败'
+        : historyPages > 0
+          ? `已载入 ${historyPages} 页 · 尚未到达开头`
+          : '已载入部分内容 · 尚未到达开头'
+    scale._prtsHistoryText.textContent = fallback
+    scale._prtsHistoryAction.textContent = historyPhase === 'loading' ? '取消' : '继续'
+    scale._prtsHistoryAction.setAttribute(
+      'aria-label',
+      historyPhase === 'loading' ? '取消前往会话开头' : '继续前往会话开头',
+    )
+    syncHistoryHint()
+  }
+
+  function syncHistoryHint() {
+    if (!historyHint || !scale) return
+    const railUnavailable = scaleSpaceObstructed || scaleBlockingObstructed || scaleObstructed
+      || scaleItemCount() < MINIMUM_TURNS
+    const visible = historyAvailable && historyPhase === 'idle' && !railUnavailable
+    if (!visible) historyHintHovered = false
+    const selected = visible && (
+      historyHintHovered
+      || (pointerInside && hoverIndex === 0)
+    )
+    historyHint.hidden = !visible
+    historyHint.toggleAttribute('data-prts-history-selected', selected)
+    scale.toggleAttribute('data-prts-conversation-history-selected', selected)
+    const tooltip = scale._prtsHistoryTooltip
+    tooltip.hidden = !selected
+    tooltip.setAttribute('aria-hidden', String(!selected))
+    const tooltipId = tooltip.id
+    for (const target of [scale, scale._prtsHistoryTrigger]) {
+      if (selected) target.setAttribute('aria-describedby', tooltipId)
+      else if (target.getAttribute('aria-describedby') === tooltipId) target.removeAttribute('aria-describedby')
+    }
+  }
+
+  function selectHistoryHint({ keyboard = false } = {}) {
+    if (!historyAvailable || historyPhase !== 'idle') return
+    keyboardActive = keyboard
+    hoverIndex = 0
+    cursorIndex = 0
+    ensureVisible(0)
+    retargetWave(0)
+    syncAccessibility()
+    schedule()
+  }
+
+  function setHistoryAvailable(next) {
+    const available = Boolean(next)
+    if (available === historyAvailable) return
+    const previousPrefix = historyPrefix()
+    historyAvailable = available
+    const delta = historyPrefix() - previousPrefix
+    if (cursorIndex >= previousPrefix) cursorIndex = Math.max(0, cursorIndex + delta)
+    if (hoverIndex >= previousPrefix) hoverIndex = Math.max(0, hoverIndex + delta)
+    if (!followBottom && scaleOffset > 0) scaleOffset = Math.max(0, scaleOffset + delta * CONVERSATION_SCALE_SPACING)
+    geometryDirty = true
+    syncHistoryStatus()
+  }
+
+  function readHistoryState() {
+    const snapshot = resolveConversationHistorySnapshot(sessions)
+    const olderButton = findConversationOlderButton(operation)
+    if (snapshot.key !== undefined && snapshot.key !== historySessionKey) {
+      historyRequest += 1
+      historySessionKey = snapshot.key
+      historyPages = 0
+      historyPhase = 'idle'
+      historyMessage = ''
+    }
+    const available = snapshot.hasMore || Boolean(olderButton) || historyPhase === 'loading'
+    setHistoryAvailable(available)
+    if (!available && historyPhase !== 'loading') {
+      historyPhase = 'idle'
+      historyMessage = ''
+      syncHistoryStatus()
+    }
+    return { ...snapshot, olderButton }
+  }
+
+  function cancelHistory({ paused = true } = {}) {
+    if (historyPhase !== 'loading') return
+    historyRequest += 1
+    historyPhase = paused && historyAvailable ? 'paused' : 'idle'
+    historyMessage = ''
+    syncHistoryStatus()
+    schedule()
+  }
+
+  function cancelNavigation() {
+    cancelJump()
+    cancelHistory()
+  }
+
+  function onHistoryAction(event) {
+    event.preventDefault()
+    event.stopPropagation()
+    if (historyPhase === 'loading') cancelHistory()
+    else void loadHistoryToStart()
+  }
+
+  function onHistoryHintPointerEnter() {
+    historyHintHovered = true
+    selectHistoryHint()
+  }
+
+  function onHistoryHintPointerLeave() {
+    historyHintHovered = false
+    if (!pointerInside) {
+      hoverIndex = -1
+      retargetWave(-1)
+    }
+    schedule()
+  }
+
+  function schedule(scan = false) {
+    if (scan) {
+      scanPending = true
+      fullScanPending = true
+    }
+    if (resizeActive) return
+    if (frame !== undefined || failed) return
+    frame = requestFrame(flush)
+  }
+
+  function clearTimers() {
+    for (const timer of [snapTimer, touchTimer, previewDelayTimer, previewHideTimer, previewRefreshTimer, resizeSettleTimer]) {
+      if (timer !== undefined) window?.clearTimeout?.(timer)
+    }
+    snapTimer = undefined
+    touchTimer = undefined
+    previewDelayTimer = undefined
+    previewHideTimer = undefined
+    previewRefreshTimer = undefined
+    resizeSettleTimer = undefined
+  }
+
+  function setScaleResizeState(active) {
+    resizeActive = Boolean(active)
+    for (const node of [scale, preview, historyHint, historyStatus, composer]) {
+      if (!node || node.hasAttribute('data-prts-resizing') === resizeActive) continue
+      node.toggleAttribute('data-prts-resizing', resizeActive)
+    }
+  }
+
+  function disconnectPreviewObserver() {
+    resizeSettleTimer = undefined
+    previewObserver?.disconnect()
+    previewObserver = undefined
+    previewSource = undefined
+  }
+
+  function observePreviewSource(source) {
+    if (source === previewSource) return
+    disconnectPreviewObserver()
+    const MutationObserver = window?.MutationObserver
+    if (!source || typeof MutationObserver !== 'function') return
+    previewSource = source
+    previewObserver = new MutationObserver(queuePreviewRefresh)
+    previewObserver.observe(source, {
+      subtree: true,
+      childList: true,
+      characterData: true,
+      attributes: true,
+      attributeFilter: ['hidden', 'aria-hidden'],
+    })
+  }
+
+  function resolveRoots() {
+    const nextOperation = document?.querySelector?.('[data-prts-region="operation"]')
+    const nextScroller = nextOperation?.querySelector?.('[data-conversation-scroll]')
+    if (!nextOperation || !nextScroller) {
+      if (operation || scroller || scale || preview) disconnectRoots()
+      return false
+    }
+    const nextComposer = nextScroller.querySelector('[data-composer-seat], [data-slot="conversation.composer"]')
+    if (operation === nextOperation && scroller === nextScroller && scale?.isConnected && preview?.isConnected
+      && historyHint?.isConnected && historyStatus?.isConnected) {
+      if (composer !== nextComposer) {
+        if (composer) resizeObserver?.unobserve?.(composer)
+        composer = nextComposer
+        if (composer) resizeObserver?.observe(composer)
+        geometryDirty = true
+      }
+      return true
+    }
+
+    disconnectRoots()
+    operation = nextOperation
+    scroller = nextScroller
+    composer = nextComposer
+    scale = createScale(document)
+    preview = scale._prtsPreview
+    historyHint = scale._prtsHistoryHint
+    historyStatus = scale._prtsHistoryStatus
+    operation.append(scale, preview, historyHint, historyStatus)
+    scale._prtsHistoryTrigger.addEventListener('click', onHistoryAction)
+    scale._prtsHistoryTrigger.addEventListener('pointerenter', onHistoryHintPointerEnter)
+    scale._prtsHistoryTrigger.addEventListener('pointerleave', onHistoryHintPointerLeave)
+    scale._prtsHistoryAction.addEventListener('click', onHistoryAction)
+    scroller.setAttribute('data-prts-conversation-scale-ready', '')
+    scale.addEventListener('pointermove', onPointerMove)
+    scale.addEventListener('pointerleave', onPointerLeave)
+    scale.addEventListener('pointerdown', onPointerDown)
+    scale.addEventListener('pointerup', onPointerUp)
+    scale.addEventListener('pointercancel', onPointerCancel)
+    scale.addEventListener('click', onClick)
+    scale.addEventListener('wheel', onWheel, { passive: false })
+    scale.addEventListener('keydown', onKeydown)
+    scale.addEventListener('focus', onFocus)
+    scale.addEventListener('blur', onBlur)
+    scroller.addEventListener('wheel', cancelNavigation, { passive: true })
+    scroller.addEventListener('touchstart', cancelNavigation, { passive: true })
+    scroller.addEventListener('pointerdown', cancelNavigation, { passive: true })
+    resizeObserver?.observe(operation)
+    resizeObserver?.observe(scroller)
+    if (composer) resizeObserver?.observe(composer)
+    turns = []
+    scaleOffset = 0
+    previousMaximum = 0
+    followBottom = true
+    obstructionDirty = true
+    cursorIndex = 0
+    hoverIndex = -1
+    previewIndex = -1
+    pendingPreviewIndex = -1
+    contentLeft = undefined
+    geometryDirty = true
+    scaleSpaceObstructed = true
+    overlayScanPending = true
+    historyRequest += 1
+    historyAvailable = false
+    historyPhase = 'idle'
+    historyPages = 0
+    historyMessage = ''
+    historySessionKey = undefined
+    historyHintHovered = false
+    setScaleResizeState(resizeActive)
+    cancelJump()
+    resetWave()
+    return true
+  }
+
+  function disconnectRoots() {
+    clearTimers()
+    hidePreview()
+    disconnectPreviewObserver()
+    if (scroller) {
+      scroller.removeAttribute('data-prts-conversation-scale-ready')
+      scroller.removeAttribute('data-prts-conversation-scale-empty')
+      scroller.removeEventListener('wheel', cancelNavigation)
+      scroller.removeEventListener('touchstart', cancelNavigation)
+      scroller.removeEventListener('pointerdown', cancelNavigation)
+    }
+    if (scale) {
+      scale.removeEventListener('pointermove', onPointerMove)
+      scale.removeEventListener('pointerleave', onPointerLeave)
+      scale.removeEventListener('pointerdown', onPointerDown)
+      scale.removeEventListener('pointerup', onPointerUp)
+      scale.removeEventListener('pointercancel', onPointerCancel)
+      scale.removeEventListener('click', onClick)
+      scale.removeEventListener('wheel', onWheel)
+      scale.removeEventListener('keydown', onKeydown)
+      scale.removeEventListener('focus', onFocus)
+      scale.removeEventListener('blur', onBlur)
+      scale._prtsHistoryTrigger?.removeEventListener('click', onHistoryAction)
+      scale._prtsHistoryTrigger?.removeEventListener('pointerenter', onHistoryHintPointerEnter)
+      scale._prtsHistoryTrigger?.removeEventListener('pointerleave', onHistoryHintPointerLeave)
+      scale._prtsHistoryAction?.removeEventListener('click', onHistoryAction)
+      scale.remove()
+    }
+    preview?.remove()
+    historyHint?.remove()
+    historyStatus?.remove()
+    resizeObserver?.disconnect()
+    historyRequest += 1
+    operation = undefined
+    scroller = undefined
+    composer = undefined
+    scale = undefined
+    preview = undefined
+    historyHint = undefined
+    historyStatus = undefined
+    turns = []
+    layout = undefined
+    geometry = undefined
+    hoverIndex = -1
+    previewIndex = -1
+    keyboardActive = false
+    pointerInside = false
+    pointerStart = undefined
+    historyHintHovered = false
+    resizeActive = false
+    cancelJump()
+    resetWave()
+    overlayCandidates.clear()
+    obstructionDirty = true
+    overlayScanPending = false
+    scaleObstructed = false
+    scaleBlockingObstructed = false
+    scaleSpaceObstructed = true
+    contentLeft = undefined
+    observedOperationWidth = undefined
+    observedOperationHeight = undefined
+    geometryDirty = true
+    pendingMutations = []
+    fullScanPending = false
+  }
+
+  function isTopLevelTurn(node) {
+    if (!node?.matches?.(CONVERSATION_USER_TURN_SELECTOR) || !scroller?.contains(node) || !visible(node)) return false
+    if (node.closest('[data-prts-conversation-scale], [data-prts-conversation-preview]')) return false
+    const parent = node.parentElement?.closest?.(CONVERSATION_USER_TURN_SELECTOR)
+    return !parent || !scroller.contains(parent)
+  }
+
+  function collectTurnsFromNode(node, target) {
+    if (node?.nodeType !== 1) return
+    if (node.matches?.(CONVERSATION_USER_TURN_SELECTOR)) target.add(node)
+    for (const turn of node.querySelectorAll?.(CONVERSATION_USER_TURN_SELECTOR) ?? []) target.add(turn)
+  }
+
+  function collectOverlayCandidates(node) {
+    if (node?.nodeType !== 1) return
+    if (node.matches?.(CONVERSATION_OVERLAY_SELECTOR)) overlayCandidates.add(node)
+    for (const candidate of node.querySelectorAll?.(CONVERSATION_OVERLAY_SELECTOR) ?? []) {
+      overlayCandidates.add(candidate)
+    }
+  }
+
+  function mutationNodeAffectsScale(node) {
+    if (node?.nodeType !== 1) return false
+    if (node.matches?.(CONVERSATION_OVERLAY_SELECTOR)
+      || node.matches?.(CONVERSATION_PORTAL_ROOT_SELECTOR)
+      || node.matches?.('[data-prts-region="operation"], [data-slot="conversation"]')) return true
+    return Boolean(node.querySelector?.([
+      CONVERSATION_OVERLAY_SELECTOR,
+      CONVERSATION_PORTAL_ROOT_SELECTOR,
+      '[data-prts-region="operation"]',
+      '[data-slot="conversation"]',
+    ].join(', ')))
+  }
+
+  function mutationAffectsTurns(mutation) {
+    if (mutation.type === 'attributes') {
+      if (mutation.attributeName === 'data-chat-flow-kind'
+        || mutation.attributeName === 'data-message-role') return true
+      if (mutation.target?.matches?.(CONVERSATION_USER_TURN_SELECTOR)
+        || mutation.target?.querySelector?.(CONVERSATION_USER_TURN_SELECTOR)) return true
+    }
+    for (const node of [...(mutation.addedNodes ?? []), ...(mutation.removedNodes ?? [])]) {
+      if (node?.nodeType !== 1) continue
+      if (node.matches?.(CONVERSATION_USER_TURN_SELECTOR)
+        || node.querySelector?.(CONVERSATION_USER_TURN_SELECTOR)) return true
+    }
+    return false
+  }
+
+  function mutationAffectsOverlay(mutation) {
+    if (overlayCandidates.has(mutation.target)) return true
+    if (mutationNodeAffectsScale(mutation.target)) return true
+    for (const node of mutation.addedNodes ?? []) if (mutationNodeAffectsScale(node)) return true
+    for (const node of mutation.removedNodes ?? []) {
+      if (mutationNodeAffectsScale(node)) return true
+      if ([...overlayCandidates].some(candidate => candidate === node || node?.contains?.(candidate))) return true
+    }
+    return false
+  }
+
+  function collectExternalOverlayCandidates() {
+    for (const child of document?.body?.children ?? []) {
+      if (child === operation || child.contains?.(operation)) continue
+      collectOverlayCandidates(child)
+    }
+  }
+
+  function updateOverlayCandidates(mutations, full = false) {
+    if (full || overlayScanPending) {
+      overlayCandidates.clear()
+      collectOverlayCandidates(operation)
+      collectExternalOverlayCandidates()
+      overlayScanPending = false
+    } else {
+      for (const mutation of mutations) {
+        if (mutation.type === 'attributes') {
+          if (mutation.target?.matches?.(CONVERSATION_OVERLAY_SELECTOR)) overlayCandidates.add(mutation.target)
+          else overlayCandidates.delete(mutation.target)
+        }
+        for (const node of mutation.addedNodes ?? []) collectOverlayCandidates(node)
+      }
+    }
+    for (const candidate of [...overlayCandidates]) {
+      if (!candidate.isConnected) overlayCandidates.delete(candidate)
+    }
+  }
+
+  function applyTurns(nextTurns) {
+    const wasAtBottom = shouldFollowConversationScaleBottom(scaleOffset, previousMaximum)
+    const previousList = turns
+    const previousTurns = new Set(previousList)
+    const previousCount = turns.length
+    const previousPrefix = historyPrefix()
+    const turnAtScaleIndex = index => previousList[index - previousPrefix]
+    const cursorTurn = turnAtScaleIndex(cursorIndex)
+    const hoverTurn = turnAtScaleIndex(hoverIndex)
+    const cursorWasHistory = historyAvailable && cursorIndex === 0
+    const hoverWasHistory = historyAvailable && hoverIndex === 0
+    const previewTurn = previousList[previewIndex]
+    const pendingPreviewTurn = previousList[pendingPreviewIndex]
+    const previewWasVisible = previewIndex >= 0
+    const anchorScaleIndex = layout
+      ? nearestVisibleConversationTick(layout, .5)
+      : -1
+    const anchorTurn = turnAtScaleIndex(anchorScaleIndex)
+    const anchorY = layout && anchorScaleIndex >= 0
+      ? layout.start + anchorScaleIndex * CONVERSATION_SCALE_SPACING - scaleOffset
+      : undefined
+    const replaced = previousCount > 0 && nextTurns.length > 0 && !nextTurns.some(turn => previousTurns.has(turn))
+    turns = nextTurns
+    if (replaced || turns.length !== previousCount) geometryDirty = true
+    if (replaced || turns.length > previousCount) cancelJump()
+    followBottom = replaced || previousCount === 0 || (turns.length > previousCount && wasAtBottom)
+    const nextScaleIndex = node => {
+      const index = node ? turns.indexOf(node) : -1
+      return index < 0 ? -1 : turnToScaleIndex(index)
+    }
+    cursorIndex = cursorWasHistory ? 0 : nextScaleIndex(cursorTurn)
+    if (cursorIndex < 0) cursorIndex = Math.max(0, scaleItemCount() - 1)
+    hoverIndex = hoverWasHistory ? 0 : nextScaleIndex(hoverTurn)
+    previewIndex = previewTurn ? turns.indexOf(previewTurn) : -1
+    pendingPreviewIndex = pendingPreviewTurn ? turns.indexOf(pendingPreviewTurn) : -1
+    if (previewWasVisible && previewIndex < 0) hidePreview()
+    if (!followBottom && anchorTurn && Number.isFinite(anchorY)) {
+      const nextAnchor = nextScaleIndex(anchorTurn)
+      if (nextAnchor >= 0) {
+        scaleOffset = Math.max(0, nextAnchor * CONVERSATION_SCALE_SPACING + (layout?.start ?? .5) - anchorY)
+      }
+    }
+    if ((previousCount === 0 || replaced) && turns.length) cursorIndex = scaleItemCount() - 1
+    const empty = scaleItemCount() < MINIMUM_TURNS
+    scale.dataset.prtsScaleCount = String(turns.length)
+    scale.toggleAttribute('data-prts-conversation-scale-partial', historyAvailable)
+    scale.toggleAttribute('data-prts-conversation-scale-empty', empty)
+    scroller.toggleAttribute('data-prts-conversation-scale-empty', empty)
+    syncAccessibility()
+  }
+
+  function syncTurns(mutations = [], full = false) {
+    updateOverlayCandidates(mutations, full)
+    const conversationMutations = mutations.filter(mutation => operation?.contains?.(mutation.target))
+    if (full || !turns.length) {
+      applyTurns(collectConversationTurns(scroller))
+      return
+    }
+    const next = new Set(turns.filter(turn => turn.isConnected && scroller.contains(turn)))
+    const touched = new Set()
+    for (const mutation of conversationMutations) {
+      if (mutation.type === 'attributes') {
+        collectTurnsFromNode(mutation.target, touched)
+        const closest = mutation.target?.closest?.(CONVERSATION_USER_TURN_SELECTOR)
+        if (closest) touched.add(closest)
+      }
+      for (const node of mutation.addedNodes ?? []) collectTurnsFromNode(node, touched)
+      for (const node of mutation.removedNodes ?? []) {
+        if (node?.nodeType !== 1) continue
+        for (const turn of next) {
+          if (turn === node || node.contains?.(turn)) next.delete(turn)
+        }
+      }
+    }
+    for (const turn of touched) {
+      if (isTopLevelTurn(turn)) next.add(turn)
+      else next.delete(turn)
+    }
+    const ordered = [...next].filter(isTopLevelTurn).sort((left, right) => {
+      if (left === right) return 0
+      return follows(left, right) ? -1 : 1
+    })
+    applyTurns(ordered)
+  }
+
+  function representativeContentLeft(operationBox) {
+    if (!geometryDirty) return contentLeft
+    const assistant = scroller.querySelector?.([
+      '[data-prts-ai-surface]:not([hidden])',
+      '[data-chat-flow-kind="assistant-step"]:not([hidden])',
+      '[data-message-role="assistant"]:not([hidden])',
+    ].join(', '))
+    const representatives = [assistant, turns[0], turns.at(-1)].filter(Boolean)
+    const positions = []
+    for (const node of representatives) {
+      if (!visible(node)) continue
+      const style = window?.getComputedStyle?.(node)
+      if (style?.display === 'none' || style?.visibility === 'hidden') continue
+      const box = node.getBoundingClientRect?.()
+      if (!box || box.width <= 0 || box.height <= 0) continue
+      positions.push(box.left - operationBox.left)
+    }
+    contentLeft = positions.length ? Math.min(...positions) : undefined
+    geometryDirty = false
+    return contentLeft
+  }
+
+  function visibleGeometry() {
+    const operationBox = operation.getBoundingClientRect()
+    const scrollerBox = scroller.getBoundingClientRect()
+    const composerBox = composer?.getBoundingClientRect?.()
+    const top = clamp(scrollerBox.top - operationBox.top + 12, 8, Math.max(8, operationBox.height - 92))
+    const bottomEdge = composerBox && composerBox.height > 0 && composerBox.top < operationBox.bottom
+      ? composerBox.top - operationBox.top - 12
+      : Math.min(scrollerBox.bottom, operationBox.bottom) - operationBox.top - 18
+    const height = Math.max(84, bottomEdge - top)
+    const drawerMode = document.documentElement.dataset.prtsDrawerMode
+    const scaleGeometry = drawerMode === 'overlay'
+      ? { visible: false, reason: 'drawer' }
+      : window.innerWidth <= 640
+        ? { visible: false, reason: 'phone' }
+        : resolveConversationScaleGeometry({
+          operationWidth: operationBox.width,
+          contentLeft: representativeContentLeft(operationBox),
+          maximumDistance,
+          previouslyHidden: scaleSpaceObstructed,
+        })
+    const left = Number.isFinite(scaleGeometry.left)
+      ? scaleGeometry.left
+      : CONVERSATION_SCALE_CONTENT_GAP
+    return { operationBox, scrollerBox, composerBox, top, height, left, scaleGeometry }
+  }
+
+  function boxesIntersect(left, right) {
+    return left.right > right.left
+      && left.left < right.right
+      && left.bottom > right.top
+      && left.top < right.bottom
+  }
+
+  function overlayIntersects(candidate, targets) {
+    if (!candidate?.isConnected || candidate.hidden || candidate.getAttribute('aria-hidden') === 'true') return false
+    if (candidate.closest?.('[data-prts-owned-conversation-scale], [data-prts-owned-conversation-preview]')) return false
+    const style = window?.getComputedStyle?.(candidate)
+    if (style?.display === 'none' || style?.visibility === 'hidden' || style?.opacity === '0') return false
+    const box = candidate.getBoundingClientRect?.()
+    if (!box || box.width <= 0 || box.height <= 0) return false
+    return targets.some(target => target?.width > 0 && target?.height > 0 && boxesIntersect(box, target))
+  }
+
+  function blockingOverlay(candidate) {
+    if (candidate?.matches?.(CONVERSATION_BLOCKING_OVERLAY_SELECTOR)) return true
+    const plugin = candidate?.matches?.('[data-plugin]') ? candidate : candidate?.closest?.('[data-plugin]')
+    return Boolean(plugin
+      && plugin.getAttribute('data-plugin') !== 'dsh-theme-prts'
+      && plugin.closest?.('[data-shell-overlay], [data-slot="shell.overlay"]'))
+  }
+
+  function syncScaleInteractiveState() {
+    if (!scale) return true
+    const hidden = scaleSpaceObstructed || scaleBlockingObstructed || scaleObstructed || scaleItemCount() < MINIMUM_TURNS
+    const wasHidden = scale.tabIndex === -1
+    if (hidden && !wasHidden) {
+      hidePreview()
+      pointerInside = false
+      hoverIndex = -1
+      keyboardActive = false
+      retargetWave(-1)
+      scale.tabIndex = -1
+      scale.setAttribute('aria-hidden', 'true')
+      if (document.activeElement === scale) scale.blur?.()
+    } else if (!hidden && wasHidden) {
+      scale.tabIndex = 0
+      scale.removeAttribute('aria-hidden')
+    }
+    syncHistoryHint()
+    return hidden
+  }
+
+  function syncScaleSpaceObstruction(resolution) {
+    const obstructed = !resolution.visible
+    scaleSpaceObstructed = obstructed
+    scale.toggleAttribute('data-prts-conversation-scale-space-obstructed', obstructed)
+    if (obstructed) scale.dataset.prtsScaleHiddenReason = resolution.reason || 'space'
+    else delete scale.dataset.prtsScaleHiddenReason
+    scale.toggleAttribute('data-prts-conversation-scale-centered', Boolean(resolution.centered))
+    syncScaleInteractiveState()
+    return scaleSpaceObstructed || scaleItemCount() < MINIMUM_TURNS
+  }
+
+  function syncScaleObstruction(currentGeometry) {
+    if (!scale) return false
+    obstructionDirty = false
+    if (scaleSpaceObstructed) {
+      scaleBlockingObstructed = false
+      scaleObstructed = false
+      scale.removeAttribute('data-prts-conversation-scale-blocked')
+      scale.removeAttribute('data-prts-conversation-scale-obstructed')
+      syncScaleInteractiveState()
+      return false
+    }
+    const candidates = [...overlayCandidates]
+    const operationBox = currentGeometry?.operationBox
+    const blocked = Boolean(operationBox?.width && operationBox?.height)
+      && candidates.some(candidate => blockingOverlay(candidate) && overlayIntersects(candidate, [operationBox]))
+    const scaleBox = scale.getBoundingClientRect?.()
+    const previewBox = preview?.hasAttribute?.('data-prts-conversation-preview-visible')
+      ? preview.getBoundingClientRect?.()
+      : undefined
+    const historyHintBox = historyHint && !historyHint.hidden
+      ? historyHint.getBoundingClientRect?.()
+      : undefined
+    const historyTooltipBox = scale._prtsHistoryTooltip && !scale._prtsHistoryTooltip.hidden
+      ? scale._prtsHistoryTooltip.getBoundingClientRect?.()
+      : undefined
+    const historyStatusBox = historyStatus && !historyStatus.hidden
+      ? historyStatus.getBoundingClientRect?.()
+      : undefined
+    const localTargets = [scaleBox, previewBox, historyHintBox, historyTooltipBox, historyStatusBox].filter(Boolean)
+    const obstructed = !blocked
+      && localTargets.length > 0
+      && candidates.some(candidate => !blockingOverlay(candidate) && overlayIntersects(candidate, localTargets))
+    scaleBlockingObstructed = blocked
+    scaleObstructed = obstructed
+    scale.toggleAttribute('data-prts-conversation-scale-blocked', blocked)
+    scale.toggleAttribute('data-prts-conversation-scale-obstructed', obstructed)
+    syncScaleInteractiveState()
+    return blocked || obstructed
+  }
+
+  function positionPreview(index) {
+    if (!preview || !layout || !geometry || index < 0 || index >= layout.count) return
+    const scaleIndex = turnToScaleIndex(index)
+    const tickY = clamp(layout.positions[scaleIndex], .5, layout.height - .5)
+    const anchor = geometry.top + tickY
+    const previewBox = preview.getBoundingClientRect?.()
+    const measuredHeight = previewBox?.height || preview.offsetHeight || PREVIEW_FALLBACK_HEIGHT
+    const maximumTop = Math.max(geometry.top, geometry.top + geometry.height - measuredHeight)
+    const top = clamp(anchor - measuredHeight / 2, geometry.top, maximumTop)
+    const left = geometry.left + SCALE_WIDTH + PREVIEW_GAP
+    preview.style.left = `${Number(left.toFixed(2))}px`
+    preview.style.top = `${Number(top.toFixed(2))}px`
+    preview.style.setProperty('--prts-preview-anchor-y', `${Number(clamp(anchor - top, 1, measuredHeight - 1).toFixed(2))}px`)
+  }
+
+  function render() {
+    if (!operation || !scroller || !scale) return
+    geometry = visibleGeometry()
+    scale.style.top = `${Number(geometry.top.toFixed(2))}px`
+    scale.style.left = `${Number(geometry.left.toFixed(2))}px`
+    scale.style.height = `${Number(geometry.height.toFixed(2))}px`
+    historyStatus.style.top = `${Number(geometry.top.toFixed(2))}px`
+    historyStatus.style.left = `${Number((geometry.left + SCALE_WIDTH + PREVIEW_GAP).toFixed(2))}px`
+    scale.dataset.prtsScaleMaxDistance = String(maximumDistance)
+    scale.dataset.prtsScaleFocusContrast = String(focusContrast)
+    syncHistoryStatus()
+    if (syncScaleSpaceObstruction(geometry.scaleGeometry)) return
+    if (obstructionDirty) {
+      if (syncScaleObstruction(geometry)) return
+    } else if (scaleBlockingObstructed || scaleObstructed) {
+      return
+    }
+
+    const provisional = getConversationScaleLayout(scaleItemCount(), geometry.height, scaleOffset)
+    if (followBottom) scaleOffset = provisional.maxOffset
+    layout = getConversationScaleLayout(scaleItemCount(), geometry.height, scaleOffset)
+    scaleOffset = layout.offset
+    previousMaximum = layout.maxOffset
+    followBottom = false
+    const historyY = layout.positions[0] ?? .5
+    historyHint.style.top = `${Number((geometry.top + historyY).toFixed(2))}px`
+    historyHint.style.left = `${Number(geometry.left.toFixed(2))}px`
+    syncHistoryHint()
+    const historyAnchor = geometry.top + historyY
+    const historyTooltipTop = clamp(
+      historyAnchor - PREVIEW_FALLBACK_HEIGHT / 2,
+      geometry.top,
+      Math.max(geometry.top, geometry.top + geometry.height - PREVIEW_FALLBACK_HEIGHT),
+    )
+    const historyTooltip = scale._prtsHistoryTooltip
+    historyTooltip.style.setProperty('--prts-history-tooltip-top', `${Number((historyTooltipTop - historyAnchor + HISTORY_TRIGGER_HEIGHT / 2).toFixed(2))}px`)
+    historyTooltip.style.setProperty('--prts-history-tooltip-anchor-y', `${Number(clamp(historyAnchor - historyTooltipTop, 1, PREVIEW_FALLBACK_HEIGHT - 1).toFixed(2))}px`)
+
+    const interactionIndex = hoverIndex >= 0
+      ? hoverIndex
+      : keyboardActive && scale.matches(':focus') ? cursorIndex : -1
+    const paths = buildConversationScalePaths(layout, interactionIndex, {
+      center: waveCenter,
+      intensity: waveIntensity,
+      historyAvailable,
+    }, scaleLengths)
+    scale._prtsSvg.setAttribute('viewBox', `0 0 ${SCALE_WIDTH} ${layout.height}`)
+    scale._prtsGray.setAttribute('d', paths.gray)
+    scale._prtsAccent.setAttribute('d', paths.yellow)
+    scale._prtsHistory.setAttribute('d', paths.history)
+    scale._prtsHit.setAttribute('height', String(layout.height))
+    scale._prtsMask.setAttribute('height', String(layout.height))
+    scale._prtsMaskRect.setAttribute('height', String(layout.height))
+    if (scaleOffset > 0) {
+      scale._prtsMarks.setAttribute('mask', `url(#${scale._prtsMaskId})`)
+      scale.setAttribute('data-prts-conversation-scale-top-fade', '')
+    } else {
+      scale._prtsMarks.removeAttribute('mask')
+      scale.removeAttribute('data-prts-conversation-scale-top-fade')
+    }
+    scale.dataset.prtsScaleCount = String(turns.length)
+    scale.toggleAttribute('data-prts-conversation-scale-partial', historyAvailable)
+    scale.dataset.prtsScaleOffset = String(Number(scaleOffset.toFixed(2)))
+    scale.dataset.prtsScaleMaximum = String(Number(layout.maxOffset.toFixed(2)))
+    if (interactionIndex >= 0) scale.dataset.prtsScaleWave = String(interactionIndex + 1)
+    else delete scale.dataset.prtsScaleWave
+    if (previewIndex >= 0) positionPreview(previewIndex)
+    syncAccessibility()
+  }
+
+  function syncAccessibility() {
+    if (!scale) return
+    const maximum = Math.max(1, scaleItemCount())
+    const current = clamp(cursorIndex + 1, 1, maximum)
+    scale.setAttribute('aria-valuemin', '1')
+    scale.setAttribute('aria-valuemax', String(maximum))
+    scale.setAttribute('aria-valuenow', String(current))
+    scale.setAttribute(
+      'aria-valuetext',
+      historyAvailable && cursorIndex === 0
+        ? '更早内容尚未载入，按回车前往会话开头'
+        : turns.length
+          ? `当前已载入第 ${scaleToTurnIndex(cursorIndex) + 1} 轮，共 ${turns.length} 轮${historyAvailable ? '，前方仍有更早内容' : ''}`
+          : '无可用会话刻度',
+    )
+  }
+
+  function flush() {
+    frame = undefined
+    if (!started || failed) return
+    try {
+      if (!resolveRoots()) return
+      readHistoryState()
+      if (scanPending) {
+        scanPending = false
+        const mutations = pendingMutations
+        const full = fullScanPending
+        pendingMutations = []
+        fullScanPending = false
+        syncTurns(mutations, full)
+      }
+      render()
+    } catch {
+      failed = true
+      disconnectRoots()
+    }
+  }
+
+  function localIndex(event) {
+    if (!layout || scaleItemCount() < MINIMUM_TURNS) return -1
+    const box = scale.getBoundingClientRect()
+    return nearestVisibleConversationTick(layout, event.clientY - box.top)
+  }
+
+  function ensureVisible(index) {
+    if (!layout || index < 0) return
+    const target = layout.start + index * CONVERSATION_SCALE_SPACING - scaleOffset
+    if (target < .5) scaleOffset += target - .5
+    else if (target > layout.height - .5) scaleOffset += target - (layout.height - .5)
+    scaleOffset = clamp(scaleOffset, 0, layout.maxOffset)
+  }
+
+  function animatePreviewContent() {
+    if (reducedMotion() || typeof preview?._prtsBody?.animate !== 'function') return
+    preview._prtsBody.animate([
+      { opacity: .28 },
+      { opacity: 1 },
+    ], { duration: 70, easing: 'ease-out' })
+  }
+
+  function updatePreviewContent(index, animate = false) {
+    if (!preview || index < 0 || index >= turns.length) return
+    const content = getConversationTurnPreview(scroller, turns, index)
+    const changed = preview._prtsQuestion.textContent !== content.question
+      || preview._prtsAnswer.textContent !== content.answer
+    preview._prtsQuestion.textContent = content.question
+    preview._prtsAnswer.textContent = content.answer
+    preview.dataset.prtsPreviewState = content.state
+    preview.dataset.prtsPreviewTurn = String(index + 1)
+    observePreviewSource(content.answerSource)
+    if (changed && animate && preview.hasAttribute('data-prts-conversation-preview-visible')) animatePreviewContent()
+  }
+
+  function showPreview(index, { animate = true, temporary = false } = {}) {
+    if (!preview || index < 0 || index >= turns.length) return
+    if (previewDelayTimer !== undefined) window?.clearTimeout?.(previewDelayTimer)
+    if (previewHideTimer !== undefined) window?.clearTimeout?.(previewHideTimer)
+    previewDelayTimer = undefined
+    previewHideTimer = undefined
+    pendingPreviewIndex = -1
+    const switched = previewIndex !== index
+    previewIndex = index
+    updatePreviewContent(index, animate && switched)
+    preview.setAttribute('data-prts-conversation-preview-visible', '')
+    preview.setAttribute('aria-hidden', 'false')
+    scale?.setAttribute('aria-describedby', preview.id)
+    positionPreview(index)
+    if (temporary) {
+      previewHideTimer = window?.setTimeout?.(() => {
+        previewHideTimer = undefined
+        hidePreview()
+      }, PREVIEW_TOUCH_DURATION)
+    }
+  }
+
+  function queuePreview(index) {
+    if (index < 0 || index >= turns.length) return
+    if (preview?.hasAttribute('data-prts-conversation-preview-visible')) {
+      showPreview(index)
+      return
+    }
+    if (pendingPreviewIndex === index && previewDelayTimer !== undefined) return
+    if (previewDelayTimer !== undefined) window?.clearTimeout?.(previewDelayTimer)
+    pendingPreviewIndex = index
+    previewDelayTimer = window?.setTimeout?.(() => {
+      previewDelayTimer = undefined
+      const pending = pendingPreviewIndex
+      pendingPreviewIndex = -1
+      if (pointerInside && scaleToTurnIndex(hoverIndex) === pending) showPreview(pending)
+    }, PREVIEW_DELAY)
+  }
+
+  function hidePreview() {
+    if (previewDelayTimer !== undefined) window?.clearTimeout?.(previewDelayTimer)
+    if (previewHideTimer !== undefined) window?.clearTimeout?.(previewHideTimer)
+    if (previewRefreshTimer !== undefined) window?.clearTimeout?.(previewRefreshTimer)
+    previewDelayTimer = undefined
+    previewHideTimer = undefined
+    previewRefreshTimer = undefined
+    pendingPreviewIndex = -1
+    previewIndex = -1
+    disconnectPreviewObserver()
+    preview?.removeAttribute('data-prts-conversation-preview-visible')
+    preview?.setAttribute('aria-hidden', 'true')
+    scale?.removeAttribute('aria-describedby')
+  }
+
+  function queuePreviewRefresh() {
+    if (previewIndex < 0 || previewRefreshTimer !== undefined) return
+    previewRefreshTimer = window?.setTimeout?.(() => {
+      previewRefreshTimer = undefined
+      if (previewIndex >= 0) {
+        updatePreviewContent(previewIndex, true)
+        positionPreview(previewIndex)
+      }
+    }, PREVIEW_REFRESH_INTERVAL)
+  }
+
+  function wait(milliseconds) {
+    return new Promise(resolve => window?.setTimeout?.(resolve, milliseconds))
+  }
+
+  async function waitForHistoryPage(request, before, deadline) {
+    let sawLoading = false
+    while (Date.now() < deadline) {
+      await wait(40)
+      if (request !== historyRequest) return 'cancelled'
+      const state = readHistoryState()
+      sawLoading ||= state.loading || Boolean(state.olderButton?.disabled)
+      const firstTurn = collectConversationTurns(scroller)[0]
+      const progressed = historyMutationRevision > before.revision
+        && (firstTurn !== before.firstTurn || !state.loading)
+      if (!state.hasMore && !state.olderButton && !state.loading) return 'complete'
+      if (progressed && !state.loading && !state.olderButton?.disabled) return 'progress'
+      if (sawLoading && !state.loading && !state.olderButton?.disabled) return 'progress'
+    }
+    return 'timeout'
+  }
+
+  async function loadHistoryToStart() {
+    if (!operation || !scroller || historyPhase === 'loading') return
+    const initial = readHistoryState()
+    if (!historyAvailable) {
+      if (turns[0]) jump(0)
+      return
+    }
+    const request = historyRequest + 1
+    historyRequest = request
+    const startedAt = Date.now()
+    const sessionKey = initial.key
+    let loadedThisRun = 0
+    historyPhase = 'loading'
+    historyMessage = ''
+    hidePreview()
+    syncHistoryStatus()
+    schedule()
+
+    while (loadedThisRun < CONVERSATION_HISTORY_PAGE_LIMIT
+      && Date.now() - startedAt < CONVERSATION_HISTORY_TIME_LIMIT) {
+      if (request !== historyRequest) return
+      const state = readHistoryState()
+      if (sessionKey !== undefined && state.key !== undefined && state.key !== sessionKey) {
+        cancelHistory({ paused: false })
+        return
+      }
+      if (!state.hasMore && !state.olderButton && !state.loading) {
+        setHistoryAvailable(false)
+        historyPhase = 'idle'
+        syncTurns([], true)
+        schedule()
+        if (turns[0]) jump(0)
+        return
+      }
+      if (state.loading || state.olderButton?.disabled) {
+        const result = await waitForHistoryPage(
+          request,
+          {
+            firstTurn: collectConversationTurns(scroller)[0],
+            revision: historyMutationRevision,
+          },
+          Math.min(startedAt + CONVERSATION_HISTORY_TIME_LIMIT, Date.now() + HISTORY_PAGE_SETTLE_LIMIT),
+        )
+        if (result === 'cancelled') return
+        if (result === 'timeout') {
+          historyPhase = 'error'
+          historyMessage = '载入超时，可继续重试'
+          break
+        }
+        historyPages += 1
+        loadedThisRun += 1
+        syncTurns([], true)
+        syncHistoryStatus()
+        schedule()
+        continue
+      }
+      if (!state.olderButton) {
+        const availableDeadline = Math.min(startedAt + CONVERSATION_HISTORY_TIME_LIMIT, Date.now() + 600)
+        while (request === historyRequest && Date.now() < availableDeadline && !findConversationOlderButton(operation)) {
+          await wait(40)
+        }
+      }
+      const button = findConversationOlderButton(operation)
+      if (!button || button.disabled) {
+        historyPhase = 'error'
+        historyMessage = '暂时无法载入更早内容'
+        break
+      }
+      const before = {
+        firstTurn: collectConversationTurns(scroller)[0],
+        revision: historyMutationRevision,
+      }
+      button.click()
+      const result = await waitForHistoryPage(
+        request,
+        before,
+        Math.min(startedAt + CONVERSATION_HISTORY_TIME_LIMIT, Date.now() + HISTORY_PAGE_SETTLE_LIMIT),
+      )
+      if (result === 'cancelled') return
+      if (result === 'timeout') {
+        historyPhase = 'error'
+        historyMessage = '载入超时，可继续重试'
+        break
+      }
+      historyPages += 1
+      loadedThisRun += 1
+      syncTurns([], true)
+      syncHistoryStatus()
+      schedule()
+    }
+
+    if (request !== historyRequest) return
+    const finalState = readHistoryState()
+    if (!finalState.hasMore && !finalState.olderButton && !finalState.loading) {
+      setHistoryAvailable(false)
+      historyPhase = 'idle'
+      syncTurns([], true)
+      if (turns[0]) jump(0)
+    } else if (historyPhase === 'loading') {
+      historyPhase = 'paused'
+    }
+    syncHistoryStatus()
+    schedule()
+  }
+
+  function jump(index) {
+    const turn = turns[index]
+    if (!turn || !scroller || !operation) return
+    const jumpScroller = scroller
+    const jumpOperation = operation
+    const jumpComposer = composer
+    const request = jumpRequest + 1
+    jumpRequest = request
+    const getTargetTop = () => {
+      if (!turn.isConnected || scroller !== jumpScroller || operation !== jumpOperation) return Number.NaN
+      const operationBox = jumpOperation.getBoundingClientRect()
+      const scrollerBox = jumpScroller.getBoundingClientRect()
+      const composerBox = jumpComposer?.getBoundingClientRect?.()
+      const visibleTop = Math.max(scrollerBox.top, operationBox.top)
+      const visibleBottom = Math.min(scrollerBox.bottom, operationBox.bottom, composerBox?.top ?? operationBox.bottom)
+      return calculateConversationJumpTop({
+        scrollTop: jumpScroller.scrollTop,
+        scrollHeight: jumpScroller.scrollHeight,
+        clientHeight: jumpScroller.clientHeight,
+        turnTop: turn.getBoundingClientRect().top,
+        visibleTop,
+        visibleHeight: Math.max(0, visibleBottom - visibleTop),
+      })
+    }
+    void performConversationJump({
+      scroller: jumpScroller,
+      getTargetTop,
+      prefersReducedMotion: reducedMotion(),
+      requestFrame,
+      now: () => currentTime(),
+      cancelled: () => request !== jumpRequest,
+      onFrame: schedule,
+    }).catch(() => {
+      if (request === jumpRequest) cancelJump()
+    })
+    cursorIndex = turnToScaleIndex(index)
+    syncAccessibility()
+  }
+
+  function showScalePreview(index, options) {
+    const turnIndex = scaleToTurnIndex(index)
+    if (turnIndex < 0) {
+      hidePreview()
+      return
+    }
+    showPreview(turnIndex, options)
+  }
+
+  function queueScalePreview(index) {
+    const turnIndex = scaleToTurnIndex(index)
+    if (turnIndex < 0) {
+      hidePreview()
+      return
+    }
+    queuePreview(turnIndex)
+  }
+
+  function activateScaleIndex(index, options) {
+    if (historyAvailable && index === 0) {
+      hidePreview()
+      void loadHistoryToStart()
+      return
+    }
+    const turnIndex = scaleToTurnIndex(index)
+    if (turnIndex < 0) return
+    showPreview(turnIndex, options)
+    jump(turnIndex)
+  }
+
+  function showWave(index, temporary = false) {
+    if (index < 0) return
+    hoverIndex = index
+    cursorIndex = index
+    ensureVisible(index)
+    retargetWave(index)
+    if (touchTimer !== undefined) window?.clearTimeout?.(touchTimer)
+    if (temporary) {
+      touchTimer = window?.setTimeout?.(() => {
+        touchTimer = undefined
+        hoverIndex = -1
+        retargetWave(-1)
+        schedule()
+      }, TOUCH_WAVE_DURATION)
+    }
+    schedule()
+  }
+
+  function onPointerMove(event) {
+    if (event.pointerType === 'touch') return
+    pointerInside = true
+    keyboardActive = false
+    const index = localIndex(event)
+    if (index === hoverIndex) return
+    showWave(index)
+    queueScalePreview(index)
+  }
+
+  function onPointerLeave(event) {
+    if (event.pointerType === 'touch') return
+    pointerInside = false
+    hoverIndex = -1
+    retargetWave(-1)
+    hidePreview()
+    schedule()
+  }
+
+  function onPointerDown(event) {
+    cancelNavigation()
+    if (event.pointerType !== 'touch' && event.pointerType !== 'pen') return
+    pointerInside = true
+    pointerStart = { x: event.clientX, y: event.clientY, id: event.pointerId }
+    scale.setPointerCapture?.(event.pointerId)
+    event.preventDefault()
+  }
+
+  function onPointerUp(event) {
+    if (!pointerStart || pointerStart.id !== event.pointerId) return
+    const distance = Math.hypot(event.clientX - pointerStart.x, event.clientY - pointerStart.y)
+    pointerStart = undefined
+    if (event.pointerType === 'touch') pointerInside = false
+    scale.releasePointerCapture?.(event.pointerId)
+    if (distance > 8) return
+    const index = localIndex(event)
+    if (index < 0) return
+    lastDirectJump = Date.now()
+    keyboardActive = false
+    showWave(index, true)
+    activateScaleIndex(index, { temporary: true })
+    scale.focus({ preventScroll: true })
+    event.preventDefault()
+  }
+
+  function onPointerCancel(event) {
+    if (pointerStart?.id === event.pointerId) {
+      pointerStart = undefined
+      if (event.pointerType === 'touch') pointerInside = false
+    }
+  }
+
+  function onClick(event) {
+    if (Date.now() - lastDirectJump < 300) return
+    keyboardActive = false
+    const index = localIndex(event)
+    if (index < 0) return
+    showWave(index)
+    activateScaleIndex(index)
+    scale.focus({ preventScroll: true })
+  }
+
+  function queueSnap() {
+    if (snapTimer !== undefined) window?.clearTimeout?.(snapTimer)
+    snapTimer = window?.setTimeout?.(() => {
+      snapTimer = undefined
+      if (!layout) return
+      scaleOffset = snapConversationScaleOffset(scaleOffset, layout.maxOffset)
+      schedule()
+    }, SNAP_DELAY)
+  }
+
+  function onWheel(event) {
+    cancelNavigation()
+    event.preventDefault()
+    event.stopPropagation()
+    hidePreview()
+    if (!layout || layout.maxOffset <= 0) return
+    const factor = event.deltaMode === 1 ? CONVERSATION_SCALE_SPACING : event.deltaMode === 2 ? layout.height : 1
+    scaleOffset = clamp(scaleOffset + event.deltaY * factor, 0, layout.maxOffset)
+    keyboardActive = false
+    hoverIndex = -1
+    retargetWave(-1)
+    schedule()
+    queueSnap()
+  }
+
+  function page(direction) {
+    if (!layout) return
+    const distance = Math.max(CONVERSATION_SCALE_SPACING, Math.floor(layout.height / CONVERSATION_SCALE_SPACING) * CONVERSATION_SCALE_SPACING)
+    scaleOffset = clamp(scaleOffset + direction * distance, 0, layout.maxOffset)
+    const edgeY = direction < 0 ? .5 : layout.height - .5
+    const nextLayout = getConversationScaleLayout(scaleItemCount(), layout.height, scaleOffset)
+    cursorIndex = nearestVisibleConversationTick(nextLayout, edgeY)
+    hoverIndex = cursorIndex
+    retargetWave(cursorIndex)
+    showScalePreview(cursorIndex)
+    schedule()
+  }
+
+  function onKeydown(event) {
+    if (scaleItemCount() < MINIMUM_TURNS) return
+    if (event.key === 'Escape' && historyPhase === 'loading') {
+      cancelHistory()
+      event.preventDefault()
+      return
+    }
+    if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
+      keyboardActive = true
+      cursorIndex = clamp(cursorIndex + (event.key === 'ArrowUp' ? -1 : 1), 0, scaleItemCount() - 1)
+      hoverIndex = cursorIndex
+      ensureVisible(cursorIndex)
+      showScalePreview(cursorIndex)
+    } else if (event.key === 'Home' || event.key === 'End') {
+      keyboardActive = true
+      cursorIndex = event.key === 'Home' ? 0 : scaleItemCount() - 1
+      hoverIndex = cursorIndex
+      ensureVisible(cursorIndex)
+      showScalePreview(cursorIndex)
+    } else if (event.key === 'PageUp' || event.key === 'PageDown') {
+      keyboardActive = true
+      page(event.key === 'PageUp' ? -1 : 1)
+      event.preventDefault()
+      return
+    } else if (event.key === 'Enter' || event.key === ' ') {
+      event.preventDefault()
+      activateScaleIndex(cursorIndex)
+      return
+    } else return
+    event.preventDefault()
+    retargetWave(cursorIndex)
+    schedule()
+  }
+
+  function onFocus() {
+    ensureVisible(cursorIndex)
+    schedule()
+  }
+
+  function onBlur() {
+    keyboardActive = false
+    hoverIndex = -1
+    retargetWave(-1)
+    if (!pointerInside) hidePreview()
+    schedule()
+  }
+
+  return {
+    getCalibrationState(candidate = maximumDistance) {
+      if (!started || failed || (!operation && !resolveRoots())) {
+        const fallback = resolveConversationScaleCalibrationState({
+          maximumDistance: candidate,
+          viewportWidth: window?.innerWidth,
+        })
+        return { ...fallback, simulated: true }
+      }
+      const cachedOperationBox = geometry?.operationBox
+      const operationBox = cachedOperationBox ?? operation.getBoundingClientRect?.()
+      const cachedContentLeft = Number.isFinite(contentLeft) ? contentLeft : undefined
+      return resolveConversationScaleCalibrationState({
+        operationWidth: operationBox?.width,
+        contentLeft: cachedContentLeft ?? representativeContentLeft(operationBox),
+        maximumDistance: candidate,
+        turnCount: turns.length,
+        drawerMode: document.documentElement.dataset.prtsDrawerMode,
+        viewportWidth: window?.innerWidth,
+        previouslyHidden: scaleSpaceObstructed,
+      })
+    },
+    update(nextPreferences = {}) {
+      const distanceNumeric = Number(nextPreferences.conversationScaleMaxDistance)
+      const nextDistance = Number.isFinite(distanceNumeric)
+        ? clamp(Math.round(distanceNumeric / 8) * 8, 16, 240)
+        : CONVERSATION_SCALE_DEFAULT_MAX_DISTANCE
+      const contrastNumeric = Number(nextPreferences.conversationScaleFocusContrast)
+      const nextContrast = Number.isFinite(contrastNumeric)
+        ? clamp(Math.round(contrastNumeric / 10) * 10, 0, 100)
+        : CONVERSATION_SCALE_FOCUS_CONTRAST_DEFAULT
+      if (nextDistance === maximumDistance && nextContrast === focusContrast) return
+      maximumDistance = nextDistance
+      if (nextContrast !== focusContrast) {
+        focusContrast = nextContrast
+        scaleLengths = resolveConversationScaleLengths(focusContrast)
+      }
+      schedule()
+    },
+    start() {
+      if (started || !document) return
+      started = true
+      failed = false
+      const ResizeObserver = window?.ResizeObserver
+      if (typeof ResizeObserver === 'function') {
+        resizeObserver = new ResizeObserver((entries = []) => {
+          geometryDirty = true
+          const operationEntry = entries.find(entry => entry.target === operation)
+          const width = Number(operationEntry?.contentRect?.width)
+          const height = Number(operationEntry?.contentRect?.height)
+          const operationChanged = !entries.length || Boolean(operationEntry) && (
+            !Number.isFinite(width)
+            || !Number.isFinite(height)
+            || width !== observedOperationWidth
+            || height !== observedOperationHeight
+          )
+          if (operationEntry) {
+            if (Number.isFinite(width)) observedOperationWidth = width
+            if (Number.isFinite(height)) observedOperationHeight = height
+          }
+          if (!operationChanged) {
+            schedule()
+            return
+          }
+          if (!resizeActive) {
+            setScaleResizeState(true)
+            if (frame !== undefined) {
+              if (window?.cancelAnimationFrame) window.cancelAnimationFrame(frame)
+              else window?.clearTimeout?.(frame)
+              frame = undefined
+            }
+          }
+          if (resizeSettleTimer !== undefined) window?.clearTimeout?.(resizeSettleTimer)
+          resizeSettleTimer = window?.setTimeout?.(() => {
+            resizeSettleTimer = undefined
+            obstructionDirty = true
+            setScaleResizeState(false)
+            schedule()
+          }, 160)
+        })
+      }
+      const MutationObserver = window?.MutationObserver
+      if (typeof MutationObserver === 'function' && document.body) {
+        mutationObserver = new MutationObserver(mutations => {
+          const external = mutations.filter(mutation =>
+            !mutation.target?.closest?.('[data-prts-conversation-scale], [data-prts-conversation-preview], [data-prts-conversation-history-hint], [data-prts-conversation-history-status]')
+          )
+          const historyRelevant = external.some(mutation =>
+            mutation.type === 'childList'
+              && operation?.contains?.(mutation.target)
+              && ((mutation.addedNodes?.length ?? 0) > 0 || (mutation.removedNodes?.length ?? 0) > 0)
+          )
+          if (historyRelevant) historyMutationRevision += 1
+          const relevant = external.filter(mutation =>
+            mutationAffectsTurns(mutation) || mutationAffectsOverlay(mutation)
+          )
+          if (relevant.some(mutationAffectsOverlay)) obstructionDirty = true
+          if (!relevant.length && !historyRelevant) return
+          if (previewIndex >= 0) queuePreviewRefresh()
+          pendingMutations.push(...relevant)
+          scanPending ||= relevant.length > 0
+          schedule()
+        })
+        mutationObserver.observe(document.body, {
+          subtree: true,
+          childList: true,
+          attributes: true,
+          attributeFilter: [
+            'data-chat-flow-kind',
+            'data-message-role',
+            'data-prts-floating-glass',
+            'hidden',
+            'aria-hidden',
+            'aria-modal',
+            'role',
+            'open',
+            'popover',
+            'class',
+            'data-slot',
+            'data-plugin',
+            'style',
+          ],
+        })
+      }
+      schedule(true)
+    },
+    dispose() {
+      started = false
+      failed = false
+      mutationObserver?.disconnect()
+      mutationObserver = undefined
+      resizeObserver?.disconnect()
+      resizeObserver = undefined
+      disconnectPreviewObserver()
+      if (frame !== undefined) {
+        if (window?.cancelAnimationFrame) window.cancelAnimationFrame(frame)
+        else window?.clearTimeout?.(frame)
+      }
+      frame = undefined
+      scanPending = false
+      fullScanPending = false
+      pendingMutations = []
+      overlayCandidates.clear()
+      overlayScanPending = false
+      scaleObstructed = false
+      scaleBlockingObstructed = false
+      scaleSpaceObstructed = true
+      contentLeft = undefined
+      geometryDirty = true
+      clearTimers()
+      setScaleResizeState(false)
+      disconnectRoots()
+    },
+  }
+}