@jmoyers/harness 0.1.0

package/src/ui/panes/home-gridfire.ts

@@ -0,0 +1,302 @@
+import { measureDisplayWidth } from '../../terminal/snapshot-oracle.ts';
+import { createUiSurface, renderUiSurfaceAnsiRows, type UiStyle } from '../surface.ts';
+
+interface HomeGridfireOptions {
+  readonly cols: number;
+  readonly rows: number;
+  readonly contentRows: readonly string[];
+  readonly timeMs: number;
+  readonly overlayTitle: string | null;
+  readonly overlaySubtitle: string | null;
+}
+
+type RgbTriplet = readonly [number, number, number];
+
+const GRID_CHARS = {
+  intersection: '+',
+  hline: '─',
+  vline: '│',
+  dot: '·',
+  brightDot: '•',
+  node: '◊',
+  brightNode: '◆',
+  empty: ' ',
+  light: '░',
+  heavy: '▓',
+} as const;
+
+const FG_PALETTE: readonly RgbTriplet[] = [
+  [14, 11, 28],
+  [28, 20, 55],
+  [50, 30, 100],
+  [75, 45, 155],
+  [55, 85, 200],
+  [90, 140, 240],
+  [150, 190, 255],
+  [220, 235, 255],
+];
+
+const BG_PALETTE: readonly RgbTriplet[] = [
+  [8, 6, 16],
+  [12, 10, 22],
+  [16, 13, 30],
+  [20, 16, 38],
+  [18, 20, 45],
+  [16, 24, 50],
+  [20, 28, 55],
+  [24, 32, 58],
+];
+
+function lerp(start: number, end: number, t: number): number {
+  return start + (end - start) * t;
+}
+
+function clamp01(value: number): number {
+  return Math.max(0, Math.min(1, value));
+}
+
+function colorLerp(start: RgbTriplet, end: RgbTriplet, t: number): RgbTriplet {
+  return [
+    Math.round(lerp(start[0], end[0], t)),
+    Math.round(lerp(start[1], end[1], t)),
+    Math.round(lerp(start[2], end[2], t)),
+  ];
+}
+
+function paletteColor(palette: readonly RgbTriplet[], t: number): RgbTriplet {
+  const normalized = clamp01(t);
+  const index = normalized * (palette.length - 1);
+  const low = Math.floor(index);
+  const high = Math.min(low + 1, palette.length - 1);
+  return colorLerp(palette[low]!, palette[high]!, index - low);
+}
+
+function styleFromColors(fg: RgbTriplet, bg: RgbTriplet, bold = false): UiStyle {
+  return {
+    fg: {
+      kind: 'rgb',
+      r: fg[0],
+      g: fg[1],
+      b: fg[2],
+    },
+    bg: {
+      kind: 'rgb',
+      r: bg[0],
+      g: bg[1],
+      b: bg[2],
+    },
+    bold,
+  };
+}
+
+function writeGlyph(
+  surface: ReturnType<typeof createUiSurface>,
+  row: number,
+  col: number,
+  glyph: string,
+  width: number,
+  style: UiStyle,
+): void {
+  const start = row * surface.cols + col;
+  const first = surface.cells[start]!;
+  first.glyph = glyph;
+  first.continued = false;
+  first.style = style;
+  for (let offset = 1; offset < width && col + offset < surface.cols; offset += 1) {
+    const trailing = surface.cells[start + offset]!;
+    trailing.glyph = '';
+    trailing.continued = true;
+    trailing.style = style;
+  }
+}
+
+function displayWidth(text: string): number {
+  let width = 0;
+  for (const glyph of text) {
+    width += Math.max(0, measureDisplayWidth(glyph));
+  }
+  return width;
+}
+
+function spacingX(cols: number): number {
+  return Math.max(4, Math.round(cols / 15));
+}
+
+function spacingY(rows: number): number {
+  return Math.max(2, Math.round(rows / 9));
+}
+
+function gridEnergy(col: number, row: number, cols: number, rows: number, phase: number): number {
+  const gridX = spacingX(cols);
+  const gridY = spacingY(rows);
+  const dxGrid = Math.abs((col % gridX) - gridX / 2) / (gridX / 2);
+  const dyGrid = Math.abs((row % gridY) - gridY / 2) / (gridY / 2);
+
+  const onHLine = 1 - dyGrid;
+  const onVLine = 1 - dxGrid;
+  const gridLine = Math.max(onHLine * 0.6, onVLine * 0.4);
+  const intersectionBoost = Math.pow(onHLine * onVLine, 0.5) * 0.5;
+
+  const nx = col / Math.max(1, cols);
+  const ny = row / Math.max(1, rows);
+  const hWave = Math.sin(nx * 12 + phase * 0.8) * 0.5 + 0.5;
+  const vWave = Math.sin(ny * 8 - phase * 0.6) * 0.5 + 0.5;
+  const crossWave = Math.sin((nx + ny) * 6 + phase * 0.4) * 0.5 + 0.5;
+  const lineEnergy = gridLine * (hWave * 0.5 + vWave * 0.3 + crossWave * 0.2);
+
+  const cx = nx - 0.5;
+  const cy = (ny - 0.5) * 0.6;
+  const dist = Math.sqrt(cx * cx + cy * cy);
+  const radialPulse = Math.sin(dist * 10 - phase * 1.5) * 0.3 * (1 - dist);
+  const nodePulse = intersectionBoost * (0.6 + Math.sin(phase * 0.7 + col * 0.3 + row * 0.5) * 0.4);
+  const ambient = 0.03 + Math.sin(nx * 4 + phase * 0.2) * Math.sin(ny * 3 - phase * 0.15) * 0.03;
+  return clamp01(
+    ambient + lineEnergy * 0.6 + nodePulse * 0.5 + Math.max(0, radialPulse) * gridLine,
+  );
+}
+
+function pickGridGlyph(
+  col: number,
+  row: number,
+  cols: number,
+  rows: number,
+  energy: number,
+): string {
+  const onHorizontal = row % spacingY(rows) === 0;
+  const onVertical = col % spacingX(cols) === 0;
+  if (onHorizontal && onVertical) {
+    return energy > 0.6
+      ? GRID_CHARS.brightNode
+      : energy > 0.3
+        ? GRID_CHARS.node
+        : GRID_CHARS.intersection;
+  }
+  if (onHorizontal) {
+    return energy > 0.7
+      ? GRID_CHARS.heavy
+      : energy > 0.4
+        ? GRID_CHARS.hline
+        : energy > 0.15
+          ? GRID_CHARS.dot
+          : GRID_CHARS.empty;
+  }
+  if (onVertical) {
+    return energy > 0.7
+      ? GRID_CHARS.heavy
+      : energy > 0.4
+        ? GRID_CHARS.vline
+        : energy > 0.15
+          ? GRID_CHARS.dot
+          : GRID_CHARS.empty;
+  }
+  return energy > 0.65
+    ? GRID_CHARS.light
+    : energy > 0.45
+      ? GRID_CHARS.brightDot
+      : energy > 0.25
+        ? GRID_CHARS.dot
+        : GRID_CHARS.empty;
+}
+
+function paintBackground(surface: ReturnType<typeof createUiSurface>, phase: number): void {
+  for (let row = 0; row < surface.rows; row += 1) {
+    for (let col = 0; col < surface.cols; col += 1) {
+      const energy = gridEnergy(col, row, surface.cols, surface.rows, phase);
+      const fg = paletteColor(FG_PALETTE, energy);
+      const bg = paletteColor(BG_PALETTE, energy * 0.3);
+      const glyph = pickGridGlyph(col, row, surface.cols, surface.rows, energy);
+      writeGlyph(surface, row, col, glyph, 1, styleFromColors(fg, bg));
+    }
+  }
+}
+
+function paintOverlayTextRow(
+  surface: ReturnType<typeof createUiSurface>,
+  row: number,
+  text: string,
+  phase: number,
+): void {
+  let col = 0;
+  for (const glyph of text) {
+    const width = Math.max(0, measureDisplayWidth(glyph));
+    if (width === 0) {
+      continue;
+    }
+    if (col >= surface.cols || col + width > surface.cols) {
+      break;
+    }
+    if (glyph !== ' ') {
+      const shimmer = clamp01(0.56 + Math.sin(phase * 0.4 + row * 0.12 + col * 0.05) * 0.06);
+      const fg: RgbTriplet = [
+        Math.round(lerp(120, 160, shimmer)),
+        Math.round(lerp(145, 185, shimmer)),
+        Math.round(lerp(180, 220, shimmer)),
+      ];
+      const offset = row * surface.cols + col;
+      const background = surface.cells[offset]!.style.bg as Extract<UiStyle['bg'], { kind: 'rgb' }>;
+      const bg: RgbTriplet = [background.r, background.g, background.b];
+      writeGlyph(surface, row, col, glyph, width, styleFromColors(fg, bg));
+    }
+    col += width;
+  }
+}
+
+function paintCenteredLabel(
+  surface: ReturnType<typeof createUiSurface>,
+  row: number,
+  text: string | null,
+  phase: number,
+): void {
+  if (text === null || text.length === 0) {
+    return;
+  }
+  const width = displayWidth(text);
+  if (width <= 0 || width > surface.cols) {
+    return;
+  }
+  let col = Math.floor((surface.cols - width) / 2);
+  let index = 0;
+  for (const glyph of text) {
+    const glyphWidth = Math.max(0, measureDisplayWidth(glyph));
+    if (glyphWidth === 0) {
+      continue;
+    }
+    const shimmer = clamp01(0.58 + Math.sin(phase * 0.35 + index * 0.18) * 0.05);
+    const fg: RgbTriplet = [
+      Math.round(lerp(125, 165, shimmer)),
+      Math.round(lerp(150, 190, shimmer)),
+      Math.round(lerp(190, 228, shimmer)),
+    ];
+    const offset = row * surface.cols + col;
+    const background = surface.cells[offset]!.style.bg as Extract<UiStyle['bg'], { kind: 'rgb' }>;
+    const bg: RgbTriplet = [background.r, background.g, background.b];
+    writeGlyph(surface, row, col, glyph, glyphWidth, styleFromColors(fg, bg));
+    col += glyphWidth;
+    index += 1;
+  }
+}
+
+export function renderHomeGridfireAnsiRows(options: HomeGridfireOptions): readonly string[] {
+  const safeCols = Math.max(1, options.cols);
+  const safeRows = Math.max(1, options.rows);
+  const surface = createUiSurface(safeCols, safeRows);
+  const phase = options.timeMs / 1000;
+
+  paintBackground(surface, phase);
+
+  for (let row = 0; row < safeRows; row += 1) {
+    const line = options.contentRows[row] ?? '';
+    paintOverlayTextRow(surface, row, line, phase);
+  }
+
+  const centerRow = Math.floor(safeRows / 2);
+  paintCenteredLabel(surface, centerRow, options.overlayTitle, phase);
+  paintCenteredLabel(
+    surface,
+    Math.min(safeRows - 1, centerRow + 2),
+    options.overlaySubtitle,
+    phase,
+  );
+
+  return renderUiSurfaceAnsiRows(surface);
+}

package/src/ui/panes/home.ts

@@ -0,0 +1,109 @@
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  buildTaskFocusedPaneView,
+  type TaskFocusedPaneEditorTarget,
+  type TaskFocusedPaneRepositoryRecord,
+  type TaskFocusedPaneTaskRecord,
+  type TaskFocusedPaneView,
+} from '../../mux/task-focused-pane.ts';
+import type { TaskComposerBuffer } from '../../mux/task-composer.ts';
+import { renderHomeGridfireAnsiRows } from './home-gridfire.ts';
+
+const HOME_PACKAGE_JSON_PATH = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '../../../package.json',
+);
+const HOME_PACKAGE_VERSION = String(
+  (JSON.parse(readFileSync(HOME_PACKAGE_JSON_PATH, 'utf8')) as { version: unknown }).version,
+);
+const HOME_OVERLAY_SUBTITLE = `- harness v${HOME_PACKAGE_VERSION} -`;
+
+interface HomePaneLayout {
+  readonly rightCols: number;
+  readonly paneRows: number;
+}
+
+interface HomePaneRenderInput {
+  readonly layout: HomePaneLayout;
+  readonly repositories: ReadonlyMap<string, TaskFocusedPaneRepositoryRecord>;
+  readonly tasks: ReadonlyMap<string, TaskFocusedPaneTaskRecord>;
+  readonly selectedRepositoryId: string | null;
+  readonly repositoryDropdownOpen: boolean;
+  readonly editorTarget: TaskFocusedPaneEditorTarget;
+  readonly draftBuffer: TaskComposerBuffer;
+  readonly taskBufferById: ReadonlyMap<string, TaskComposerBuffer>;
+  readonly notice: string | null;
+  readonly scrollTop: number;
+}
+
+interface HomePaneOptions {
+  readonly showTaskPlanningUi?: boolean;
+  readonly animateBackground?: boolean;
+  readonly overlaySubtitle?: string;
+}
+
+export class HomePane {
+  private readonly showTaskPlanningUi: boolean;
+  private readonly animateBackground: boolean;
+  private readonly staticBackgroundTimeMs: number;
+  private readonly overlaySubtitle: string;
+
+  constructor(
+    private readonly renderTaskFocusedPaneView: typeof buildTaskFocusedPaneView = buildTaskFocusedPaneView,
+    private readonly renderBackgroundRows: typeof renderHomeGridfireAnsiRows = renderHomeGridfireAnsiRows,
+    private readonly nowMs: () => number = Date.now,
+    options: HomePaneOptions = {},
+  ) {
+    this.showTaskPlanningUi = options.showTaskPlanningUi ?? false;
+    this.animateBackground = options.animateBackground ?? true;
+    this.staticBackgroundTimeMs = this.nowMs();
+    this.overlaySubtitle = options.overlaySubtitle ?? HOME_OVERLAY_SUBTITLE;
+  }
+
+  private hiddenTaskPlanningView(layout: HomePaneLayout): TaskFocusedPaneView {
+    const safeCols = Math.max(1, layout.rightCols);
+    const safeRows = Math.max(1, layout.paneRows);
+    const blankRow = ' '.repeat(safeCols);
+    const rows = Array.from({ length: safeRows }, () => blankRow);
+    return {
+      rows,
+      taskIds: Array.from({ length: safeRows }, () => null),
+      repositoryIds: Array.from({ length: safeRows }, () => null),
+      actions: Array.from({ length: safeRows }, () => null),
+      actionCells: Array.from({ length: safeRows }, () => null),
+      top: 0,
+      selectedRepositoryId: null,
+    };
+  }
+
+  render(input: HomePaneRenderInput): TaskFocusedPaneView {
+    const view = this.showTaskPlanningUi
+      ? this.renderTaskFocusedPaneView({
+          repositories: input.repositories,
+          tasks: input.tasks,
+          selectedRepositoryId: input.selectedRepositoryId,
+          repositoryDropdownOpen: input.repositoryDropdownOpen,
+          editorTarget: input.editorTarget,
+          draftBuffer: input.draftBuffer,
+          taskBufferById: input.taskBufferById,
+          notice: input.notice,
+          cols: input.layout.rightCols,
+          rows: input.layout.paneRows,
+          scrollTop: input.scrollTop,
+        })
+      : this.hiddenTaskPlanningView(input.layout);
+    return {
+      ...view,
+      rows: this.renderBackgroundRows({
+        cols: input.layout.rightCols,
+        rows: input.layout.paneRows,
+        contentRows: view.rows,
+        timeMs: this.animateBackground ? this.nowMs() : this.staticBackgroundTimeMs,
+        overlayTitle: 'GSV Sleeper Service',
+        overlaySubtitle: this.overlaySubtitle,
+      }),
+    };
+  }
+}

package/src/ui/panes/left-rail.ts

@@ -0,0 +1,12 @@
+import { buildRailRows } from '../../mux/live-mux/rail-layout.ts';
+
+type LeftRailRenderInput = Parameters<typeof buildRailRows>[0];
+type LeftRailRenderResult = ReturnType<typeof buildRailRows>;
+
+export class LeftRailPane {
+  constructor(private readonly renderRailRows: typeof buildRailRows = buildRailRows) {}
+
+  render(input: LeftRailRenderInput): LeftRailRenderResult {
+    return this.renderRailRows(input);
+  }
+}

package/src/ui/panes/project.ts

@@ -0,0 +1,44 @@
+import { buildProjectPaneRows, type ProjectPaneSnapshot } from '../../mux/harness-core-ui.ts';
+
+interface ProjectPaneLayout {
+  readonly rightCols: number;
+  readonly paneRows: number;
+}
+
+interface ProjectPaneRenderInput {
+  readonly layout: ProjectPaneLayout;
+  readonly snapshot: ProjectPaneSnapshot | null;
+  readonly scrollTop: number;
+}
+
+interface ProjectPaneRenderResult {
+  readonly rows: readonly string[];
+  readonly scrollTop: number;
+}
+
+export class ProjectPane {
+  constructor(
+    private readonly renderProjectRows: typeof buildProjectPaneRows = buildProjectPaneRows,
+  ) {}
+
+  render(input: ProjectPaneRenderInput): ProjectPaneRenderResult {
+    if (input.snapshot === null) {
+      return {
+        rows: Array.from({ length: input.layout.paneRows }, () =>
+          ' '.repeat(input.layout.rightCols),
+        ),
+        scrollTop: input.scrollTop,
+      };
+    }
+    const view = this.renderProjectRows(
+      input.snapshot,
+      input.layout.rightCols,
+      input.layout.paneRows,
+      input.scrollTop,
+    );
+    return {
+      rows: view.rows,
+      scrollTop: view.top,
+    };
+  }
+}

package/src/ui/pointer-routing-input.ts

@@ -0,0 +1,158 @@
+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 PointerTarget = 'left' | 'right' | 'separator' | 'status' | 'outside';
+
+interface HomePaneDragState {
+  readonly kind: 'task' | 'repository';
+  readonly itemId: string;
+  readonly startedRowIndex: number;
+  readonly latestRowIndex: number;
+  readonly hasDragged: boolean;
+}
+
+interface PointerRoutingInputOptions {
+  readonly getPaneDividerDragActive: () => boolean;
+  readonly setPaneDividerDragActive: (active: boolean) => void;
+  readonly applyPaneDividerAtCol: (col: number) => void;
+  readonly getHomePaneDragState: () => HomePaneDragState | null;
+  readonly setHomePaneDragState: (next: HomePaneDragState | null) => void;
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly taskIdAtRow: (index: number) => string | null;
+  readonly repositoryIdAtRow: (index: number) => string | null;
+  readonly reorderTaskByDrop: (draggedTaskId: string, targetTaskId: string) => void;
+  readonly reorderRepositoryByDrop: (
+    draggedRepositoryId: string,
+    targetRepositoryId: string,
+  ) => void;
+  readonly onProjectWheel: (delta: number) => void;
+  readonly onHomeWheel: (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;
+}
+
+interface PointerEventInput {
+  readonly code: number;
+  readonly final: 'M' | 'm';
+  readonly col: number;
+  readonly target: PointerTarget;
+  readonly rowIndex: number;
+}
+
+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;
+  }
+
+  handlePaneDividerDrag(event: Pick<PointerEventInput, 'code' | 'final' | 'col'>): boolean {
+    return this.handlePaneDividerDragInput({
+      paneDividerDragActive: this.options.getPaneDividerDragActive(),
+      isMouseRelease: isMouseRelease(event.final),
+      isWheelMouseCode: isWheelMouseCode(event.code),
+      mouseCol: event.col,
+      setPaneDividerDragActive: this.options.setPaneDividerDragActive,
+      applyPaneDividerAtCol: this.options.applyPaneDividerAtCol,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  handleHomePaneDragRelease(
+    event: Pick<PointerEventInput, 'final' | 'target' | 'rowIndex'>,
+  ): boolean {
+    return this.handleHomePaneDragReleaseInput({
+      homePaneDragState: this.options.getHomePaneDragState(),
+      isMouseRelease: isMouseRelease(event.final),
+      mainPaneMode: this.options.getMainPaneMode(),
+      target: event.target,
+      rowIndex: event.rowIndex,
+      taskIdAtRow: this.options.taskIdAtRow,
+      repositoryIdAtRow: this.options.repositoryIdAtRow,
+      reorderTaskByDrop: this.options.reorderTaskByDrop,
+      reorderRepositoryByDrop: this.options.reorderRepositoryByDrop,
+      setHomePaneDragState: this.options.setHomePaneDragState,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  handleSeparatorPointerPress(
+    event: Pick<PointerEventInput, 'target' | 'code' | 'final' | 'col'>,
+  ): boolean {
+    return this.handleSeparatorPointerPressInput({
+      target: event.target,
+      isLeftButtonPress: isLeftButtonPress(event.code, event.final),
+      hasAltModifier: hasAltModifier(event.code),
+      mouseCol: event.col,
+      setPaneDividerDragActive: this.options.setPaneDividerDragActive,
+      applyPaneDividerAtCol: this.options.applyPaneDividerAtCol,
+    });
+  }
+
+  handleMainPaneWheel(
+    event: Pick<PointerEventInput, 'target' | 'code'>,
+    onConversationWheel: (delta: number) => void,
+  ): boolean {
+    return this.handleMainPaneWheelInput({
+      target: event.target,
+      wheelDelta: wheelDeltaRowsFromCode(event.code),
+      mainPaneMode: this.options.getMainPaneMode(),
+      onProjectWheel: this.options.onProjectWheel,
+      onHomeWheel: this.options.onHomeWheel,
+      onConversationWheel,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  handleHomePaneDragMove(
+    event: Pick<PointerEventInput, 'target' | 'code' | 'final' | 'rowIndex'>,
+  ): boolean {
+    return this.handleHomePaneDragMoveInput({
+      homePaneDragState: this.options.getHomePaneDragState(),
+      mainPaneMode: this.options.getMainPaneMode(),
+      target: event.target,
+      isSelectionDrag: isSelectionDrag(event.code, event.final),
+      hasAltModifier: hasAltModifier(event.code),
+      rowIndex: event.rowIndex,
+      setHomePaneDragState: this.options.setHomePaneDragState,
+      markDirty: this.options.markDirty,
+    });
+  }
+}