@jmoyers/harness 0.1.0

package/src/services/runtime-layout-resize.ts

@@ -0,0 +1,236 @@
+import { computeDualPaneLayout } from '../mux/dual-pane-core.ts';
+
+interface RuntimeLayoutResizeConversationRecord {
+  readonly sessionId: string;
+  readonly live: boolean;
+  readonly oracle: {
+    resize: (cols: number, rows: number) => void;
+  };
+}
+
+interface RuntimeLayoutResizeConversationManager<
+  TConversation extends RuntimeLayoutResizeConversationRecord,
+> {
+  readonly activeConversationId: string | null;
+  get(sessionId: string): TConversation | undefined;
+  values(): IterableIterator<TConversation>;
+}
+
+interface RuntimeLayoutResizeSize {
+  readonly cols: number;
+  readonly rows: number;
+}
+
+type RuntimeLayout = ReturnType<typeof computeDualPaneLayout>;
+
+interface RuntimeLayoutResizeOptions<TConversation extends RuntimeLayoutResizeConversationRecord> {
+  readonly getSize: () => RuntimeLayoutResizeSize;
+  readonly setSize: (nextSize: RuntimeLayoutResizeSize) => void;
+  readonly getLayout: () => RuntimeLayout;
+  readonly setLayout: (nextLayout: RuntimeLayout) => void;
+  readonly getLeftPaneColsOverride: () => number | null;
+  readonly setLeftPaneColsOverride: (leftCols: number | null) => void;
+  readonly conversationManager: RuntimeLayoutResizeConversationManager<TConversation>;
+  readonly ptySizeByConversationId: Map<string, RuntimeLayoutResizeSize>;
+  readonly sendResize: (sessionId: string, cols: number, rows: number) => void;
+  readonly markDirty: () => void;
+  readonly resetFrameCache: () => void;
+  readonly resizeRecordingOracle: (nextLayout: RuntimeLayout) => void;
+  readonly queuePersistMuxUiState: () => void;
+  readonly resizeMinIntervalMs: number;
+  readonly ptyResizeSettleMs: number;
+  readonly nowMs?: () => number;
+  readonly setTimeoutFn?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+  readonly clearTimeoutFn?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+
+export class RuntimeLayoutResize<TConversation extends RuntimeLayoutResizeConversationRecord> {
+  private resizeTimer: ReturnType<typeof setTimeout> | null = null;
+  private pendingSize: RuntimeLayoutResizeSize | null = null;
+  private lastResizeApplyAtMs = 0;
+  private ptyResizeTimer: ReturnType<typeof setTimeout> | null = null;
+  private pendingPtySize: RuntimeLayoutResizeSize | null = null;
+  private readonly nowMs: () => number;
+  private readonly setTimeoutFn: (
+    callback: () => void,
+    delayMs: number,
+  ) => ReturnType<typeof setTimeout>;
+  private readonly clearTimeoutFn: (timer: ReturnType<typeof setTimeout>) => void;
+
+  constructor(private readonly options: RuntimeLayoutResizeOptions<TConversation>) {
+    this.nowMs = options.nowMs ?? Date.now;
+    this.setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+    this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
+  }
+
+  clearResizeTimer(): void {
+    if (this.resizeTimer === null) {
+      return;
+    }
+    this.clearTimeoutFn(this.resizeTimer);
+    this.resizeTimer = null;
+  }
+
+  clearPtyResizeTimer(): void {
+    if (this.ptyResizeTimer === null) {
+      return;
+    }
+    this.clearTimeoutFn(this.ptyResizeTimer);
+    this.ptyResizeTimer = null;
+  }
+
+  schedulePtyResize(ptySize: RuntimeLayoutResizeSize, immediate = false): void {
+    this.pendingPtySize = ptySize;
+    if (immediate) {
+      this.clearPtyResizeTimer();
+      this.flushPendingPtyResize();
+      return;
+    }
+
+    if (this.ptyResizeTimer !== null) {
+      this.clearTimeoutFn(this.ptyResizeTimer);
+    }
+    this.ptyResizeTimer = this.setTimeoutFn(() => {
+      this.flushPendingPtyResize();
+    }, this.options.ptyResizeSettleMs);
+  }
+
+  applyLayout(nextSize: RuntimeLayoutResizeSize, forceImmediatePtyResize = false): void {
+    const nextLayout = computeDualPaneLayout(nextSize.cols, nextSize.rows, {
+      leftCols: this.options.getLeftPaneColsOverride(),
+    });
+    this.schedulePtyResize(
+      {
+        cols: nextLayout.rightCols,
+        rows: nextLayout.paneRows,
+      },
+      forceImmediatePtyResize,
+    );
+    const layout = this.options.getLayout();
+    if (
+      nextLayout.cols === layout.cols &&
+      nextLayout.rows === layout.rows &&
+      nextLayout.leftCols === layout.leftCols &&
+      nextLayout.rightCols === layout.rightCols &&
+      nextLayout.paneRows === layout.paneRows
+    ) {
+      return;
+    }
+    this.options.setSize(nextSize);
+    this.options.setLayout(nextLayout);
+    for (const conversation of this.options.conversationManager.values()) {
+      conversation.oracle.resize(nextLayout.rightCols, nextLayout.paneRows);
+      if (conversation.live) {
+        this.applyPtyResizeToSession(
+          conversation.sessionId,
+          {
+            cols: nextLayout.rightCols,
+            rows: nextLayout.paneRows,
+          },
+          true,
+        );
+      }
+    }
+    this.options.resizeRecordingOracle(nextLayout);
+    // Force a full clear on actual layout changes to avoid stale diagonal artifacts during drag.
+    this.options.resetFrameCache();
+    this.options.markDirty();
+  }
+
+  queueResize(nextSize: RuntimeLayoutResizeSize): void {
+    this.pendingSize = nextSize;
+    if (this.resizeTimer !== null) {
+      return;
+    }
+
+    const nowMs = this.nowMs();
+    const elapsedMs = nowMs - this.lastResizeApplyAtMs;
+    const delayMs =
+      elapsedMs >= this.options.resizeMinIntervalMs
+        ? 0
+        : this.options.resizeMinIntervalMs - elapsedMs;
+    this.resizeTimer = this.setTimeoutFn(() => {
+      this.flushPendingResize();
+    }, delayMs);
+  }
+
+  applyPaneDividerAtCol(col: number): void {
+    const size = this.options.getSize();
+    const normalizedCol = Math.max(1, Math.min(size.cols, col));
+    this.options.setLeftPaneColsOverride(Math.max(1, normalizedCol - 1));
+    this.applyLayout(size);
+    this.options.queuePersistMuxUiState();
+  }
+
+  private applyPtyResizeToSession(
+    sessionId: string,
+    ptySize: RuntimeLayoutResizeSize,
+    force = false,
+  ): void {
+    const conversation = this.options.conversationManager.get(sessionId);
+    if (conversation === undefined || !conversation.live) {
+      return;
+    }
+    const currentPtySize = this.options.ptySizeByConversationId.get(sessionId);
+    if (
+      !force &&
+      currentPtySize !== undefined &&
+      currentPtySize.cols === ptySize.cols &&
+      currentPtySize.rows === ptySize.rows
+    ) {
+      return;
+    }
+    this.options.ptySizeByConversationId.set(sessionId, {
+      cols: ptySize.cols,
+      rows: ptySize.rows,
+    });
+    conversation.oracle.resize(ptySize.cols, ptySize.rows);
+    this.options.sendResize(sessionId, ptySize.cols, ptySize.rows);
+    this.options.markDirty();
+  }
+
+  private applyPtyResize(ptySize: RuntimeLayoutResizeSize): void {
+    const activeConversationId = this.options.conversationManager.activeConversationId;
+    if (activeConversationId === null) {
+      return;
+    }
+    this.applyPtyResizeToSession(activeConversationId, ptySize, false);
+  }
+
+  private flushPendingPtyResize(): void {
+    this.ptyResizeTimer = null;
+    const ptySize = this.pendingPtySize;
+    if (ptySize === null) {
+      return;
+    }
+    this.pendingPtySize = null;
+    this.applyPtyResize(ptySize);
+  }
+
+  private flushPendingResize(): void {
+    this.resizeTimer = null;
+    const nextSize = this.pendingSize;
+    if (nextSize === null) {
+      return;
+    }
+
+    const nowMs = this.nowMs();
+    const elapsedMs = nowMs - this.lastResizeApplyAtMs;
+    if (elapsedMs < this.options.resizeMinIntervalMs) {
+      this.resizeTimer = this.setTimeoutFn(() => {
+        this.flushPendingResize();
+      }, this.options.resizeMinIntervalMs - elapsedMs);
+      return;
+    }
+
+    this.pendingSize = null;
+    this.applyLayout(nextSize);
+    this.lastResizeApplyAtMs = this.nowMs();
+
+    if (this.pendingSize !== null && this.resizeTimer === null) {
+      this.resizeTimer = this.setTimeoutFn(() => {
+        this.flushPendingResize();
+      }, this.options.resizeMinIntervalMs);
+    }
+  }
+}

package/src/services/runtime-left-rail-render.ts

@@ -0,0 +1,159 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { RepositoryManager } from '../domain/repositories.ts';
+
+interface RuntimeLeftRailRenderLayout {
+  readonly cols: number;
+  readonly paneRows: number;
+  readonly leftCols: number;
+  readonly rightCols: number;
+  readonly separatorCol: number;
+  readonly rightStartCol: number;
+}
+
+interface SessionProjectionInstrumentationLike<TDirectoryRecord, TConversationRecord> {
+  refreshSelectorSnapshot(
+    source: 'render' | 'observed',
+    directories: ReadonlyMap<string, TDirectoryRecord>,
+    conversations: ReadonlyMap<string, TConversationRecord>,
+    orderedConversationIds: readonly string[],
+  ): void;
+}
+
+interface LeftRailPaneLike<
+  TLayout,
+  TRepositoryRecord,
+  TRepositorySnapshot,
+  TDirectoryRecord,
+  TConversationRecord,
+  TGitSummary,
+  TProcessUsage,
+  TShortcutBindings,
+  TRailViewRows,
+> {
+  render(input: {
+    layout: TLayout;
+    repositories: ReadonlyMap<string, TRepositoryRecord>;
+    repositoryAssociationByDirectoryId: ReadonlyMap<string, string>;
+    directoryRepositorySnapshotByDirectoryId: ReadonlyMap<string, TRepositorySnapshot>;
+    directories: ReadonlyMap<string, TDirectoryRecord>;
+    conversations: ReadonlyMap<string, TConversationRecord>;
+    orderedIds: readonly string[];
+    activeProjectId: string | null;
+    activeRepositoryId: string | null;
+    activeConversationId: string | null;
+    projectSelectionEnabled: boolean;
+    repositorySelectionEnabled: boolean;
+    homeSelectionEnabled: boolean;
+    repositoriesCollapsed: boolean;
+    collapsedRepositoryGroupIds: ReadonlySet<string>;
+    shortcutsCollapsed: boolean;
+    gitSummaryByDirectoryId: ReadonlyMap<string, TGitSummary>;
+    processUsageBySessionId: ReadonlyMap<string, TProcessUsage>;
+    shortcutBindings: TShortcutBindings;
+    loadingGitSummary: TGitSummary;
+  }): {
+    readonly ansiRows: readonly string[];
+    readonly viewRows: TRailViewRows;
+  };
+}
+
+interface RuntimeLeftRailRenderOptions<
+  TDirectoryRecord,
+  TConversationRecord,
+  TRepositoryRecord,
+  TRepositorySnapshot,
+  TGitSummary,
+  TProcessUsage,
+  TShortcutBindings,
+  TRailViewRows,
+> {
+  readonly leftRailPane: LeftRailPaneLike<
+    RuntimeLeftRailRenderLayout,
+    TRepositoryRecord,
+    TRepositorySnapshot,
+    TDirectoryRecord,
+    TConversationRecord,
+    TGitSummary,
+    TProcessUsage,
+    TShortcutBindings,
+    TRailViewRows
+  >;
+  readonly sessionProjectionInstrumentation: SessionProjectionInstrumentationLike<
+    TDirectoryRecord,
+    TConversationRecord
+  >;
+  readonly workspace: WorkspaceModel;
+  readonly repositoryManager: RepositoryManager<TRepositoryRecord, TRepositorySnapshot>;
+  readonly repositories: ReadonlyMap<string, TRepositoryRecord>;
+  readonly repositoryAssociationByDirectoryId: ReadonlyMap<string, string>;
+  readonly directoryRepositorySnapshotByDirectoryId: ReadonlyMap<string, TRepositorySnapshot>;
+  readonly directories: ReadonlyMap<string, TDirectoryRecord>;
+  readonly conversations: ReadonlyMap<string, TConversationRecord>;
+  readonly gitSummaryByDirectoryId: ReadonlyMap<string, TGitSummary>;
+  readonly processUsageBySessionId: () => ReadonlyMap<string, TProcessUsage>;
+  readonly shortcutBindings: TShortcutBindings;
+  readonly loadingGitSummary: TGitSummary;
+  readonly activeConversationId: () => string | null;
+  readonly orderedConversationIds: () => readonly string[];
+}
+
+export class RuntimeLeftRailRender<
+  TDirectoryRecord,
+  TConversationRecord,
+  TRepositoryRecord,
+  TRepositorySnapshot,
+  TGitSummary,
+  TProcessUsage,
+  TShortcutBindings,
+  TRailViewRows,
+> {
+  constructor(
+    private readonly options: RuntimeLeftRailRenderOptions<
+      TDirectoryRecord,
+      TConversationRecord,
+      TRepositoryRecord,
+      TRepositorySnapshot,
+      TGitSummary,
+      TProcessUsage,
+      TShortcutBindings,
+      TRailViewRows
+    >,
+  ) {}
+
+  render(layout: RuntimeLeftRailRenderLayout): {
+    readonly ansiRows: readonly string[];
+    readonly viewRows: TRailViewRows;
+  } {
+    const orderedIds = this.options.orderedConversationIds();
+    this.options.sessionProjectionInstrumentation.refreshSelectorSnapshot(
+      'render',
+      this.options.directories,
+      this.options.conversations,
+      orderedIds,
+    );
+    return this.options.leftRailPane.render({
+      layout,
+      repositories: this.options.repositories,
+      repositoryAssociationByDirectoryId: this.options.repositoryAssociationByDirectoryId,
+      directoryRepositorySnapshotByDirectoryId:
+        this.options.directoryRepositorySnapshotByDirectoryId,
+      directories: this.options.directories,
+      conversations: this.options.conversations,
+      orderedIds,
+      activeProjectId: this.options.workspace.activeDirectoryId,
+      activeRepositoryId: this.options.workspace.activeRepositorySelectionId,
+      activeConversationId: this.options.activeConversationId(),
+      projectSelectionEnabled: this.options.workspace.leftNavSelection.kind === 'project',
+      repositorySelectionEnabled: this.options.workspace.leftNavSelection.kind === 'repository',
+      homeSelectionEnabled: this.options.workspace.leftNavSelection.kind === 'home',
+      repositoriesCollapsed: this.options.workspace.repositoriesCollapsed,
+      collapsedRepositoryGroupIds:
+        this.options.repositoryManager.readonlyCollapsedRepositoryGroupIds(),
+      shortcutsCollapsed: this.options.workspace.shortcutsCollapsed,
+      gitSummaryByDirectoryId: this.options.gitSummaryByDirectoryId,
+      processUsageBySessionId: this.options.processUsageBySessionId(),
+      shortcutBindings: this.options.shortcutBindings,
+      loadingGitSummary: this.options.loadingGitSummary,
+    });
+  }
+}

package/src/services/runtime-main-pane-input.ts

@@ -0,0 +1,230 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { LeftRailPointerInput } from '../ui/left-rail-pointer-input.ts';
+import { MainPanePointerInput } from '../ui/main-pane-pointer-input.ts';
+import { PointerRoutingInput } from '../ui/pointer-routing-input.ts';
+import { ConversationSelectionInput } from '../ui/conversation-selection-input.ts';
+import { InputTokenRouter } from '../ui/input-token-router.ts';
+
+type ProjectPaneSnapshot = NonNullable<WorkspaceModel['projectPaneSnapshot']>;
+type MainPanePointerInputOptions = ConstructorParameters<
+  typeof MainPanePointerInput<ProjectPaneSnapshot>
+>[0];
+type PointerRoutingInputOptions = ConstructorParameters<typeof PointerRoutingInput>[0];
+type ConversationSelectionInputOptions = ConstructorParameters<
+  typeof ConversationSelectionInput
+>[0];
+type InputTokenRouterOptions = ConstructorParameters<typeof InputTokenRouter>[0];
+
+type RouteTokensInput = Parameters<InputTokenRouter['routeTokens']>[0];
+type RouteTokensResult = ReturnType<InputTokenRouter['routeTokens']>;
+
+interface RuntimeMainPaneWorkspaceActions {
+  runTaskPaneAction(action: 'task.ready' | 'task.draft' | 'task.complete'): void;
+  openTaskEditPrompt(taskId: string): void;
+  openRepositoryPromptForEdit(repositoryId: string): void;
+  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void;
+  reorderRepositoryByDrop(draggedRepositoryId: string, targetRepositoryId: string): void;
+}
+
+interface RuntimeMainPaneInputOptions {
+  readonly workspace: WorkspaceModel;
+  readonly leftRailPointerInput: Pick<LeftRailPointerInput, 'handlePointerClick'>;
+  readonly workspaceActions: RuntimeMainPaneWorkspaceActions;
+  readonly projectPaneActionAtRow: MainPanePointerInputOptions['projectPaneActionAtRow'];
+  readonly openNewThreadPrompt: MainPanePointerInputOptions['openNewThreadPrompt'];
+  readonly queueCloseDirectory: MainPanePointerInputOptions['queueCloseDirectory'];
+  readonly selectTaskById: MainPanePointerInputOptions['selectTaskById'];
+  readonly selectRepositoryById: MainPanePointerInputOptions['selectRepositoryById'];
+  readonly taskPaneActionAtCell: (
+    view: WorkspaceModel['latestTaskPaneView'],
+    rowIndex: number,
+    colIndex: number,
+  ) => ReturnType<MainPanePointerInputOptions['actionAtCell']>;
+  readonly taskPaneActionAtRow: (
+    view: WorkspaceModel['latestTaskPaneView'],
+    rowIndex: number,
+  ) => ReturnType<MainPanePointerInputOptions['actionAtRow']>;
+  readonly taskPaneTaskIdAtRow: (
+    view: WorkspaceModel['latestTaskPaneView'],
+    rowIndex: number,
+  ) => ReturnType<MainPanePointerInputOptions['taskIdAtRow']>;
+  readonly taskPaneRepositoryIdAtRow: (
+    view: WorkspaceModel['latestTaskPaneView'],
+    rowIndex: number,
+  ) => ReturnType<MainPanePointerInputOptions['repositoryIdAtRow']>;
+  readonly applyPaneDividerAtCol: PointerRoutingInputOptions['applyPaneDividerAtCol'];
+  readonly pinViewportForSelection: ConversationSelectionInputOptions['pinViewportForSelection'];
+  readonly releaseViewportPinForSelection: ConversationSelectionInputOptions['releaseViewportPinForSelection'];
+  readonly markDirty: () => void;
+  readonly homePaneEditDoubleClickWindowMs: number;
+  readonly nowMs?: () => number;
+}
+
+interface RuntimeMainPaneInputDependencies {
+  readonly createMainPanePointerInput?: (
+    options: MainPanePointerInputOptions,
+  ) => Pick<
+    MainPanePointerInput<ProjectPaneSnapshot>,
+    'handleProjectPanePointerClick' | 'handleHomePanePointerClick'
+  >;
+  readonly createPointerRoutingInput?: (
+    options: PointerRoutingInputOptions,
+  ) => Pick<
+    PointerRoutingInput,
+    | 'handlePaneDividerDrag'
+    | 'handleHomePaneDragRelease'
+    | 'handleSeparatorPointerPress'
+    | 'handleMainPaneWheel'
+    | 'handleHomePaneDragMove'
+  >;
+  readonly createConversationSelectionInput?: (
+    options: ConversationSelectionInputOptions,
+  ) => Pick<ConversationSelectionInput, 'clearSelectionOnTextToken' | 'handleMouseSelection'>;
+  readonly createInputTokenRouter?: (
+    options: InputTokenRouterOptions,
+  ) => Pick<InputTokenRouter, 'routeTokens'>;
+}
+
+export class RuntimeMainPaneInput {
+  private readonly inputTokenRouter: Pick<InputTokenRouter, 'routeTokens'>;
+
+  constructor(
+    options: RuntimeMainPaneInputOptions,
+    dependencies: RuntimeMainPaneInputDependencies = {},
+  ) {
+    const nowMs = options.nowMs ?? (() => Date.now());
+    const createMainPanePointerInput =
+      dependencies.createMainPanePointerInput ??
+      ((mainPaneOptions: MainPanePointerInputOptions) => new MainPanePointerInput(mainPaneOptions));
+    const createPointerRoutingInput =
+      dependencies.createPointerRoutingInput ??
+      ((pointerOptions: PointerRoutingInputOptions) => new PointerRoutingInput(pointerOptions));
+    const createConversationSelectionInput =
+      dependencies.createConversationSelectionInput ??
+      ((selectionOptions: ConversationSelectionInputOptions) =>
+        new ConversationSelectionInput(selectionOptions));
+    const createInputTokenRouter =
+      dependencies.createInputTokenRouter ??
+      ((tokenRouterOptions: InputTokenRouterOptions) => new InputTokenRouter(tokenRouterOptions));
+
+    const mainPanePointerInput = createMainPanePointerInput({
+      getMainPaneMode: () => options.workspace.mainPaneMode,
+      getProjectPaneSnapshot: () => options.workspace.projectPaneSnapshot,
+      getProjectPaneScrollTop: () => options.workspace.projectPaneScrollTop,
+      projectPaneActionAtRow: options.projectPaneActionAtRow,
+      openNewThreadPrompt: options.openNewThreadPrompt,
+      queueCloseDirectory: options.queueCloseDirectory,
+      actionAtCell: (rowIndex, colIndex) =>
+        options.taskPaneActionAtCell(options.workspace.latestTaskPaneView, rowIndex, colIndex),
+      actionAtRow: (rowIndex) =>
+        options.taskPaneActionAtRow(options.workspace.latestTaskPaneView, rowIndex),
+      clearTaskEditClickState: () => {
+        options.workspace.taskPaneTaskEditClickState = null;
+      },
+      clearRepositoryEditClickState: () => {
+        options.workspace.taskPaneRepositoryEditClickState = null;
+      },
+      clearHomePaneDragState: () => {
+        options.workspace.homePaneDragState = null;
+      },
+      getTaskRepositoryDropdownOpen: () => options.workspace.taskRepositoryDropdownOpen,
+      setTaskRepositoryDropdownOpen: (open) => {
+        options.workspace.taskRepositoryDropdownOpen = open;
+      },
+      taskIdAtRow: (rowIndex) =>
+        options.taskPaneTaskIdAtRow(options.workspace.latestTaskPaneView, rowIndex),
+      repositoryIdAtRow: (rowIndex) =>
+        options.taskPaneRepositoryIdAtRow(options.workspace.latestTaskPaneView, rowIndex),
+      selectTaskById: options.selectTaskById,
+      selectRepositoryById: options.selectRepositoryById,
+      runTaskPaneAction: (action) => {
+        options.workspaceActions.runTaskPaneAction(action);
+      },
+      nowMs,
+      homePaneEditDoubleClickWindowMs: options.homePaneEditDoubleClickWindowMs,
+      getTaskEditClickState: () => options.workspace.taskPaneTaskEditClickState,
+      getRepositoryEditClickState: () => options.workspace.taskPaneRepositoryEditClickState,
+      clearTaskPaneNotice: () => {
+        options.workspace.taskPaneNotice = null;
+      },
+      setTaskEditClickState: (next) => {
+        options.workspace.taskPaneTaskEditClickState = next;
+      },
+      setRepositoryEditClickState: (next) => {
+        options.workspace.taskPaneRepositoryEditClickState = next;
+      },
+      setHomePaneDragState: (next) => {
+        options.workspace.homePaneDragState = next;
+      },
+      openTaskEditPrompt: (taskId) => {
+        options.workspaceActions.openTaskEditPrompt(taskId);
+      },
+      openRepositoryPromptForEdit: (repositoryId) => {
+        options.workspaceActions.openRepositoryPromptForEdit(repositoryId);
+      },
+      markDirty: options.markDirty,
+    });
+
+    const pointerRoutingInput = createPointerRoutingInput({
+      getPaneDividerDragActive: () => options.workspace.paneDividerDragActive,
+      setPaneDividerDragActive: (active) => {
+        options.workspace.paneDividerDragActive = active;
+      },
+      applyPaneDividerAtCol: options.applyPaneDividerAtCol,
+      getHomePaneDragState: () => options.workspace.homePaneDragState,
+      setHomePaneDragState: (next) => {
+        options.workspace.homePaneDragState = next;
+      },
+      getMainPaneMode: () => options.workspace.mainPaneMode,
+      taskIdAtRow: (index) =>
+        options.taskPaneTaskIdAtRow(options.workspace.latestTaskPaneView, index),
+      repositoryIdAtRow: (index) =>
+        options.taskPaneRepositoryIdAtRow(options.workspace.latestTaskPaneView, index),
+      reorderTaskByDrop: (draggedTaskId, targetTaskId) => {
+        options.workspaceActions.reorderTaskByDrop(draggedTaskId, targetTaskId);
+      },
+      reorderRepositoryByDrop: (draggedRepositoryId, targetRepositoryId) => {
+        options.workspaceActions.reorderRepositoryByDrop(draggedRepositoryId, targetRepositoryId);
+      },
+      onProjectWheel: (delta) => {
+        options.workspace.projectPaneScrollTop = Math.max(
+          0,
+          options.workspace.projectPaneScrollTop + delta,
+        );
+      },
+      onHomeWheel: (delta) => {
+        options.workspace.taskPaneScrollTop = Math.max(
+          0,
+          options.workspace.taskPaneScrollTop + delta,
+        );
+      },
+      markDirty: options.markDirty,
+    });
+
+    const conversationSelectionInput = createConversationSelectionInput({
+      getSelection: () => options.workspace.selection,
+      setSelection: (next) => {
+        options.workspace.selection = next;
+      },
+      getSelectionDrag: () => options.workspace.selectionDrag,
+      setSelectionDrag: (next) => {
+        options.workspace.selectionDrag = next;
+      },
+      pinViewportForSelection: options.pinViewportForSelection,
+      releaseViewportPinForSelection: options.releaseViewportPinForSelection,
+      markDirty: options.markDirty,
+    });
+
+    this.inputTokenRouter = createInputTokenRouter({
+      getMainPaneMode: () => options.workspace.mainPaneMode,
+      pointerRoutingInput,
+      mainPanePointerInput,
+      leftRailPointerInput: options.leftRailPointerInput,
+      conversationSelectionInput,
+    });
+  }
+
+  routeTokens(input: RouteTokensInput): RouteTokensResult {
+    return this.inputTokenRouter.routeTokens(input);
+  }
+}