nastech-tui 0.0.1

package/src/__tests__/viewport.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+
+import { stickyPromptFromViewport } from '../domain/viewport.js'
+
+describe('stickyPromptFromViewport', () => {
+  it('hides the sticky prompt when a newer user message is already visible', () => {
+    const messages = [
+      { role: 'user' as const, text: 'older prompt' },
+      { role: 'assistant' as const, text: 'older answer' },
+      { role: 'user' as const, text: 'current prompt' },
+      { role: 'assistant' as const, text: 'current answer' }
+    ]
+
+    const offsets = [0, 2, 10, 12, 20]
+
+    expect(stickyPromptFromViewport(messages, offsets, 8, 16, false)).toBe('')
+  })
+
+  it('shows the latest user message above the viewport when no user message is visible', () => {
+    const messages = [
+      { role: 'user' as const, text: 'older prompt' },
+      { role: 'assistant' as const, text: 'older answer' },
+      { role: 'user' as const, text: 'current prompt' },
+      { role: 'assistant' as const, text: 'current answer' }
+    ]
+
+    const offsets = [0, 2, 10, 12, 20]
+
+    expect(stickyPromptFromViewport(messages, offsets, 16, 20, false)).toBe('current prompt')
+  })
+
+  it('shows the last prompt once the viewport starts after the history tail', () => {
+    const messages = [
+      { role: 'user' as const, text: 'current prompt' },
+      { role: 'assistant' as const, text: 'completed answer' }
+    ]
+
+    expect(stickyPromptFromViewport(messages, [0, 2, 5], 8, 14, false)).toBe('current prompt')
+  })
+
+  it('shows a prompt as soon as its full row is above the viewport', () => {
+    const messages = [
+      { role: 'user' as const, text: 'current prompt' },
+      { role: 'assistant' as const, text: 'current answer' }
+    ]
+
+    expect(stickyPromptFromViewport(messages, [0, 2, 10], 2, 8, false)).toBe('current prompt')
+  })
+
+  it('hides the sticky prompt at the bottom', () => {
+    const messages = [
+      { role: 'user' as const, text: 'current prompt' },
+      { role: 'assistant' as const, text: 'current answer' }
+    ]
+
+    expect(stickyPromptFromViewport(messages, [0, 2, 10], 8, 10, true)).toBe('')
+  })
+})

package/src/__tests__/viewportStore.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest'
+
+import { getScrollbarSnapshot, getViewportSnapshot, scrollbarSnapshotKey, viewportSnapshotKey } from '../lib/viewportStore.js'
+
+describe('viewportStore', () => {
+  it('normalizes absent scroll handles', () => {
+    expect(getViewportSnapshot(null)).toEqual({
+      atBottom: true,
+      bottom: 0,
+      pending: 0,
+      scrollHeight: 0,
+      top: 0,
+      viewportHeight: 0
+    })
+  })
+
+  it('includes pending scroll delta in snapshot math and keying', () => {
+    const handle = {
+      getPendingDelta: () => 3,
+      getScrollHeight: () => 40,
+      getScrollTop: () => 10,
+      getViewportHeight: () => 5,
+      isSticky: () => false
+    }
+
+    const snap = getViewportSnapshot(handle as any)
+
+    expect(snap).toMatchObject({
+      atBottom: false,
+      bottom: 18,
+      pending: 3,
+      scrollHeight: 40,
+      top: 13,
+      viewportHeight: 5
+    })
+    expect(viewportSnapshotKey(snap)).toBe('0:16:5:40:3')
+  })
+
+  it('uses fresh scroll height to clear stale non-bottom state', () => {
+    const handle = {
+      getFreshScrollHeight: () => 20,
+      getPendingDelta: () => 0,
+      getScrollHeight: () => 40,
+      getScrollTop: () => 15,
+      getViewportHeight: () => 5,
+      isSticky: () => false
+    }
+
+    const snap = getViewportSnapshot(handle as any)
+
+    expect(snap.atBottom).toBe(true)
+    expect(snap.scrollHeight).toBe(20)
+  })
+
+  it('keeps scrollbar position tied to committed scrollTop, not pending target', () => {
+    const handle = {
+      getPendingDelta: () => 24,
+      getScrollHeight: () => 100,
+      getScrollTop: () => 10,
+      getViewportHeight: () => 20,
+      isSticky: () => false
+    }
+
+    const viewport = getViewportSnapshot(handle as any)
+    const scrollbar = getScrollbarSnapshot(handle as any)
+
+    expect(viewport.top).toBe(34)
+    expect(scrollbar).toEqual({
+      scrollHeight: 100,
+      top: 10,
+      viewportHeight: 20
+    })
+    expect(scrollbarSnapshotKey(scrollbar)).toBe('10:20:100')
+  })
+
+  it('clamps scrollbar position to committed scroll bounds', () => {
+    const handle = {
+      getScrollHeight: () => 30,
+      getScrollTop: () => 50,
+      getViewportHeight: () => 20
+    }
+
+    expect(getScrollbarSnapshot(handle as any).top).toBe(10)
+  })
+})

package/src/__tests__/virtualHeights.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest'
+
+import { estimatedMsgHeight, messageHeightKey, wrappedLines } from '../lib/virtualHeights.js'
+import type { Msg } from '../types.js'
+
+describe('virtual height estimates', () => {
+  it('uses stable content keys across resumed message objects', () => {
+    const msg: Msg = { role: 'assistant', text: 'same text', tools: ['Search Files [long message]'] }
+
+    expect(messageHeightKey(msg)).toBe(messageHeightKey({ ...msg }))
+  })
+
+  it('accounts for wrapping and preserved blank-block rhythm', () => {
+    const msg: Msg = { role: 'assistant', text: `one\n\n${'x'.repeat(90)}` }
+
+    expect(wrappedLines(msg.text, 30)).toBe(5)
+    expect(estimatedMsgHeight(msg, 35, { compact: false, details: false })).toBeGreaterThan(5)
+  })
+
+  it('uses compound user prompt width when estimating user message wrapping', () => {
+    const msg: Msg = { role: 'user', text: 'x'.repeat(21) }
+
+    expect(estimatedMsgHeight(msg, 26, { compact: false, details: false, userPrompt: '❯' })).toBe(3)
+    expect(estimatedMsgHeight(msg, 26, { compact: false, details: false, userPrompt: 'Ψ >' })).toBe(4)
+  })
+
+  it('includes detail sections when visible', () => {
+    const msg: Msg = { role: 'assistant', text: 'ok', thinking: 'line 1\nline 2', tools: ['Tool A', 'Tool B'] }
+
+    expect(estimatedMsgHeight(msg, 80, { compact: false, details: true })).toBeGreaterThan(
+      estimatedMsgHeight(msg, 80, { compact: false, details: false })
+    )
+  })
+
+  it('accounts for the response separator when assistant details are visible', () => {
+    const msg: Msg = { role: 'assistant', text: 'ok', thinking: 'plan' }
+
+    expect(estimatedMsgHeight(msg, 80, { compact: false, details: true })).toBe(
+      estimatedMsgHeight(msg, 80, { compact: false, details: false }) + 3
+    )
+  })
+
+  it('does not account for a response separator without visible details', () => {
+    const msg: Msg = { role: 'assistant', text: 'ok' }
+
+    expect(estimatedMsgHeight(msg, 80, { compact: false, details: true })).toBe(
+      estimatedMsgHeight(msg, 80, { compact: false, details: false })
+    )
+  })
+
+  it('honors per-section visibility when estimating response separators', () => {
+    const thinkingOnly: Msg = { role: 'assistant', text: 'ok', thinking: 'plan' }
+    const toolsOnly: Msg = { role: 'assistant', text: 'ok', tools: ['Tool A'] }
+
+    expect(
+      estimatedMsgHeight(thinkingOnly, 80, {
+        compact: false,
+        details: true,
+        thinkingVisible: false,
+        toolsVisible: true
+      })
+    ).toBe(estimatedMsgHeight(thinkingOnly, 80, { compact: false, details: false }))
+
+    expect(
+      estimatedMsgHeight(toolsOnly, 80, {
+        compact: false,
+        details: true,
+        thinkingVisible: true,
+        toolsVisible: false
+      })
+    ).toBe(estimatedMsgHeight(toolsOnly, 80, { compact: false, details: false }))
+  })
+
+  it('reserves two extra rows for the inter-turn separator on non-first user messages', () => {
+    const msg: Msg = { role: 'user', text: 'follow-up question' }
+    const base = estimatedMsgHeight(msg, 80, { compact: false, details: false })
+    const withSep = estimatedMsgHeight(msg, 80, { compact: false, details: false, withSeparator: true })
+
+    expect(withSep).toBe(base + 2)
+  })
+
+  it('caps wrapped-line counting so giant assistant turns do not block offset rebuilds', () => {
+    // wrappedLines is invoked once per uncached message during
+    // useVirtualHistory's offset rebuild. Unbounded counting on a long
+    // assistant response (10k+ chars × every row × every rebuild) blocks
+    // the UI on cold mount. Cap is ~800 rows; post-mount Yoga
+    // measurement converges to the true height regardless.
+    const giant = 'x'.repeat(1_000_000)
+    const t0 = performance.now()
+    const rows = wrappedLines(giant, 80)
+    const elapsed = performance.now() - t0
+
+    expect(rows).toBeLessThanOrEqual(800)
+    expect(elapsed).toBeLessThan(50)
+  })
+})

package/src/__tests__/virtualHistoryClamp.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import { shouldSetVirtualClamp } from '../hooks/useVirtualHistory.js'
+
+describe('virtual history clamp bounds', () => {
+  it('does not clamp sticky live tail content', () => {
+    expect(shouldSetVirtualClamp({ itemCount: 20, sticky: true, viewportHeight: 10 })).toBe(false)
+  })
+
+  it('sets clamp bounds after manual scroll breaks sticky mode', () => {
+    expect(shouldSetVirtualClamp({ itemCount: 20, sticky: false, viewportHeight: 10 })).toBe(true)
+  })
+
+  it('does not clamp while a live tail is growing below virtual history', () => {
+    expect(shouldSetVirtualClamp({ itemCount: 20, liveTailActive: true, sticky: false, viewportHeight: 10 })).toBe(
+      false
+    )
+  })
+})

package/src/__tests__/virtualHistoryOffsetCache.test.ts

@@ -0,0 +1,282 @@
+import { PassThrough } from 'stream'
+
+import { Box, renderSync, ScrollBox, type ScrollBoxHandle, Text } from '@nastechai/ink'
+import React, { useLayoutEffect, useRef } from 'react'
+import { describe, expect, it } from 'vitest'
+
+import { useVirtualHistory, virtualHistorySnapshotKey } from '../hooks/useVirtualHistory.js'
+
+interface Item {
+  height: number
+  heightAfterResize?: number
+  key: string
+}
+
+interface Exposed {
+  scroll: ScrollBoxHandle | null
+  virtualHistory: ReturnType<typeof useVirtualHistory>
+}
+
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
+const makeStreams = () => {
+  const stdout = new PassThrough()
+  const stdin = new PassThrough()
+  const stderr = new PassThrough()
+
+  Object.assign(stdout, { columns: 80, isTTY: false, rows: 20 })
+  Object.assign(stdin, { isTTY: false })
+  Object.assign(stderr, { isTTY: false })
+  stdout.on('data', () => {})
+
+  return { stderr, stdin, stdout }
+}
+
+const mountedSpan = (items: readonly Item[], virtualHistory: ReturnType<typeof useVirtualHistory>) => {
+  let height = 0
+
+  for (let index = virtualHistory.start; index < virtualHistory.end; index++) {
+    height += items[index]?.height ?? 0
+  }
+
+  return { bottom: virtualHistory.topSpacer + height, top: virtualHistory.topSpacer }
+}
+
+const viewportIsMounted = (items: readonly Item[], virtualHistory: ReturnType<typeof useVirtualHistory>, scroll: ScrollBoxHandle) => {
+  const span = mountedSpan(items, virtualHistory)
+  const top = scroll.getScrollTop()
+  const bottom = top + scroll.getViewportHeight()
+
+  return top >= span.top && bottom <= span.bottom
+}
+
+const itemHeightForColumns = (item: Item | undefined, columns: number) =>
+  columns >= 80 ? (item?.heightAfterResize ?? item?.height ?? 1) : (item?.height ?? 1)
+
+function Harness({
+  columns = 80,
+  expose,
+  height = 10,
+  items,
+  maxMounted = 16
+}: {
+  columns?: number
+  expose: React.MutableRefObject<Exposed | null>
+  height?: number
+  items: readonly Item[]
+  maxMounted?: number
+}) {
+  const scrollRef = useRef<ScrollBoxHandle | null>(null)
+
+  const virtualHistory = useVirtualHistory(scrollRef, items, columns, {
+    coldStartCount: 16,
+    estimateHeight: index => itemHeightForColumns(items[index], columns),
+    maxMounted,
+    overscan: 2
+  })
+
+  useLayoutEffect(() => {
+    expose.current = { scroll: scrollRef.current, virtualHistory }
+  })
+
+  return React.createElement(
+    ScrollBox,
+    { flexDirection: 'column', height, ref: scrollRef, stickyScroll: true },
+    React.createElement(
+      Box,
+      { flexDirection: 'column', width: '100%' },
+      virtualHistory.topSpacer > 0 ? React.createElement(Box, { height: virtualHistory.topSpacer }) : null,
+      ...items
+        .slice(virtualHistory.start, virtualHistory.end)
+        .map(item =>
+          React.createElement(
+            Box,
+            {
+              height: itemHeightForColumns(item, columns),
+              key: item.key,
+              ref: virtualHistory.measureRef(item.key)
+            },
+            React.createElement(Text, null, item.key)
+          )
+        ),
+      virtualHistory.bottomSpacer > 0 ? React.createElement(Box, { height: virtualHistory.bottomSpacer }) : null
+    )
+  )
+}
+
+describe('useVirtualHistory offset cache reuse', () => {
+  it('includes viewport height in the external-store snapshot key', () => {
+    const base = {
+      getPendingDelta: () => 0,
+      getScrollTop: () => 20,
+      isSticky: () => false
+    }
+
+    const short = virtualHistorySnapshotKey({
+      ...base,
+      getViewportHeight: () => 5
+    } as ScrollBoxHandle)
+
+    const tall = virtualHistorySnapshotKey({
+      ...base,
+      getViewportHeight: () => 25
+    } as ScrollBoxHandle)
+
+    expect(short).not.toBe(tall)
+  })
+
+  it('remounts enough tail rows after the scroll viewport grows', async () => {
+    const items = Array.from({ length: 100 }, (_, index) => ({ height: 1, key: `item-${index}` }))
+    const expose = { current: null as Exposed | null }
+    const streams = makeStreams()
+
+    const instance = renderSync(React.createElement(Harness, { expose, height: 4, items, maxMounted: 80 }), {
+      patchConsole: false,
+      stderr: streams.stderr as NodeJS.WriteStream,
+      stdin: streams.stdin as NodeJS.ReadStream,
+      stdout: streams.stdout as NodeJS.WriteStream
+    })
+
+    try {
+      await delay(20)
+      instance.rerender(React.createElement(Harness, { expose, height: 9, items, maxMounted: 80 }))
+      await delay(80)
+
+      expect(viewportIsMounted(items, expose.current!.virtualHistory, expose.current!.scroll!)).toBe(true)
+    } finally {
+      instance.unmount()
+      instance.cleanup()
+    }
+  })
+
+  it('recomputes tail coverage when wrapped rows shrink after a width resize', async () => {
+    const items = Array.from({ length: 100 }, (_, index) => ({
+      height: 4,
+      heightAfterResize: 1,
+      key: `item-${index}`
+    }))
+
+    const expose = { current: null as Exposed | null }
+    const streams = makeStreams()
+
+    const instance = renderSync(
+      React.createElement(Harness, { columns: 40, expose, height: 10, items, maxMounted: 80 }),
+      {
+        patchConsole: false,
+        stderr: streams.stderr as NodeJS.WriteStream,
+        stdin: streams.stdin as NodeJS.ReadStream,
+        stdout: streams.stdout as NodeJS.WriteStream
+      }
+    )
+
+    try {
+      await delay(20)
+      instance.rerender(React.createElement(Harness, { columns: 80, expose, height: 10, items, maxMounted: 80 }))
+      await delay(80)
+
+      const resizedItems = items.map(item => ({ height: item.heightAfterResize!, key: item.key }))
+
+      expect(viewportIsMounted(resizedItems, expose.current!.virtualHistory, expose.current!.scroll!)).toBe(true)
+    } finally {
+      instance.unmount()
+      instance.cleanup()
+    }
+  })
+
+  it('keeps sticky scroll at the bottom when one tall tail row resizes', async () => {
+    const items = [{ height: 90, heightAfterResize: 50, key: 'tail' }]
+    const expose = { current: null as Exposed | null }
+    const streams = makeStreams()
+
+    const instance = renderSync(
+      React.createElement(Harness, { columns: 70, expose, height: 18, items, maxMounted: 80 }),
+      {
+        patchConsole: false,
+        stderr: streams.stderr as NodeJS.WriteStream,
+        stdin: streams.stdin as NodeJS.ReadStream,
+        stdout: streams.stdout as NodeJS.WriteStream
+      }
+    )
+
+    try {
+      await delay(20)
+      instance.rerender(React.createElement(Harness, { columns: 120, expose, height: 36, items, maxMounted: 80 }))
+      await delay(80)
+
+      const scroll = expose.current!.scroll!
+
+      expect(scroll.getScrollTop()).toBe(scroll.getScrollHeight() - scroll.getViewportHeight())
+    } finally {
+      instance.unmount()
+      instance.cleanup()
+    }
+  })
+
+  it('recomputes offsets after a mounted row height changes', async () => {
+    const tall = [
+      { height: 6, key: 'a' },
+      { height: 6, key: 'b' },
+      { height: 6, key: 'c' }
+    ]
+
+    const short = tall.map(item => ({ ...item, height: 2 }))
+    const expose = { current: null as Exposed | null }
+    const streams = makeStreams()
+
+    const instance = renderSync(React.createElement(Harness, { expose, items: tall }), {
+      patchConsole: false,
+      stderr: streams.stderr as NodeJS.WriteStream,
+      stdin: streams.stdin as NodeJS.ReadStream,
+      stdout: streams.stdout as NodeJS.WriteStream
+    })
+
+    try {
+      await delay(20)
+      expect(expose.current!.virtualHistory.offsets[tall.length]).toBe(18)
+
+      instance.rerender(React.createElement(Harness, { expose, items: short }))
+      await delay(40)
+
+      expect(expose.current!.virtualHistory.offsets[short.length]).toBe(6)
+      expect(expose.current!.virtualHistory.bottomSpacer).toBe(0)
+    } finally {
+      instance.unmount()
+      instance.cleanup()
+    }
+  })
+
+  it('ignores stale reused offset-array entries after the item count shrinks', async () => {
+    const beforeShrink = Array.from({ length: 1400 }, (_, index) => ({ height: 1, key: `old${index}` }))
+    const afterShrink = Array.from({ length: 800 }, (_, index) => ({ height: 7, key: `new${index}` }))
+    const expose = { current: null as Exposed | null }
+    const streams = makeStreams()
+
+    const instance = renderSync(React.createElement(Harness, { expose, items: beforeShrink }), {
+      patchConsole: false,
+      stderr: streams.stderr as NodeJS.WriteStream,
+      stdin: streams.stdin as NodeJS.ReadStream,
+      stdout: streams.stdout as NodeJS.WriteStream
+    })
+
+    try {
+      await delay(20)
+      instance.rerender(React.createElement(Harness, { expose, items: afterShrink }))
+      await delay(20)
+
+      const scroll = expose.current!.scroll!
+      const transcriptHeight = expose.current!.virtualHistory.offsets[afterShrink.length] ?? 0
+
+      expect(transcriptHeight).toBe(5600)
+      expect(scroll.getScrollTop()).toBe(transcriptHeight - scroll.getViewportHeight())
+
+      scroll.scrollBy(-1)
+      await delay(80)
+
+      expect(scroll.getPendingDelta()).toBe(0)
+      expect(viewportIsMounted(afterShrink, expose.current!.virtualHistory, scroll)).toBe(true)
+    } finally {
+      instance.unmount()
+      instance.cleanup()
+    }
+  })
+})

package/src/__tests__/wheelAccel.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest'
+
+import { computeWheelStep, initWheelAccel } from '../lib/wheelAccel.js'
+
+describe('wheelAccel — native path', () => {
+  it('first click after init returns base', () => {
+    const s = initWheelAccel(false, 1)
+
+    expect(computeWheelStep(s, 1, 1000)).toBe(1)
+  })
+
+  it('same-direction fast events ramp mult (window-mode)', () => {
+    const s = initWheelAccel(false, 1)
+
+    computeWheelStep(s, 1, 1000)
+    computeWheelStep(s, 1, 1020)
+    computeWheelStep(s, 1, 1040)
+
+    // Key property: doesn't shrink below base.
+    expect(computeWheelStep(s, 1, 1060)).toBeGreaterThanOrEqual(1)
+  })
+
+  it('gap beyond window resets mult to base', () => {
+    const s = initWheelAccel(false, 1)
+
+    for (let t = 1000; t < 1100; t += 20) {
+      computeWheelStep(s, 1, t)
+    }
+
+    expect(computeWheelStep(s, 1, 2000)).toBe(1)
+  })
+
+  it('direction flip defers one event for bounce detection', () => {
+    const s = initWheelAccel(false, 1)
+
+    computeWheelStep(s, 1, 1000)
+
+    expect(computeWheelStep(s, -1, 1050)).toBe(0)
+  })
+
+  it('flip-back within bounce window engages wheelMode', () => {
+    const s = initWheelAccel(false, 1)
+
+    computeWheelStep(s, 1, 1000)
+    computeWheelStep(s, -1, 1050)
+    computeWheelStep(s, 1, 1100)
+
+    expect(s.wheelMode).toBe(true)
+  })
+
+  it('flip-back outside bounce window is a real reversal (no wheelMode)', () => {
+    const s = initWheelAccel(false, 1)
+
+    computeWheelStep(s, 1, 1000)
+    computeWheelStep(s, -1, 1050)
+    computeWheelStep(s, 1, 1400)
+
+    expect(s.wheelMode).toBe(false)
+  })
+
+  it('5 consecutive sub-5ms events disengage wheelMode (trackpad signature)', () => {
+    const s = initWheelAccel(false, 1)
+    s.wheelMode = true
+    s.dir = 1
+    s.time = 1000
+
+    for (let t = 1002; t <= 1010; t += 2) {
+      computeWheelStep(s, 1, t)
+    }
+
+    expect(s.wheelMode).toBe(false)
+  })
+
+  it('1.5s idle disengages wheelMode', () => {
+    const s = initWheelAccel(false, 1)
+    s.wheelMode = true
+    s.dir = 1
+    s.time = 1000
+
+    computeWheelStep(s, 1, 3000)
+
+    expect(s.wheelMode).toBe(false)
+  })
+})
+
+describe('wheelAccel — xterm.js path', () => {
+  it('first click returns 2 after long idle', () => {
+    const s = initWheelAccel(true, 1)
+
+    expect(computeWheelStep(s, 1, 1000)).toBeGreaterThanOrEqual(1)
+  })
+
+  it('sub-5ms burst returns 1 (same-direction, same-batch)', () => {
+    const s = initWheelAccel(true, 1)
+
+    computeWheelStep(s, 1, 1000)
+
+    expect(computeWheelStep(s, 1, 1002)).toBe(1)
+  })
+
+  it('slow steady scroll stays in precision range', () => {
+    const s = initWheelAccel(true, 1)
+
+    for (let t = 1000; t < 2000; t += 33) {
+      const r = computeWheelStep(s, 1, t)
+
+      expect(r).toBeGreaterThanOrEqual(1)
+      expect(r).toBeLessThanOrEqual(6)
+    }
+  })
+
+  it('direction reversal resets mult', () => {
+    const s = initWheelAccel(true, 1)
+
+    for (let t = 1000; t < 1100; t += 20) {
+      computeWheelStep(s, 1, t)
+    }
+
+    const beforeFlip = s.mult
+
+    computeWheelStep(s, -1, 1200)
+
+    expect(s.mult).toBeLessThanOrEqual(beforeFlip)
+    expect(s.mult).toBe(2)
+  })
+
+  it('frac stays in [0,1) across events', () => {
+    const s = initWheelAccel(true, 1)
+
+    // Correctness invariant of fractional carry: never negative, never reaches 1.
+    for (let t = 1000; t < 1200; t += 30) {
+      computeWheelStep(s, 1, t)
+
+      expect(s.frac).toBeGreaterThanOrEqual(0)
+      expect(s.frac).toBeLessThan(1)
+    }
+  })
+})