@jmoyers/harness 0.1.10 → 0.1.20

package/packages/harness-ui/src/interaction/left-nav-input.ts

@@ -0,0 +1,166 @@
+export type LeftNavSelection =
+  | {
+      readonly kind: 'home';
+    }
+  | {
+      readonly kind: 'nim';
+    }
+  | {
+      readonly kind: 'tasks';
+    }
+  | {
+      readonly kind: 'repository';
+      readonly repositoryId: string;
+    }
+  | {
+      readonly kind: 'project';
+      readonly directoryId: string;
+    }
+  | {
+      readonly kind: 'github';
+      readonly directoryId: string;
+    }
+  | {
+      readonly kind: 'conversation';
+      readonly sessionId: string;
+    };
+
+export interface LeftNavState {
+  readonly railViewState: {
+    readLatestRows(): unknown;
+  };
+  readonly currentSelection: () => LeftNavSelection;
+}
+
+export interface LeftNavActions {
+  readonly enterHomePane: () => void;
+  readonly enterNimPane?: () => void;
+  readonly enterTasksPane?: () => void;
+  readonly firstDirectoryForRepositoryGroup: (repositoryGroupId: string) => string | null;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly enterGitHubPane?: (directoryId: string) => void;
+  readonly setMainPaneProjectMode: () => void;
+  readonly selectLeftNavRepository: (repositoryGroupId: string) => void;
+  readonly selectLeftNavConversation?: (sessionId: string) => void;
+  readonly markDirty: () => void;
+  readonly directoriesHas: (directoryId: string) => boolean;
+  readonly conversationDirectoryId: (sessionId: string) => string | null;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly queueLatestControlPlaneOp?: (
+    key: string,
+    task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+    label: string,
+  ) => void;
+  readonly activateConversation: (
+    sessionId: string,
+    options?: { readonly signal?: AbortSignal },
+  ) => Promise<void>;
+  readonly conversationsHas: (sessionId: string) => boolean;
+}
+
+export interface ActivateLeftNavTargetInput {
+  readonly target: LeftNavSelection;
+  readonly direction: 'next' | 'previous';
+  readonly enterHomePane: () => void;
+  readonly enterNimPane?: () => void;
+  readonly enterTasksPane?: () => void;
+  readonly firstDirectoryForRepositoryGroup: (repositoryGroupId: string) => string | null;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly enterGitHubPane?: (directoryId: string) => void;
+  readonly setMainPaneProjectMode: () => void;
+  readonly selectLeftNavRepository: (repositoryGroupId: string) => void;
+  readonly selectLeftNavConversation?: (sessionId: string) => void;
+  readonly markDirty: () => void;
+  readonly directoriesHas: (directoryId: string) => boolean;
+  readonly visibleTargetsForState: () => readonly LeftNavSelection[];
+  readonly conversationDirectoryId: (sessionId: string) => string | null;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly queueLatestControlPlaneOp?: (
+    key: string,
+    task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+    label: string,
+  ) => void;
+  readonly activateConversation: (
+    sessionId: string,
+    options?: { readonly signal?: AbortSignal },
+  ) => Promise<void>;
+  readonly conversationsHas: (sessionId: string) => boolean;
+}
+
+export interface CycleLeftNavSelectionInput {
+  readonly visibleTargets: readonly LeftNavSelection[];
+  readonly currentSelection: LeftNavSelection;
+  readonly direction: 'next' | 'previous';
+  readonly activateTarget: (target: LeftNavSelection, direction: 'next' | 'previous') => void;
+}
+
+export interface LeftNavStrategies {
+  visibleTargets(rows: unknown): readonly LeftNavSelection[];
+  activateTarget(input: ActivateLeftNavTargetInput): void;
+  cycleSelection(input: CycleLeftNavSelectionInput): boolean;
+}
+
+export class LeftNavInput {
+  constructor(
+    private readonly state: LeftNavState,
+    private readonly actions: LeftNavActions,
+    private readonly strategies: LeftNavStrategies,
+  ) {}
+
+  visibleTargets(): readonly LeftNavSelection[] {
+    return this.strategies.visibleTargets(this.state.railViewState.readLatestRows());
+  }
+
+  activateTarget(target: LeftNavSelection, direction: 'next' | 'previous'): void {
+    this.strategies.activateTarget({
+      target,
+      direction,
+      enterHomePane: this.actions.enterHomePane,
+      ...(this.actions.enterNimPane === undefined
+        ? {}
+        : {
+            enterNimPane: this.actions.enterNimPane,
+          }),
+      firstDirectoryForRepositoryGroup: this.actions.firstDirectoryForRepositoryGroup,
+      enterProjectPane: this.actions.enterProjectPane,
+      ...(this.actions.enterGitHubPane === undefined
+        ? {}
+        : {
+            enterGitHubPane: this.actions.enterGitHubPane,
+          }),
+      setMainPaneProjectMode: this.actions.setMainPaneProjectMode,
+      selectLeftNavRepository: this.actions.selectLeftNavRepository,
+      ...(this.actions.selectLeftNavConversation === undefined
+        ? {}
+        : {
+            selectLeftNavConversation: this.actions.selectLeftNavConversation,
+          }),
+      markDirty: this.actions.markDirty,
+      directoriesHas: this.actions.directoriesHas,
+      visibleTargetsForState: () => this.visibleTargets(),
+      conversationDirectoryId: this.actions.conversationDirectoryId,
+      queueControlPlaneOp: this.actions.queueControlPlaneOp,
+      ...(this.actions.queueLatestControlPlaneOp === undefined
+        ? {}
+        : {
+            queueLatestControlPlaneOp: this.actions.queueLatestControlPlaneOp,
+          }),
+      activateConversation: this.actions.activateConversation,
+      conversationsHas: this.actions.conversationsHas,
+      ...(this.actions.enterTasksPane === undefined
+        ? {}
+        : {
+            enterTasksPane: this.actions.enterTasksPane,
+          }),
+    });
+  }
+
+  cycleSelection(direction: 'next' | 'previous'): boolean {
+    return this.strategies.cycleSelection({
+      visibleTargets: this.visibleTargets(),
+      currentSelection: this.state.currentSelection(),
+      direction,
+      activateTarget: (target, nextDirection) => this.activateTarget(target, nextDirection),
+    });
+  }
+}

package/{src/ui → packages/harness-ui/src/interaction}/main-pane-pointer-input.ts

@@ -1,7 +1,3 @@
-import { hasAltModifier, isLeftButtonPress, isMotionMouseCode } from '../mux/live-mux/selection.ts';
-import { handleHomePanePointerClick } from '../mux/live-mux/home-pane-pointer.ts';
-import { handleProjectPaneActionClick } from '../mux/live-mux/project-pane-pointer.ts';
-
 interface EntityDoubleClickState {
   readonly entityId: string;
   readonly atMs: number;
@@ -15,10 +11,32 @@ interface HomePaneDragState {
   readonly hasDragged: boolean;
 }
 
-type MainPaneMode = 'conversation' | 'project' | 'home';
+type MainPaneMode = 'conversation' | 'project' | 'home' | 'nim';
 type PointerTarget = 'left' | 'right' | 'separator' | 'status' | 'outside';
 
-interface MainPanePointerInputOptions<TProjectSnapshot extends { directoryId: string }> {
+function isWheelMouseCode(code: number): boolean {
+  return (code & 0b0100_0000) !== 0;
+}
+
+function hasAltModifier(code: number): boolean {
+  return (code & 0b0000_1000) !== 0;
+}
+
+function isMotionMouseCode(code: number): boolean {
+  return (code & 0b0010_0000) !== 0;
+}
+
+function isLeftButtonPress(code: number, final: 'M' | 'm'): boolean {
+  if (final !== 'M') {
+    return false;
+  }
+  if (isWheelMouseCode(code) || isMotionMouseCode(code)) {
+    return false;
+  }
+  return (code & 0b0000_0011) === 0;
+}
+
+export interface MainPanePointerInputOptions<TProjectSnapshot extends { directoryId: string }> {
   readonly getMainPaneMode: () => MainPaneMode;
   readonly getProjectPaneSnapshot: () => TProjectSnapshot | null;
   readonly getProjectPaneScrollTop: () => number;
@@ -40,6 +58,7 @@ interface MainPanePointerInputOptions<TProjectSnapshot extends { directoryId: st
   readonly setTaskRepositoryDropdownOpen: (open: boolean) => void;
   readonly taskIdAtRow: (rowIndex: number) => string | null;
   readonly repositoryIdAtRow: (rowIndex: number) => string | null;
+  readonly rowTextAtRow?: (rowIndex: number) => string | null;
   readonly selectTaskById: (taskId: string) => void;
   readonly selectRepositoryById: (repositoryId: string) => void;
   readonly runTaskPaneAction: (action: 'task.ready' | 'task.draft' | 'task.complete') => void;
@@ -56,11 +75,6 @@ interface MainPanePointerInputOptions<TProjectSnapshot extends { directoryId: st
   readonly markDirty: () => void;
 }
 
-interface MainPanePointerInputDependencies {
-  readonly handleProjectPaneActionClick?: typeof handleProjectPaneActionClick;
-  readonly handleHomePanePointerClick?: typeof handleHomePanePointerClick;
-}
-
 interface PointerEventInput {
   readonly target: PointerTarget;
   readonly code: number;
@@ -72,19 +86,68 @@ interface PointerEventInput {
   readonly rightStartCol: number;
 }
 
-export class MainPanePointerInput<TProjectSnapshot extends { directoryId: string }> {
-  private readonly projectPaneActionClick: typeof handleProjectPaneActionClick<TProjectSnapshot>;
-  private readonly homePanePointerClick: typeof handleHomePanePointerClick;
+export interface HandleProjectPaneActionClickInput<TSnapshot extends { directoryId: string }> {
+  readonly clickEligible: boolean;
+  readonly snapshot: TSnapshot | null;
+  readonly rightCols: number;
+  readonly paneRows: number;
+  readonly projectPaneScrollTop: number;
+  readonly rowIndex: number;
+  readonly projectPaneActionAtRow: (
+    snapshot: TSnapshot,
+    rightCols: number,
+    paneRows: number,
+    projectPaneScrollTop: number,
+    rowIndex: number,
+  ) => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly queueCloseDirectory: (directoryId: string) => void;
+  readonly markDirty: () => void;
+}
 
+export interface HandleHomePanePointerClickInput {
+  readonly clickEligible: boolean;
+  readonly paneRows: number;
+  readonly rightCols: number;
+  readonly rightStartCol: number;
+  readonly pointerRow: number;
+  readonly pointerCol: number;
+  readonly actionAtCell: (rowIndex: number, colIndex: number) => string | null;
+  readonly actionAtRow: (rowIndex: number) => string | null;
+  readonly clearTaskEditClickState: () => void;
+  readonly clearRepositoryEditClickState: () => void;
+  readonly clearHomePaneDragState: () => void;
+  readonly getTaskRepositoryDropdownOpen: () => boolean;
+  readonly setTaskRepositoryDropdownOpen: (open: boolean) => void;
+  readonly taskIdAtRow: (rowIndex: number) => string | null;
+  readonly repositoryIdAtRow: (rowIndex: number) => string | null;
+  readonly rowTextAtRow?: (rowIndex: number) => string | null;
+  readonly selectTaskById: (taskId: string) => void;
+  readonly selectRepositoryById: (repositoryId: string) => void;
+  readonly runTaskPaneAction: (action: 'task.ready' | 'task.draft' | 'task.complete') => void;
+  readonly nowMs: number;
+  readonly homePaneEditDoubleClickWindowMs: number;
+  readonly taskEditClickState: EntityDoubleClickState | null;
+  readonly repositoryEditClickState: EntityDoubleClickState | null;
+  readonly clearTaskPaneNotice: () => void;
+  readonly setTaskEditClickState: (next: EntityDoubleClickState | null) => void;
+  readonly setRepositoryEditClickState: (next: EntityDoubleClickState | null) => void;
+  readonly setHomePaneDragState: (next: HomePaneDragState | null) => void;
+  readonly openTaskEditPrompt: (taskId: string) => void;
+  readonly openRepositoryPromptForEdit: (repositoryId: string) => void;
+  readonly markDirty: () => void;
+}
+
+export interface MainPanePointerStrategies<TProjectSnapshot extends { directoryId: string }> {
+  handleProjectPaneActionClick(input: HandleProjectPaneActionClickInput<TProjectSnapshot>): boolean;
+  handleHomePanePointerClick(input: HandleHomePanePointerClickInput): boolean;
+}
+
+export class MainPanePointerInput<TProjectSnapshot extends { directoryId: string }> {
   constructor(
     private readonly options: MainPanePointerInputOptions<TProjectSnapshot>,
-    dependencies: MainPanePointerInputDependencies = {},
-  ) {
-    this.projectPaneActionClick =
-      dependencies.handleProjectPaneActionClick ?? handleProjectPaneActionClick;
-    this.homePanePointerClick =
-      dependencies.handleHomePanePointerClick ?? handleHomePanePointerClick;
-  }
+    private readonly strategies: MainPanePointerStrategies<TProjectSnapshot>,
+  ) {}
 
   handleProjectPanePointerClick(input: PointerEventInput): boolean {
     const clickEligible =
@@ -94,7 +157,7 @@ export class MainPanePointerInput<TProjectSnapshot extends { directoryId: string
       !hasAltModifier(input.code) &&
       !isMotionMouseCode(input.code);
     const rowIndex = Math.max(0, Math.min(input.paneRows - 1, input.row - 1));
-    return this.projectPaneActionClick({
+    return this.strategies.handleProjectPaneActionClick({
       clickEligible,
       snapshot: this.options.getProjectPaneSnapshot(),
       rightCols: input.rightCols,
@@ -115,7 +178,7 @@ export class MainPanePointerInput<TProjectSnapshot extends { directoryId: string
       isLeftButtonPress(input.code, input.final) &&
       !hasAltModifier(input.code) &&
       !isMotionMouseCode(input.code);
-    return this.homePanePointerClick({
+    return this.strategies.handleHomePanePointerClick({
       clickEligible,
       paneRows: input.paneRows,
       rightCols: input.rightCols,
@@ -145,6 +208,11 @@ export class MainPanePointerInput<TProjectSnapshot extends { directoryId: string
       openTaskEditPrompt: this.options.openTaskEditPrompt,
       openRepositoryPromptForEdit: this.options.openRepositoryPromptForEdit,
       markDirty: this.options.markDirty,
+      ...(this.options.rowTextAtRow === undefined
+        ? {}
+        : {
+            rowTextAtRow: this.options.rowTextAtRow,
+          }),
     });
   }
 }

package/{src/ui → packages/harness-ui/src/interaction}/pointer-routing-input.ts

@@ -1,20 +1,4 @@
-import { wheelDeltaRowsFromCode } from '../mux/dual-pane-core.ts';
-import { handleHomePaneDragRelease as handleHomePaneDragReleaseFrame } from '../mux/live-mux/home-pane-drop.ts';
-import {
-  handleHomePaneDragMove as handleHomePaneDragMoveFrame,
-  handleMainPaneWheelInput as handleMainPaneWheelInputFrame,
-  handlePaneDividerDragInput as handlePaneDividerDragInputFrame,
-  handleSeparatorPointerPress as handleSeparatorPointerPressFrame,
-} from '../mux/live-mux/pointer-routing.ts';
-import {
-  hasAltModifier,
-  isLeftButtonPress,
-  isMouseRelease,
-  isSelectionDrag,
-  isWheelMouseCode,
-} from '../mux/live-mux/selection.ts';
-
-type MainPaneMode = 'conversation' | 'project' | 'home';
+type MainPaneMode = 'conversation' | 'project' | 'home' | 'nim';
 type PointerTarget = 'left' | 'right' | 'separator' | 'status' | 'outside';
 
 interface HomePaneDragState {
@@ -25,7 +9,44 @@ interface HomePaneDragState {
   readonly hasDragged: boolean;
 }
 
-interface PointerRoutingInputOptions {
+function isWheelMouseCode(code: number): boolean {
+  return (code & 0b0100_0000) !== 0;
+}
+
+function hasAltModifier(code: number): boolean {
+  return (code & 0b0000_1000) !== 0;
+}
+
+function isMotionMouseCode(code: number): boolean {
+  return (code & 0b0010_0000) !== 0;
+}
+
+function isLeftButtonPress(code: number, final: 'M' | 'm'): boolean {
+  if (final !== 'M') {
+    return false;
+  }
+  if (isWheelMouseCode(code) || isMotionMouseCode(code)) {
+    return false;
+  }
+  return (code & 0b0000_0011) === 0;
+}
+
+function isMouseRelease(final: 'M' | 'm'): boolean {
+  return final === 'm';
+}
+
+function isSelectionDrag(code: number, final: 'M' | 'm'): boolean {
+  return final === 'M' && isMotionMouseCode(code);
+}
+
+function wheelDeltaRowsFromCode(code: number): number | null {
+  if (!isWheelMouseCode(code)) {
+    return null;
+  }
+  return (code & 0b0000_0001) === 0 ? -1 : 1;
+}
+
+export interface PointerRoutingInputOptions {
   readonly getPaneDividerDragActive: () => boolean;
   readonly setPaneDividerDragActive: (active: boolean) => void;
   readonly applyPaneDividerAtCol: (col: number) => void;
@@ -41,15 +62,74 @@ interface PointerRoutingInputOptions {
   ) => void;
   readonly onProjectWheel: (delta: number) => void;
   readonly onHomeWheel: (delta: number) => void;
+  readonly onNimWheel: (delta: number) => void;
   readonly markDirty: () => void;
 }
 
-interface PointerRoutingInputDependencies {
-  readonly handlePaneDividerDragInput?: typeof handlePaneDividerDragInputFrame;
-  readonly handleHomePaneDragRelease?: typeof handleHomePaneDragReleaseFrame;
-  readonly handleSeparatorPointerPress?: typeof handleSeparatorPointerPressFrame;
-  readonly handleMainPaneWheelInput?: typeof handleMainPaneWheelInputFrame;
-  readonly handleHomePaneDragMove?: typeof handleHomePaneDragMoveFrame;
+export interface HandlePaneDividerDragInput {
+  readonly paneDividerDragActive: boolean;
+  readonly isMouseRelease: boolean;
+  readonly isWheelMouseCode: boolean;
+  readonly mouseCol: number;
+  readonly setPaneDividerDragActive: (active: boolean) => void;
+  readonly applyPaneDividerAtCol: (col: number) => void;
+  readonly markDirty: () => void;
+}
+
+export interface HandleHomePaneDragReleaseInput {
+  readonly homePaneDragState: HomePaneDragState | null;
+  readonly isMouseRelease: boolean;
+  readonly mainPaneMode: MainPaneMode;
+  readonly target: PointerTarget;
+  readonly rowIndex: number;
+  readonly taskIdAtRow: (rowIndex: number) => string | null;
+  readonly repositoryIdAtRow: (rowIndex: number) => string | null;
+  readonly reorderTaskByDrop: (draggedTaskId: string, targetTaskId: string) => void;
+  readonly reorderRepositoryByDrop: (
+    draggedRepositoryId: string,
+    targetRepositoryId: string,
+  ) => void;
+  readonly setHomePaneDragState: (next: HomePaneDragState | null) => void;
+  readonly markDirty: () => void;
+}
+
+export interface HandleSeparatorPointerPressInput {
+  readonly target: PointerTarget;
+  readonly isLeftButtonPress: boolean;
+  readonly hasAltModifier: boolean;
+  readonly mouseCol: number;
+  readonly setPaneDividerDragActive: (active: boolean) => void;
+  readonly applyPaneDividerAtCol: (col: number) => void;
+}
+
+export interface HandleMainPaneWheelInput {
+  readonly target: PointerTarget;
+  readonly wheelDelta: number | null;
+  readonly mainPaneMode: MainPaneMode;
+  readonly onProjectWheel: (delta: number) => void;
+  readonly onHomeWheel: (delta: number) => void;
+  readonly onNimWheel: (delta: number) => void;
+  readonly onConversationWheel: (delta: number) => void;
+  readonly markDirty: () => void;
+}
+
+export interface HandleHomePaneDragMoveInput {
+  readonly homePaneDragState: HomePaneDragState | null;
+  readonly mainPaneMode: MainPaneMode;
+  readonly target: PointerTarget;
+  readonly isSelectionDrag: boolean;
+  readonly hasAltModifier: boolean;
+  readonly rowIndex: number;
+  readonly setHomePaneDragState: (next: HomePaneDragState) => void;
+  readonly markDirty: () => void;
+}
+
+export interface PointerRoutingStrategies {
+  handlePaneDividerDragInput(options: HandlePaneDividerDragInput): boolean;
+  handleHomePaneDragRelease(options: HandleHomePaneDragReleaseInput): boolean;
+  handleSeparatorPointerPress(options: HandleSeparatorPointerPressInput): boolean;
+  handleMainPaneWheelInput(options: HandleMainPaneWheelInput): boolean;
+  handleHomePaneDragMove(options: HandleHomePaneDragMoveInput): boolean;
 }
 
 interface PointerEventInput {
@@ -61,30 +141,13 @@ interface PointerEventInput {
 }
 
 export class PointerRoutingInput {
-  private readonly handlePaneDividerDragInput: typeof handlePaneDividerDragInputFrame;
-  private readonly handleHomePaneDragReleaseInput: typeof handleHomePaneDragReleaseFrame;
-  private readonly handleSeparatorPointerPressInput: typeof handleSeparatorPointerPressFrame;
-  private readonly handleMainPaneWheelInput: typeof handleMainPaneWheelInputFrame;
-  private readonly handleHomePaneDragMoveInput: typeof handleHomePaneDragMoveFrame;
-
   constructor(
     private readonly options: PointerRoutingInputOptions,
-    dependencies: PointerRoutingInputDependencies = {},
-  ) {
-    this.handlePaneDividerDragInput =
-      dependencies.handlePaneDividerDragInput ?? handlePaneDividerDragInputFrame;
-    this.handleHomePaneDragReleaseInput =
-      dependencies.handleHomePaneDragRelease ?? handleHomePaneDragReleaseFrame;
-    this.handleSeparatorPointerPressInput =
-      dependencies.handleSeparatorPointerPress ?? handleSeparatorPointerPressFrame;
-    this.handleMainPaneWheelInput =
-      dependencies.handleMainPaneWheelInput ?? handleMainPaneWheelInputFrame;
-    this.handleHomePaneDragMoveInput =
-      dependencies.handleHomePaneDragMove ?? handleHomePaneDragMoveFrame;
-  }
+    private readonly strategies: PointerRoutingStrategies,
+  ) {}
 
   handlePaneDividerDrag(event: Pick<PointerEventInput, 'code' | 'final' | 'col'>): boolean {
-    return this.handlePaneDividerDragInput({
+    return this.strategies.handlePaneDividerDragInput({
       paneDividerDragActive: this.options.getPaneDividerDragActive(),
       isMouseRelease: isMouseRelease(event.final),
       isWheelMouseCode: isWheelMouseCode(event.code),
@@ -98,7 +161,7 @@ export class PointerRoutingInput {
   handleHomePaneDragRelease(
     event: Pick<PointerEventInput, 'final' | 'target' | 'rowIndex'>,
   ): boolean {
-    return this.handleHomePaneDragReleaseInput({
+    return this.strategies.handleHomePaneDragRelease({
       homePaneDragState: this.options.getHomePaneDragState(),
       isMouseRelease: isMouseRelease(event.final),
       mainPaneMode: this.options.getMainPaneMode(),
@@ -116,7 +179,7 @@ export class PointerRoutingInput {
   handleSeparatorPointerPress(
     event: Pick<PointerEventInput, 'target' | 'code' | 'final' | 'col'>,
   ): boolean {
-    return this.handleSeparatorPointerPressInput({
+    return this.strategies.handleSeparatorPointerPress({
       target: event.target,
       isLeftButtonPress: isLeftButtonPress(event.code, event.final),
       hasAltModifier: hasAltModifier(event.code),
@@ -130,12 +193,13 @@ export class PointerRoutingInput {
     event: Pick<PointerEventInput, 'target' | 'code'>,
     onConversationWheel: (delta: number) => void,
   ): boolean {
-    return this.handleMainPaneWheelInput({
+    return this.strategies.handleMainPaneWheelInput({
       target: event.target,
       wheelDelta: wheelDeltaRowsFromCode(event.code),
       mainPaneMode: this.options.getMainPaneMode(),
       onProjectWheel: this.options.onProjectWheel,
       onHomeWheel: this.options.onHomeWheel,
+      onNimWheel: this.options.onNimWheel,
       onConversationWheel,
       markDirty: this.options.markDirty,
     });
@@ -144,7 +208,7 @@ export class PointerRoutingInput {
   handleHomePaneDragMove(
     event: Pick<PointerEventInput, 'target' | 'code' | 'final' | 'rowIndex'>,
   ): boolean {
-    return this.handleHomePaneDragMoveInput({
+    return this.strategies.handleHomePaneDragMove({
       homePaneDragState: this.options.getHomePaneDragState(),
       mainPaneMode: this.options.getMainPaneMode(),
       target: event.target,

package/packages/harness-ui/src/interaction/rail-pointer-input.ts

@@ -0,0 +1,62 @@
+export interface HandlePointerClickInput {
+  readonly clickEligible: boolean;
+  readonly paneRows: number;
+  readonly leftCols: number;
+  readonly pointerRow: number;
+  readonly pointerCol: number;
+}
+
+export interface RailPointerHitResolver<THit> {
+  resolveHit(rowIndex: number, colIndex: number, railCols: number): THit | null;
+}
+
+export interface RailPointerHitDispatcher<THit> {
+  dispatchHit(hit: THit): boolean;
+}
+
+export interface RailPointerEditController<THit> {
+  hasActiveEdit(): boolean;
+  shouldKeepActiveEdit(hit: THit): boolean;
+  stopActiveEdit(): void;
+}
+
+export interface RailPointerSelectionController {
+  hasSelection(): boolean;
+  clearSelection(): void;
+}
+
+export class RailPointerInput<THit> {
+  constructor(
+    private readonly hitResolver: RailPointerHitResolver<THit>,
+    private readonly hitDispatcher: RailPointerHitDispatcher<THit>,
+    private readonly editController: RailPointerEditController<THit> | null = null,
+    private readonly selectionController: RailPointerSelectionController | null = null,
+  ) {}
+
+  handlePointerClick(input: HandlePointerClickInput): boolean {
+    if (!input.clickEligible) {
+      return false;
+    }
+
+    const rowIndex = Math.max(0, Math.min(input.paneRows - 1, input.pointerRow - 1));
+    const colIndex = Math.max(0, Math.min(input.leftCols - 1, input.pointerCol - 1));
+    const hit = this.hitResolver.resolveHit(rowIndex, colIndex, input.leftCols);
+    if (hit === null) {
+      return false;
+    }
+
+    if (
+      this.editController !== null &&
+      this.editController.hasActiveEdit() &&
+      !this.editController.shouldKeepActiveEdit(hit)
+    ) {
+      this.editController.stopActiveEdit();
+    }
+
+    if (this.selectionController !== null && this.selectionController.hasSelection()) {
+      this.selectionController.clearSelection();
+    }
+
+    return this.hitDispatcher.dispatchHit(hit);
+  }
+}