@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/runtime-render-lifecycle.ts

@@ -4,7 +4,7 @@ interface ScreenLike {
   markDirty(): void;
 }
 
-interface RuntimeRenderLifecycleOptions {
+export interface RuntimeRenderLifecycleOptions {
   readonly screen: ScreenLike;
   readonly render: () => void;
   readonly isShuttingDown: () => boolean;
@@ -21,84 +21,85 @@ interface RuntimeRenderLifecycleOptions {
 
 const FATAL_EXIT_DELAY_MS = 1200;
 
-export class RuntimeRenderLifecycle {
-  private readonly setImmediateFn: (callback: () => void) => void;
-  private readonly setTimeoutFn: (
-    callback: () => void,
-    delayMs: number,
-  ) => ReturnType<typeof setTimeout>;
-  private readonly clearTimeoutFn: (timer: ReturnType<typeof setTimeout>) => void;
-  private renderScheduled = false;
-  private runtimeFatal: { origin: string; error: unknown } | null = null;
-  private runtimeFatalExitTimer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor(private readonly options: RuntimeRenderLifecycleOptions) {
-    this.setImmediateFn = options.setImmediateFn ?? setImmediate;
-    this.setTimeoutFn = options.setTimeoutFn ?? setTimeout;
-    this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
-  }
-
-  hasFatal(): boolean {
-    return this.runtimeFatal !== null;
-  }
-
-  clearRenderScheduled(): void {
-    this.renderScheduled = false;
-  }
-
-  clearRuntimeFatalExitTimer(): void {
-    if (this.runtimeFatalExitTimer === null) {
-      return;
-    }
-    this.clearTimeoutFn(this.runtimeFatalExitTimer);
-    this.runtimeFatalExitTimer = null;
-  }
+export interface RuntimeRenderLifecycle {
+  hasFatal(): boolean;
+  clearRenderScheduled(): void;
+  clearRuntimeFatalExitTimer(): void;
+  markDirty(): void;
+  scheduleRender(): void;
+  handleRuntimeFatal(origin: string, error: unknown): void;
+}
 
-  markDirty(): void {
-    if (this.options.isShuttingDown()) {
-      return;
-    }
-    this.options.screen.markDirty();
-    this.scheduleRender();
-  }
+export function createRuntimeRenderLifecycle(
+  options: RuntimeRenderLifecycleOptions,
+): RuntimeRenderLifecycle {
+  const setImmediateFn = options.setImmediateFn ?? setImmediate;
+  const setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+  const clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
+  let renderScheduled = false;
+  let runtimeFatal: { origin: string; error: unknown } | null = null;
+  let runtimeFatalExitTimer: ReturnType<typeof setTimeout> | null = null;
 
-  scheduleRender(): void {
-    if (this.options.isShuttingDown() || this.renderScheduled) {
+  const scheduleRender = (): void => {
+    if (options.isShuttingDown() || renderScheduled) {
       return;
     }
-    this.renderScheduled = true;
-    this.setImmediateFn(() => {
-      this.renderScheduled = false;
+    renderScheduled = true;
+    setImmediateFn(() => {
+      renderScheduled = false;
       try {
-        this.options.render();
-        if (this.options.screen.isDirty()) {
-          this.scheduleRender();
+        options.render();
+        if (options.screen.isDirty()) {
+          scheduleRender();
         }
       } catch (error: unknown) {
-        this.handleRuntimeFatal('render', error);
+        handleRuntimeFatal('render', error);
       }
     });
-  }
+  };
 
-  handleRuntimeFatal(origin: string, error: unknown): void {
-    if (this.runtimeFatal !== null) {
+  const handleRuntimeFatal = (origin: string, error: unknown): void => {
+    if (runtimeFatal !== null) {
       return;
     }
-    this.runtimeFatal = {
+    runtimeFatal = {
       origin,
       error,
     };
-    this.options.setShuttingDown(true);
-    this.options.setStop(true);
-    this.options.screen.clearDirty();
-    this.options.writeStderr(
-      `[mux] fatal runtime error (${origin}): ${this.options.formatErrorMessage(error)}\n`,
+    options.setShuttingDown(true);
+    options.setStop(true);
+    options.screen.clearDirty();
+    options.writeStderr(
+      `[mux] fatal runtime error (${origin}): ${options.formatErrorMessage(error)}\n`,
     );
-    this.options.restoreTerminalState();
-    this.runtimeFatalExitTimer = this.setTimeoutFn(() => {
-      this.options.writeStderr('[mux] fatal runtime error forced exit\n');
-      this.options.exitProcess(1);
+    options.restoreTerminalState();
+    runtimeFatalExitTimer = setTimeoutFn(() => {
+      options.writeStderr('[mux] fatal runtime error forced exit\n');
+      options.exitProcess(1);
     }, FATAL_EXIT_DELAY_MS);
-    this.runtimeFatalExitTimer.unref?.();
-  }
+    runtimeFatalExitTimer.unref?.();
+  };
+
+  return {
+    hasFatal: (): boolean => runtimeFatal !== null,
+    clearRenderScheduled: (): void => {
+      renderScheduled = false;
+    },
+    clearRuntimeFatalExitTimer: (): void => {
+      if (runtimeFatalExitTimer === null) {
+        return;
+      }
+      clearTimeoutFn(runtimeFatalExitTimer);
+      runtimeFatalExitTimer = null;
+    },
+    markDirty: (): void => {
+      if (options.isShuttingDown()) {
+        return;
+      }
+      options.screen.markDirty();
+      scheduleRender();
+    },
+    scheduleRender,
+    handleRuntimeFatal,
+  };
 }

package/src/services/runtime-render-orchestrator.ts

@@ -1,6 +1,7 @@
 interface RuntimeRenderStateResult<TConversation, TFrame, TSelection> {
   readonly projectPaneActive: boolean;
   readonly homePaneActive: boolean;
+  readonly nimPaneActive: boolean;
   readonly activeConversation: TConversation | null;
   readonly rightFrame: TFrame | null;
   readonly renderSelection: TSelection | null;
@@ -12,28 +13,35 @@ interface RuntimeLeftRailRenderResult<TRailViewRows> {
   readonly viewRows: TRailViewRows;
 }
 
-interface RuntimeRenderOrchestratorOptions<
+export interface RuntimeRenderOrchestratorOptions<
   TLayout,
   TConversation,
   TFrame,
   TSelection,
   TSelectionDrag,
   TRailViewRows,
+  TRenderSnapshot,
 > {
   readonly isScreenDirty: () => boolean;
   readonly clearDirty: () => void;
+  readonly readRenderSnapshot: () => TRenderSnapshot;
   readonly prepareRenderState: (
     selection: TSelection | null,
     selectionDrag: TSelectionDrag | null,
   ) => RuntimeRenderStateResult<TConversation, TFrame, TSelection> | null;
-  readonly renderLeftRail: (layout: TLayout) => RuntimeLeftRailRenderResult<TRailViewRows>;
+  readonly renderLeftRail: (
+    layout: TLayout,
+    snapshot: TRenderSnapshot,
+  ) => RuntimeLeftRailRenderResult<TRailViewRows>;
   readonly setLatestRailViewRows: (rows: TRailViewRows) => void;
   readonly renderRightRows: (input: {
     layout: TLayout;
     rightFrame: TFrame | null;
     homePaneActive: boolean;
+    nimPaneActive: boolean;
     projectPaneActive: boolean;
     activeDirectoryId: string | null;
+    snapshot: TRenderSnapshot;
   }) => readonly string[];
   readonly flushRender: (input: {
     layout: TLayout;
@@ -49,60 +57,62 @@ interface RuntimeRenderOrchestratorOptions<
   readonly activeDirectoryId: () => string | null;
 }
 
-interface RuntimeRenderOrchestratorInput<TLayout, TSelection, TSelectionDrag> {
+export interface RuntimeRenderOrchestratorInput<TLayout, TSelection, TSelectionDrag> {
   readonly shuttingDown: boolean;
   readonly layout: TLayout;
   readonly selection: TSelection | null;
   readonly selectionDrag: TSelectionDrag | null;
 }
 
-export class RuntimeRenderOrchestrator<
+export function orchestrateRuntimeRender<
   TLayout,
   TConversation,
   TFrame,
   TSelection,
   TSelectionDrag,
   TRailViewRows,
-> {
-  constructor(
-    private readonly options: RuntimeRenderOrchestratorOptions<
-      TLayout,
-      TConversation,
-      TFrame,
-      TSelection,
-      TSelectionDrag,
-      TRailViewRows
-    >,
-  ) {}
-
-  render(input: RuntimeRenderOrchestratorInput<TLayout, TSelection, TSelectionDrag>): void {
-    if (input.shuttingDown || !this.options.isScreenDirty()) {
-      return;
-    }
-    const renderState = this.options.prepareRenderState(input.selection, input.selectionDrag);
-    if (renderState === null) {
-      this.options.clearDirty();
-      return;
-    }
-    const rail = this.options.renderLeftRail(input.layout);
-    this.options.setLatestRailViewRows(rail.viewRows);
-    const rightRows = this.options.renderRightRows({
-      layout: input.layout,
-      rightFrame: renderState.rightFrame,
-      homePaneActive: renderState.homePaneActive,
-      projectPaneActive: renderState.projectPaneActive,
-      activeDirectoryId: this.options.activeDirectoryId(),
-    });
-    this.options.flushRender({
-      layout: input.layout,
-      projectPaneActive: renderState.projectPaneActive,
-      homePaneActive: renderState.homePaneActive,
-      activeConversation: renderState.activeConversation,
-      rightFrame: renderState.rightFrame,
-      renderSelection: renderState.renderSelection,
-      selectionRows: renderState.selectionRows,
-      railAnsiRows: rail.ansiRows,
-      rightRows,
-    });
+  TRenderSnapshot,
+>(
+  options: RuntimeRenderOrchestratorOptions<
+    TLayout,
+    TConversation,
+    TFrame,
+    TSelection,
+    TSelectionDrag,
+    TRailViewRows,
+    TRenderSnapshot
+  >,
+  input: RuntimeRenderOrchestratorInput<TLayout, TSelection, TSelectionDrag>,
+): void {
+  if (input.shuttingDown || !options.isScreenDirty()) {
+    return;
+  }
+  const renderState = options.prepareRenderState(input.selection, input.selectionDrag);
+  if (renderState === null) {
+    options.clearDirty();
+    return;
   }
+  const snapshot = options.readRenderSnapshot();
+  const rail = options.renderLeftRail(input.layout, snapshot);
+  options.setLatestRailViewRows(rail.viewRows);
+  const rightRows = options.renderRightRows({
+    layout: input.layout,
+    rightFrame: renderState.rightFrame,
+    homePaneActive: renderState.homePaneActive,
+    nimPaneActive: renderState.nimPaneActive,
+    projectPaneActive: renderState.projectPaneActive,
+    activeDirectoryId: options.activeDirectoryId(),
+    snapshot,
+  });
+  options.flushRender({
+    layout: input.layout,
+    projectPaneActive: renderState.projectPaneActive,
+    homePaneActive: renderState.homePaneActive,
+    activeConversation: renderState.activeConversation,
+    rightFrame: renderState.rightFrame,
+    renderSelection: renderState.renderSelection,
+    selectionRows: renderState.selectionRows,
+    railAnsiRows: rail.ansiRows,
+    rightRows,
+  });
 }

package/src/services/runtime-render-pipeline.ts

@@ -5,57 +5,46 @@ import type {
   TaskFocusedPaneTaskRecord,
 } from '../mux/task-focused-pane.ts';
 import type { TerminalSnapshotFrameCore } from '../terminal/snapshot-oracle.ts';
-import { RuntimeLeftRailRender } from './runtime-left-rail-render.ts';
-import { RuntimeRenderFlush } from './runtime-render-flush.ts';
-import { RuntimeRenderOrchestrator } from './runtime-render-orchestrator.ts';
-import { RuntimeRenderState } from './runtime-render-state.ts';
-import { RuntimeRightPaneRender } from './runtime-right-pane-render.ts';
+import {
+  renderRuntimeLeftRail,
+  type RuntimeLeftRailRenderOptions,
+  type RuntimeLeftRailRenderSnapshot,
+} from './runtime-left-rail-render.ts';
+import { flushRuntimeRender, type RuntimeRenderFlushOptions } from './runtime-render-flush.ts';
+import {
+  orchestrateRuntimeRender,
+  type RuntimeRenderOrchestratorInput,
+  type RuntimeRenderOrchestratorOptions,
+} from './runtime-render-orchestrator.ts';
+import {
+  prepareRuntimeRenderState,
+  type RuntimeRenderStateOptions,
+} from './runtime-render-state.ts';
+import {
+  renderRuntimeRightPaneRows,
+  type RuntimeRightPaneRenderOptions,
+  type RuntimeRightPaneRenderSnapshot,
+} from './runtime-right-pane-render.ts';
 
 type RuntimeLayout = ReturnType<typeof computeDualPaneLayout>;
 
-type RuntimeRenderFlushOptions<TConversation, TModalOverlay, TStatusRow> = ConstructorParameters<
-  typeof RuntimeRenderFlush<
-    TConversation,
-    TerminalSnapshotFrameCore,
-    PaneSelection,
-    RuntimeLayout,
-    TModalOverlay,
-    TStatusRow
-  >
->[0];
-
-type RuntimeRightPaneRenderOptions<
-  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
-  TTaskRecord extends TaskFocusedPaneTaskRecord,
-> = ConstructorParameters<typeof RuntimeRightPaneRender<TRepositoryRecord, TTaskRecord>>[0];
-
-type RuntimeLeftRailRenderOptions<
+export interface RuntimeRenderPipelineSnapshot<
   TDirectoryRecord,
   TConversation,
-  TRepositoryRecord,
-  TRepositorySnapshot,
-  TGitSummary,
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
   TProcessUsage,
-  TShortcutBindings,
-  TRailViewRows,
-> = ConstructorParameters<
-  typeof RuntimeLeftRailRender<
+> {
+  readonly leftRail: RuntimeLeftRailRenderSnapshot<
     TDirectoryRecord,
     TConversation,
     TRepositoryRecord,
-    TRepositorySnapshot,
-    TGitSummary,
-    TProcessUsage,
-    TShortcutBindings,
-    TRailViewRows
-  >
->[0];
-
-type RuntimeRenderStateOptions<TConversation> = ConstructorParameters<
-  typeof RuntimeRenderState<TConversation, TerminalSnapshotFrameCore>
->[0];
+    TProcessUsage
+  >;
+  readonly rightPane: RuntimeRightPaneRenderSnapshot<TRepositoryRecord, TTaskRecord>;
+}
 
-interface RuntimeRenderPipelineOptions<
+export interface RuntimeRenderPipelineOptions<
   TConversation,
   TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
   TTaskRecord extends TaskFocusedPaneTaskRecord,
@@ -63,12 +52,18 @@ interface RuntimeRenderPipelineOptions<
   TRepositorySnapshot,
   TGitSummary,
   TProcessUsage,
-  TShortcutBindings,
   TRailViewRows,
   TModalOverlay,
   TStatusRow,
 > {
-  readonly renderFlush: RuntimeRenderFlushOptions<TConversation, TModalOverlay, TStatusRow>;
+  readonly renderFlush: RuntimeRenderFlushOptions<
+    TConversation,
+    TerminalSnapshotFrameCore,
+    PaneSelection,
+    RuntimeLayout,
+    TModalOverlay,
+    TStatusRow
+  >;
   readonly rightPaneRender: RuntimeRightPaneRenderOptions<TRepositoryRecord, TTaskRecord>;
   readonly leftRailRender: RuntimeLeftRailRenderOptions<
     TDirectoryRecord,
@@ -77,28 +72,30 @@ interface RuntimeRenderPipelineOptions<
     TRepositorySnapshot,
     TGitSummary,
     TProcessUsage,
-    TShortcutBindings,
     TRailViewRows
   >;
-  readonly renderState: RuntimeRenderStateOptions<TConversation>;
+  readonly renderState: RuntimeRenderStateOptions<TConversation, TerminalSnapshotFrameCore>;
   readonly isScreenDirty: () => boolean;
   readonly clearDirty: () => void;
+  // Frame-local TUI snapshot read. React/web adapters should consume store selectors directly.
+  readonly readRenderSnapshot: () => RuntimeRenderPipelineSnapshot<
+    TDirectoryRecord,
+    TConversation,
+    TRepositoryRecord,
+    TTaskRecord,
+    TProcessUsage
+  >;
   readonly setLatestRailViewRows: (rows: TRailViewRows) => void;
   readonly activeDirectoryId: () => string | null;
 }
 
-type RuntimeRenderPipelineInput = Parameters<
-  RuntimeRenderOrchestrator<
-    RuntimeLayout,
-    unknown,
-    TerminalSnapshotFrameCore,
-    PaneSelection,
-    PaneSelectionDrag,
-    unknown
-  >['render']
->[0];
+type RuntimeRenderPipelineInput = RuntimeRenderOrchestratorInput<
+  RuntimeLayout,
+  PaneSelection,
+  PaneSelectionDrag
+>;
 
-export class RuntimeRenderPipeline<
+export function createRuntimeRenderPipeline<
   TConversation,
   TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
   TTaskRecord extends TaskFocusedPaneTaskRecord,
@@ -106,62 +103,68 @@ export class RuntimeRenderPipeline<
   TRepositorySnapshot,
   TGitSummary,
   TProcessUsage,
-  TShortcutBindings,
   TRailViewRows,
   TModalOverlay,
   TStatusRow,
-> {
-  private readonly renderOrchestrator: RuntimeRenderOrchestrator<
+>(
+  options: RuntimeRenderPipelineOptions<
+    TConversation,
+    TRepositoryRecord,
+    TTaskRecord,
+    TDirectoryRecord,
+    TRepositorySnapshot,
+    TGitSummary,
+    TProcessUsage,
+    TRailViewRows,
+    TModalOverlay,
+    TStatusRow
+  >,
+): (input: RuntimeRenderPipelineInput) => void {
+  const renderOrchestratorOptions: RuntimeRenderOrchestratorOptions<
     RuntimeLayout,
     TConversation,
     TerminalSnapshotFrameCore,
     PaneSelection,
     PaneSelectionDrag,
-    TRailViewRows
-  >;
-
-  constructor(
-    options: RuntimeRenderPipelineOptions<
+    TRailViewRows,
+    RuntimeRenderPipelineSnapshot<
+      TDirectoryRecord,
       TConversation,
       TRepositoryRecord,
       TTaskRecord,
-      TDirectoryRecord,
-      TRepositorySnapshot,
-      TGitSummary,
-      TProcessUsage,
-      TShortcutBindings,
-      TRailViewRows,
-      TModalOverlay,
-      TStatusRow
-    >,
-  ) {
-    const renderFlush = new RuntimeRenderFlush(options.renderFlush);
-    const rightPaneRender = new RuntimeRightPaneRender(options.rightPaneRender);
-    const leftRailRender = new RuntimeLeftRailRender(options.leftRailRender);
-    const renderState = new RuntimeRenderState(options.renderState);
-    this.renderOrchestrator = new RuntimeRenderOrchestrator({
-      isScreenDirty: options.isScreenDirty,
-      clearDirty: options.clearDirty,
-      prepareRenderState: (selection, selectionDrag) =>
-        renderState.prepareRenderState(selection, selectionDrag),
-      renderLeftRail: (layout) => leftRailRender.render(layout),
-      setLatestRailViewRows: options.setLatestRailViewRows,
-      renderRightRows: (input) =>
-        rightPaneRender.renderRightRows({
-          layout: input.layout,
-          rightFrame: input.rightFrame,
-          homePaneActive: input.homePaneActive,
-          projectPaneActive: input.projectPaneActive,
-          activeDirectoryId: input.activeDirectoryId,
-        }),
-      flushRender: (input) => {
-        renderFlush.flushRender(input);
-      },
-      activeDirectoryId: options.activeDirectoryId,
-    });
-  }
-
-  render(input: RuntimeRenderPipelineInput): void {
-    this.renderOrchestrator.render(input);
-  }
+      TProcessUsage
+    >
+  > = {
+    isScreenDirty: options.isScreenDirty,
+    clearDirty: options.clearDirty,
+    readRenderSnapshot: options.readRenderSnapshot,
+    prepareRenderState: (selection, selectionDrag) => {
+      return prepareRuntimeRenderState(options.renderState, selection, selectionDrag);
+    },
+    renderLeftRail: (layout, snapshot) => {
+      return renderRuntimeLeftRail(options.leftRailRender, {
+        layout,
+        snapshot: snapshot.leftRail,
+      });
+    },
+    setLatestRailViewRows: options.setLatestRailViewRows,
+    renderRightRows: (input) => {
+      return renderRuntimeRightPaneRows(options.rightPaneRender, {
+        layout: input.layout,
+        rightFrame: input.rightFrame,
+        homePaneActive: input.homePaneActive,
+        nimPaneActive: input.nimPaneActive,
+        projectPaneActive: input.projectPaneActive,
+        activeDirectoryId: input.activeDirectoryId,
+        snapshot: input.snapshot.rightPane,
+      });
+    },
+    flushRender: (input) => {
+      flushRuntimeRender(options.renderFlush, input);
+    },
+    activeDirectoryId: options.activeDirectoryId,
+  };
+  return (input: RuntimeRenderPipelineInput): void => {
+    orchestrateRuntimeRender(renderOrchestratorOptions, input);
+  };
 }