@brimveyn/aimux 1.13.0 → 1.14.0

package/src/session-backend/local-session-backend.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events'
 
-import type { AssistantId, ScrollIntent, WorkspaceSnapshotV1 } from '../state/types'
+import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
 import type { SessionBackend, SessionBackendEvents } from './types'
 
 import { SessionManager } from '../daemon/session-manager'
@@ -12,7 +12,6 @@ import {
   getSnapshotTrees,
   toTerminalContentSize,
 } from '../state/layout-resize'
-import { getSnapshotScrollIntents } from '../state/session-persistence'
 
 export class LocalSessionBackend
   extends EventEmitter<SessionBackendEvents>
@@ -67,22 +66,15 @@ export class LocalSessionBackend
     })
     this.currentSessionId = options.sessionId
     const trees = getSnapshotTrees(options.workspaceSnapshot)
-    const intents = getSnapshotScrollIntents(options.workspaceSnapshot)
     const splitTrees = trees.filter((t) => t.type === 'split')
     if (splitTrees.length > 0) {
       const bounds = createTerminalBounds(options.cols, options.rows)
       forEachSplitPaneRect(splitTrees, bounds, (tabId, rect) => {
         const size = toTerminalContentSize(rect)
-        this.sessionManager.resizeTab(
-          options.sessionId,
-          tabId,
-          size.cols,
-          size.rows,
-          intents.get(tabId)
-        )
+        this.sessionManager.resizeTab(options.sessionId, tabId, size.cols, size.rows)
       })
     } else {
-      this.sessionManager.resize(options.sessionId, options.cols, options.rows, intents)
+      this.sessionManager.resize(options.sessionId, options.cols, options.rows)
     }
     const attachResult = this.sessionManager.attachSession(
       options.sessionId,
@@ -149,36 +141,20 @@ export class LocalSessionBackend
     this.sessionManager.scrollToBottom(this.currentSessionId, tabId)
   }
 
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.reapplyScrollIntent(this.currentSessionId, tabId, intent)
-  }
-
   setActiveTab(tabId: string | null): void {
     if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
     logDebug('backend.local.setActiveTab', { sessionId: this.currentSessionId, tabId })
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
 
-  resizeAll(
-    cols: number,
-    rows: number,
-    intents?: Map<string, ScrollIntent>,
-    options?: { sync?: boolean }
-  ): void {
+  resizeAll(cols: number, rows: number, options?: { sync?: boolean }): void {
     if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.resize(this.currentSessionId, cols, rows, intents, options)
+    this.sessionManager.resize(this.currentSessionId, cols, rows, options)
   }
 
-  resizeTab(
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent,
-    options?: { sync?: boolean }
-  ): void {
+  resizeTab(tabId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
     if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent, options)
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, options)
   }
 
   disposeSession(tabId: string): void {

package/src/session-backend/remote-session-backend.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events'
 import { connect, type Socket } from 'node:net'
 
-import type { AssistantId, ScrollIntent, WorkspaceSnapshotV1 } from '../state/types'
+import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
 import type { SessionBackend, SessionBackendEvents } from './types'
 
 import { getIpcDaemonSocketPath } from '../daemon/runtime-paths'
@@ -144,6 +144,17 @@ export class RemoteSessionBackend
     }
   }
 
+  /** Fire-and-forget a command, reporting any failure via reportCommandError. */
+  private dispatchCommand(request: ClientRequest, context: string, tabId?: string): void {
+    void (async () => {
+      try {
+        await this.sendExpectOk(request)
+      } catch (error) {
+        this.reportCommandError(context, error, tabId)
+      }
+    })()
+  }
+
   private handleServerEvent(message: ServerEvent): void {
     logDebug('backend.remote.event', { type: message.type })
     switch (message.type) {
@@ -352,8 +363,10 @@ export class RemoteSessionBackend
       return
     }
 
-    void this.sendExpectOk({ id: crypto.randomUUID(), payload: options, type: 'createTab' }).catch(
-      (error) => this.reportCommandError('createTab', error, options.tabId)
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: options, type: 'createTab' },
+      'createTab',
+      options.tabId
     )
   }
 
@@ -362,99 +375,76 @@ export class RemoteSessionBackend
       logDebug('backend.remote.skipWriteBeforeAttach', { inputLength: input.length, tabId })
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { data: input, tabId },
-      type: 'write',
-    }).catch((error) => this.reportCommandError('write', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { data: input, tabId }, type: 'write' },
+      'write',
+      tabId
+    )
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { deltaLines, tabId },
-      type: 'scroll',
-    }).catch((error) => this.reportCommandError('scroll', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { deltaLines, tabId }, type: 'scroll' },
+      'scroll',
+      tabId
+    )
   }
 
   scrollViewportToBottom(tabId: string): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { tabId },
-      type: 'scrollToBottom',
-    }).catch((error) => this.reportCommandError('scrollToBottom', error, tabId))
-  }
-
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
-    if (!this.attached) {
-      return
-    }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { intent, tabId },
-      type: 'reapplyScrollIntent',
-    }).catch((error) => this.reportCommandError('reapplyScrollIntent', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { tabId }, type: 'scrollToBottom' },
+      'scrollToBottom',
+      tabId
+    )
   }
 
   setActiveTab(tabId: string | null): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { tabId },
-      type: 'setActiveTab',
-    }).catch((error) => this.reportCommandError('setActiveTab', error))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { tabId }, type: 'setActiveTab' },
+      'setActiveTab'
+    )
   }
 
-  resizeAll(
-    cols: number,
-    rows: number,
-    intents?: Map<string, ScrollIntent>,
-    _options?: { sync?: boolean }
-  ): void {
+  resizeAll(cols: number, rows: number, _options?: { sync?: boolean }): void {
     if (!this.attached) {
       logDebug('backend.remote.skipResizeBeforeAttach', { cols, rows })
       return
     }
     logDebug('backend.remote.resize', { cols, rows, sessionId: this.currentSessionId })
-    const intentsRecord = intents ? Object.fromEntries(intents.entries()) : undefined
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { cols, intents: intentsRecord, rows },
-      type: 'resizeClient',
-    }).catch((error) => this.reportCommandError('resizeClient', error))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { cols, rows }, type: 'resizeClient' },
+      'resizeClient'
+    )
   }
 
-  resizeTab(
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent,
-    _options?: { sync?: boolean }
-  ): void {
+  resizeTab(tabId: string, cols: number, rows: number, _options?: { sync?: boolean }): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { cols, intent, rows, tabId },
-      type: 'resizeTab',
-    }).catch((error) => this.reportCommandError('resizeTab', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { cols, rows, tabId }, type: 'resizeTab' },
+      'resizeTab',
+      tabId
+    )
   }
 
   disposeSession(tabId: string): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({ id: crypto.randomUUID(), payload: { tabId }, type: 'closeTab' }).catch(
-      (error) => this.reportCommandError('closeTab', error, tabId)
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { tabId }, type: 'closeTab' },
+      'closeTab',
+      tabId
     )
   }
 
@@ -462,9 +452,7 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({ id: crypto.randomUUID(), payload: {}, type: 'disposeAll' }).catch(
-      (error) => this.reportCommandError('disposeAll', error)
-    )
+    this.dispatchCommand({ id: crypto.randomUUID(), payload: {}, type: 'disposeAll' }, 'disposeAll')
   }
 
   async destroy(keepSessions = true): Promise<void> {

package/src/session-backend/types.ts

@@ -1,7 +1,6 @@
 import type { EventEmitter } from 'node:events'
 
 import type {
-  ScrollIntent,
   SessionStatus,
   TabActivity,
   TabSession,
@@ -49,21 +48,9 @@ export interface SessionBackend extends EventEmitter<SessionBackendEvents> {
   write(tabId: string, input: string): void
   scrollViewport(tabId: string, deltaLines: number): void
   scrollViewportToBottom(tabId: string): void
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void
   setActiveTab(tabId: string | null): void
-  resizeAll(
-    cols: number,
-    rows: number,
-    intents?: Map<string, ScrollIntent>,
-    options?: { sync?: boolean }
-  ): void
-  resizeTab(
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent,
-    options?: { sync?: boolean }
-  ): void
+  resizeAll(cols: number, rows: number, options?: { sync?: boolean }): void
+  resizeTab(tabId: string, cols: number, rows: number, options?: { sync?: boolean }): void
   disposeSession(tabId: string): void
   disposeAll(): void
   destroy(keepSessions?: boolean): Promise<void> | void

package/src/state/reducers/tab-state.ts

@@ -1,3 +1,5 @@
+import type { AppAction, AppState, TabSession } from '../types'
+
 import {
   allLeafIds,
   createGroupId,
@@ -15,13 +17,6 @@ import {
 import { normalizeGroupedTabOrder } from '../session-persistence'
 import { orderTabsByWorktree, withActiveWorktree } from '../session-worktrees'
 import { createDefaultTerminalModes } from '../terminal-modes'
-import {
-  type AppAction,
-  type AppState,
-  DEFAULT_SCROLL_INTENT,
-  deriveScrollIntent,
-  type TabSession,
-} from '../types'
 
 const MAX_BUFFER_LENGTH = 50_000
 
@@ -448,7 +443,6 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
             buffer: '',
             errorMessage: undefined,
             exitCode: undefined,
-            scrollIntent: DEFAULT_SCROLL_INTENT,
             status: 'starting',
             terminalModes: createDefaultTerminalModes(),
             viewport: undefined,
@@ -470,23 +464,11 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         ...state,
         tabs: updateTab(state.tabs, action.tabId, (tab) => ({
           ...tab,
-          scrollIntent:
-            action.source === 'resize' || action.source === 'switch'
-              ? (tab.scrollIntent ?? DEFAULT_SCROLL_INTENT)
-              : deriveScrollIntent(action.viewport),
           status: tab.status === 'starting' ? 'running' : tab.status,
           terminalModes: action.terminalModes,
           viewport: action.viewport,
         })),
       }
-    case 'set-scroll-intent':
-      return {
-        ...state,
-        tabs: updateTab(state.tabs, action.tabId, (tab) => ({
-          ...tab,
-          scrollIntent: action.intent,
-        })),
-      }
     case 'set-tab-activity':
       return {
         ...state,

package/src/state/session-persistence.ts

@@ -1,12 +1,6 @@
+import type { AppState, TabSession, TabStatus, WorkspaceSnapshotV1 } from './types'
+
 import { allLeafIds, createGroupId, type LayoutNode, pruneLayoutTree } from './layout-tree'
-import {
-  type AppState,
-  DEFAULT_SCROLL_INTENT,
-  type ScrollIntent,
-  type TabSession,
-  type TabStatus,
-  type WorkspaceSnapshotV1,
-} from './types'
 
 export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
   return {
@@ -47,7 +41,6 @@ export function serializeWorkspace(state: AppState): WorkspaceSnapshotV1 {
       errorMessage: tab.errorMessage,
       exitCode: tab.exitCode,
       id: tab.id,
-      scrollIntent: tab.scrollIntent,
       status: tab.status === 'disconnected' ? 'running' : tab.status,
       terminalModes: tab.terminalModes,
       title: tab.title,
@@ -76,7 +69,6 @@ export function restoreTabsFromWorkspace(snapshot: WorkspaceSnapshotV1 | undefin
       errorMessage: tab.errorMessage,
       exitCode: tab.exitCode,
       id: tab.id,
-      scrollIntent: tab.scrollIntent ?? DEFAULT_SCROLL_INTENT,
       status: getDisconnectedStatus(tab.status),
       terminalModes: tab.terminalModes,
       title: tab.title,
@@ -85,18 +77,6 @@ export function restoreTabsFromWorkspace(snapshot: WorkspaceSnapshotV1 | undefin
     }))
 }
 
-export function getSnapshotScrollIntents(
-  snapshot: WorkspaceSnapshotV1 | undefined
-): Map<string, ScrollIntent> {
-  if (!snapshot || snapshot.version !== 1) {
-    return new Map()
-  }
-
-  return new Map(
-    snapshot.tabs.map((tab) => [tab.id, tab.scrollIntent ?? DEFAULT_SCROLL_INTENT] as const)
-  )
-}
-
 export function restoreLayoutTrees(
   snapshot: WorkspaceSnapshotV1 | undefined,
   tabs: TabSession[]

package/src/state/types.ts

@@ -70,16 +70,11 @@ export interface TerminalSnapshot {
   cursorVisible: boolean
 }
 
+// The scroll position is owned end-to-end by the backend emulator; this type
+// only describes the re-anchor target the backend computes for itself across a
+// reflow. The frontend no longer derives, stores, or sends a scroll intent.
 export type ScrollIntent = { kind: 'bottom' } | { absoluteLine: number; kind: 'anchor' }
 
-export const DEFAULT_SCROLL_INTENT: ScrollIntent = { kind: 'bottom' }
-
-export function deriveScrollIntent(viewport: TerminalSnapshot): ScrollIntent {
-  return viewport.viewportY >= viewport.baseY
-    ? { kind: 'bottom' }
-    : { absoluteLine: viewport.viewportY, kind: 'anchor' }
-}
-
 export interface TerminalModeState {
   mouseTrackingMode: 'none' | 'x10' | 'vt200' | 'drag' | 'any'
   sendFocusMode: boolean
@@ -97,7 +92,6 @@ export interface PersistedTabSnapshot {
   buffer: string
   viewport?: TerminalSnapshot
   terminalModes: TerminalModeState
-  scrollIntent?: ScrollIntent
   errorMessage?: string
   exitCode?: number
   worktreeId?: string
@@ -163,7 +157,6 @@ export interface TabSession {
   buffer: string
   viewport?: TerminalSnapshot
   terminalModes: TerminalModeState
-  scrollIntent?: ScrollIntent
   command: string
   errorMessage?: string
   exitCode?: number
@@ -583,7 +576,6 @@ export type TabAction =
       terminalModes: TerminalModeState
       source?: 'resize' | 'scroll' | 'data' | 'switch'
     }
-  | { type: 'set-scroll-intent'; tabId: string; intent: ScrollIntent }
   | { type: 'set-tab-activity'; tabId: string; activity?: TabActivity }
   | { type: 'set-tab-error'; tabId: string; message: string }
 

package/src/state/validation.ts

@@ -56,13 +56,6 @@ function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
   )
 }
 
-function isScrollIntent(value: unknown): boolean {
-  if (!isObjectRecord(value)) return false
-  if (value.kind === 'bottom') return true
-  if (value.kind === 'anchor') return isFiniteNumber(value.absoluteLine)
-  return false
-}
-
 function isTerminalModeState(value: unknown): value is TerminalModeState {
   return (
     isObjectRecord(value) &&
@@ -149,7 +142,6 @@ export function isWorkspaceSnapshotV1(value: unknown): value is WorkspaceSnapsho
         isString(tab.buffer) &&
         isTerminalModeState(tab.terminalModes) &&
         (tab.viewport === undefined || isTerminalSnapshot(tab.viewport)) &&
-        (tab.scrollIntent === undefined || isScrollIntent(tab.scrollIntent)) &&
         (tab.errorMessage === undefined || isString(tab.errorMessage)) &&
         (tab.exitCode === undefined || isFiniteNumber(tab.exitCode)) &&
         (tab.worktreeId === undefined || isString(tab.worktreeId))

package/src/terminal-manager/manager-client.ts

@@ -1,12 +1,7 @@
 import { EventEmitter } from 'node:events'
 import { connect, type Socket } from 'node:net'
 
-import type {
-  ScrollIntent,
-  TerminalModeState,
-  TerminalSnapshot,
-  WorkspaceSnapshotV1,
-} from '../state/types'
+import type { TerminalModeState, TerminalSnapshot, WorkspaceSnapshotV1 } from '../state/types'
 
 import { getTerminalManagerSocketPath } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
@@ -306,29 +301,18 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  async resize(
-    sessionId: string,
-    cols: number,
-    rows: number,
-    intents?: Record<string, ScrollIntent>
-  ): Promise<void> {
+  async resize(sessionId: string, cols: number, rows: number): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
-      payload: { cols, intents, rows, sessionId },
+      payload: { cols, rows, sessionId },
       type: 'resizeClient',
     })
   }
 
-  async resizeTab(
-    sessionId: string,
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent
-  ): Promise<void> {
+  async resizeTab(sessionId: string, tabId: string, cols: number, rows: number): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
-      payload: { cols, intent, rows, sessionId, tabId },
+      payload: { cols, rows, sessionId, tabId },
       type: 'resizeTab',
     })
   }
@@ -349,14 +333,6 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  async reapplyScrollIntent(sessionId: string, tabId: string, intent: ScrollIntent): Promise<void> {
-    return this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { intent, sessionId, tabId },
-      type: 'reapplyScrollIntent',
-    })
-  }
-
   async setActiveTab(sessionId: string, tabId: string | null): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),

package/src/terminal-manager/terminal-manager.ts

@@ -211,15 +211,10 @@ export async function runTerminalManager(): Promise<void> {
                 break
               case 'resizeClient': {
                 requireNegotiatedVersion(socket, negotiatedVersions)
-                const intentsRecord = message.payload.intents
-                const intentsMap = intentsRecord
-                  ? new Map(Object.entries(intentsRecord))
-                  : undefined
                 sessionManager.resize(
                   message.payload.sessionId,
                   message.payload.cols,
-                  message.payload.rows,
-                  intentsMap
+                  message.payload.rows
                 )
                 sendOk(socket, message.id)
                 break
@@ -230,8 +225,7 @@ export async function runTerminalManager(): Promise<void> {
                   message.payload.sessionId,
                   message.payload.tabId,
                   message.payload.cols,
-                  message.payload.rows,
-                  message.payload.intent
+                  message.payload.rows
                 )
                 sendOk(socket, message.id)
                 break
@@ -249,15 +243,6 @@ export async function runTerminalManager(): Promise<void> {
                 sessionManager.scrollToBottom(message.payload.sessionId, message.payload.tabId)
                 sendOk(socket, message.id)
                 break
-              case 'reapplyScrollIntent':
-                requireNegotiatedVersion(socket, negotiatedVersions)
-                sessionManager.reapplyScrollIntent(
-                  message.payload.sessionId,
-                  message.payload.tabId,
-                  message.payload.intent
-                )
-                sendOk(socket, message.id)
-                break
               case 'setActiveTab':
                 requireNegotiatedVersion(socket, negotiatedVersions)
                 sessionManager.setActiveTab(message.payload.sessionId, message.payload.tabId)

package/src/ui/components/git/diff-renderer/fold-strip.tsx

@@ -1,3 +1,5 @@
+import { memo, useCallback } from 'react'
+
 import type { FoldDispatch } from './pierre-diff'
 
 import { useTheme } from '../../../theme'
@@ -8,7 +10,7 @@ interface Props {
   dispatch: FoldDispatch
 }
 
-function Button({ label, onPress }: { label: string; onPress: () => void }) {
+const Button = memo(function Button({ label, onPress }: { label: string; onPress: () => void }) {
   const t = useTheme()
   const bg = t.diffContextBg
   return (
@@ -16,7 +18,7 @@ function Button({ label, onPress }: { label: string; onPress: () => void }) {
       <text fg={t.primary}>{label}</text>
     </box>
   )
-}
+})
 
 function Spacer() {
   return <text> </text>
@@ -31,42 +33,47 @@ export function FoldStrip({ dispatch, fold }: Props) {
   const shrinkUp = Math.min(FOLD_STEP, topExpanded)
   const shrinkDown = Math.min(FOLD_STEP, bottomExpanded)
 
+  const handleExpandTop = useCallback(
+    () => dispatch.adjust(foldId, 'top', stepUp),
+    [dispatch, foldId, stepUp]
+  )
+  const handleExpandBottom = useCallback(
+    () => dispatch.adjust(foldId, 'bottom', stepDown),
+    [dispatch, foldId, stepDown]
+  )
+  const handleExpandAll = useCallback(
+    () => dispatch.set(foldId, total, 0),
+    [dispatch, foldId, total]
+  )
+  const handleShrinkTop = useCallback(
+    () => dispatch.adjust(foldId, 'top', -shrinkUp),
+    [dispatch, foldId, shrinkUp]
+  )
+  const handleShrinkBottom = useCallback(
+    () => dispatch.adjust(foldId, 'bottom', -shrinkDown),
+    [dispatch, foldId, shrinkDown]
+  )
+
   const controls: React.ReactNode[] = []
   if (hidden > 0) {
     controls.push(
-      <Button
-        key="up"
-        label={`↑${stepUp}`}
-        onPress={() => dispatch.adjust(foldId, 'top', stepUp)}
-      />,
+      <Button key="up" label={`↑${stepUp}`} onPress={handleExpandTop} />,
       <Spacer key="sp1" />,
-      <Button
-        key="down"
-        label={`↓${stepDown}`}
-        onPress={() => dispatch.adjust(foldId, 'bottom', stepDown)}
-      />,
+      <Button key="down" label={`↓${stepDown}`} onPress={handleExpandBottom} />,
       <Spacer key="sp2" />,
-      <Button key="all" label="⇅ all" onPress={() => dispatch.set(foldId, total, 0)} />
+      <Button key="all" label="⇅ all" onPress={handleExpandAll} />
     )
   }
   if (shrinkUp > 0) {
     controls.push(
       <Spacer key="sp3" />,
-      <Button
-        key="shrinkUp"
-        label={`−↑${shrinkUp}`}
-        onPress={() => dispatch.adjust(foldId, 'top', -shrinkUp)}
-      />
+      <Button key="shrinkUp" label={`−↑${shrinkUp}`} onPress={handleShrinkTop} />
     )
   }
   if (shrinkDown > 0) {
     controls.push(
       <Spacer key="sp4" />,
-      <Button
-        key="shrinkDown"
-        label={`−↓${shrinkDown}`}
-        onPress={() => dispatch.adjust(foldId, 'bottom', -shrinkDown)}
-      />
+      <Button key="shrinkDown" label={`−↓${shrinkDown}`} onPress={handleShrinkBottom} />
     )
   }