mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/ink/src/frame.ts

@@ -0,0 +1,105 @@
+import type { Cursor } from './cursor.js';
+import type { Size } from './layout/geometry.js';
+import type { ScrollHint } from './render-node-to-output.js';
+import {
+  type CharPool,
+  createScreen,
+  type HyperlinkPool,
+  type Screen,
+  type StylePool,
+} from './screen.js';
+
+/** Immutable snapshot of one rendered frame. */
+export type Frame = {
+  readonly screen: Screen;
+  readonly viewport: Size;
+  readonly cursor: Cursor;
+  /** DECSTBM scroll-optimisation hint. Set only in alt-screen mode. */
+  readonly scrollHint?: ScrollHint | null;
+  /** A ScrollBox has remaining `pendingScrollDelta` — schedule one more frame. */
+  readonly scrollDrainPending?: boolean;
+};
+
+export function emptyFrame(
+  rows: number,
+  columns: number,
+  stylePool: StylePool,
+  charPool: CharPool,
+  hyperlinkPool: HyperlinkPool,
+): Frame {
+  return {
+    screen: createScreen(0, 0, stylePool, charPool, hyperlinkPool),
+    viewport: { width: columns, height: rows },
+    cursor: { x: 0, y: 0, visible: true },
+  };
+}
+
+export type FlickerReason = 'resize' | 'offscreen' | 'clear';
+
+export type FrameEvent = {
+  durationMs: number;
+  /** Per-phase breakdown. */
+  phases?: {
+    /** DOM → Yoga → screen buffer pipeline cost. */
+    renderer: number;
+    /** `LogUpdate.render()` — screen diff to Patch list. */
+    diff: number;
+    /** `optimize()` — patch merge / dedupe pass. */
+    optimize: number;
+    /** `writeDiffToTerminal()` — patch list to ANSI to stdout. */
+    write: number;
+    /** Pre-optimise patch count — proxy for "how much changed". */
+    patches: number;
+    /** `yoga.calculateLayout()` from `resetAfterCommit`. */
+    yoga: number;
+    /** React reconcile, `scrollMutated` → `resetAfterCommit`. 0 with no commit. */
+    commit: number;
+    /** `layoutNode()` recursive call count, including cache hits. */
+    yogaVisited: number;
+    /** Calls to the expensive text-measure path. */
+    yogaMeasured: number;
+    /** Hits on the per-node single-slot measurement cache. */
+    yogaCacheHits: number;
+    /** Live Yoga node count (creates − frees). Sustained growth = leak. */
+    yogaLive: number;
+  };
+  /** Frames where the renderer had to clear because the diff alone wouldn't work. */
+  flickers: Array<{
+    desiredHeight: number;
+    availableHeight: number;
+    reason: FlickerReason;
+  }>;
+};
+
+export type Patch =
+  | { type: 'stdout'; content: string }
+  | { type: 'clear'; count: number }
+  | {
+      type: 'clearTerminal';
+      reason: FlickerReason;
+      /** Set by log-update when a scrollback diff triggered the reset. */
+      debug?: { triggerY: number; prevLine: string; nextLine: string };
+    }
+  | { type: 'cursorHide' }
+  | { type: 'cursorShow' }
+  | { type: 'cursorMove'; x: number; y: number }
+  | { type: 'cursorTo'; col: number }
+  | { type: 'carriageReturn' }
+  | { type: 'hyperlink'; uri: string }
+  | { type: 'styleStr'; str: string };
+
+export type Diff = Patch[];
+
+/** Decide whether the next frame requires a hard clear before patching. */
+export function shouldClearScreen(prevFrame: Frame, frame: Frame): FlickerReason | undefined {
+  const resized =
+    frame.viewport.height !== prevFrame.viewport.height ||
+    frame.viewport.width !== prevFrame.viewport.width;
+  if (resized) return 'resize';
+
+  const overflowsNow = frame.screen.height >= frame.viewport.height;
+  const overflowedBefore = prevFrame.screen.height >= prevFrame.viewport.height;
+  if (overflowsNow || overflowedBefore) return 'offscreen';
+
+  return undefined;
+}

package/node_modules/ink/src/get-max-width.ts

@@ -0,0 +1,10 @@
+import { LayoutEdge, type LayoutNode } from './layout/node.js';
+
+const getMaxWidth = (yogaNode: LayoutNode): number =>
+  yogaNode.getComputedWidth() -
+  yogaNode.getComputedPadding(LayoutEdge.Left) -
+  yogaNode.getComputedPadding(LayoutEdge.Right) -
+  yogaNode.getComputedBorder(LayoutEdge.Left) -
+  yogaNode.getComputedBorder(LayoutEdge.Right);
+
+export default getMaxWidth;

package/node_modules/ink/src/hit-test.ts

@@ -0,0 +1,107 @@
+import type { DOMElement } from './dom.js';
+import { ClickEvent } from './events/click-event.js';
+import type { EventHandlerProps } from './events/event-handlers.js';
+import { nodeCache } from './node-cache.js';
+
+/** Find the deepest DOM element whose painted rectangle contains (col, row). */
+export function hitTest(
+  node: DOMElement,
+  col: number,
+  row: number,
+): DOMElement | null {
+  const rect = nodeCache.get(node);
+  if (!rect) return null;
+  if (
+    col < rect.x ||
+    col >= rect.x + rect.width ||
+    row < rect.y ||
+    row >= rect.y + rect.height
+  ) {
+    return null;
+  }
+  for (let i = node.childNodes.length - 1; i >= 0; i--) {
+    const child = node.childNodes[i]!;
+    if (child.nodeName === '#text') continue;
+    const hit = hitTest(child, col, row);
+    if (hit) return hit;
+  }
+  return node;
+}
+
+/** Dispatch a synthetic click at (col, row) against the rendered tree. */
+export function dispatchClick(
+  root: DOMElement,
+  col: number,
+  row: number,
+  cellIsBlank = false,
+): boolean {
+  let target: DOMElement | undefined = hitTest(root, col, row) ?? undefined;
+  if (!target) return false;
+
+  // The root is always ink-root, which holds the FocusManager. Walk up
+  // looking for a focusable ancestor and promote it.
+  if (root.focusManager) {
+    let focusTarget: DOMElement | undefined = target;
+    while (focusTarget) {
+      if (typeof focusTarget.attributes['tabIndex'] === 'number') {
+        root.focusManager.handleClickFocus(focusTarget);
+        break;
+      }
+      focusTarget = focusTarget.parentNode;
+    }
+  }
+  const event = new ClickEvent(col, row, cellIsBlank);
+  let handled = false;
+  while (target) {
+    const handler = target._eventHandlers?.onClick as
+      | ((event: ClickEvent) => void)
+      | undefined;
+    if (handler) {
+      handled = true;
+      // Recompute local coordinates for each handler — they're relative
+      // to the element actually handling the event, not the original hit.
+      const rect = nodeCache.get(target);
+      if (rect) {
+        event.localCol = col - rect.x;
+        event.localRow = row - rect.y;
+      }
+      handler(event);
+      if (event.didStopImmediatePropagation()) return true;
+    }
+    target = target.parentNode;
+  }
+  return handled;
+}
+
+/** Fire onMouseEnter / onMouseLeave as the pointer moves over the tree. */
+export function dispatchHover(
+  root: DOMElement,
+  col: number,
+  row: number,
+  hovered: Set<DOMElement>,
+): void {
+  const next = new Set<DOMElement>();
+  let node: DOMElement | undefined = hitTest(root, col, row) ?? undefined;
+  while (node) {
+    const h = node._eventHandlers as EventHandlerProps | undefined;
+    if (h?.onMouseEnter || h?.onMouseLeave) next.add(node);
+    node = node.parentNode;
+  }
+  for (const old of hovered) {
+    if (!next.has(old)) {
+      hovered.delete(old);
+      // If the node was unmounted between pointer events, it has no
+      // parent any more; skip the handler rather than firing into a
+      // detached subtree.
+      if (old.parentNode) {
+        (old._eventHandlers as EventHandlerProps | undefined)?.onMouseLeave?.();
+      }
+    }
+  }
+  for (const n of next) {
+    if (!hovered.has(n)) {
+      hovered.add(n);
+      (n._eventHandlers as EventHandlerProps | undefined)?.onMouseEnter?.();
+    }
+  }
+}

package/node_modules/ink/src/hooks/use-animation-frame.ts

@@ -0,0 +1,33 @@
+import { useContext, useEffect, useState } from 'react'
+import { ClockContext } from '../components/ClockContext.js'
+import type { DOMElement } from '../dom.js'
+import { useTerminalViewport } from './use-terminal-viewport.js'
+
+export function useAnimationFrame(
+  intervalMs: number | null = 16,
+): [ref: (element: DOMElement | null) => void, time: number] {
+  const clock = useContext(ClockContext)
+  const [viewportRef, { isVisible }] = useTerminalViewport()
+  const [time, setTime] = useState(() => clock?.now() ?? 0)
+
+  const active = isVisible && intervalMs !== null
+
+  useEffect(() => {
+    if (!clock || !active) return
+
+    let lastUpdate = clock.now()
+
+    const onChange = (): void => {
+      const now = clock.now()
+      if (now - lastUpdate >= intervalMs!) {
+        lastUpdate = now
+        setTime(now)
+      }
+    }
+
+    // keepAlive: true — a visible animation owns the clock's awake state.
+    return clock.subscribe(onChange, true)
+  }, [clock, intervalMs, active])
+
+  return [viewportRef, time]
+}

package/node_modules/ink/src/hooks/use-app.ts

@@ -0,0 +1,6 @@
+import { useContext } from 'react'
+import AppContext, { type Props as AppContextValue } from '../components/AppContext.js'
+
+/** Access the app-level exit handle. */
+const useApp = (): AppContextValue => useContext(AppContext)
+export default useApp

package/node_modules/ink/src/hooks/use-declared-cursor.ts

@@ -0,0 +1,59 @@
+import { useCallback, useContext, useLayoutEffect, useRef } from 'react'
+import CursorDeclarationContext from '../components/CursorDeclarationContext.js'
+import type { DOMElement } from '../dom.js'
+
+type UseDeclaredCursorOptions = {
+  line: number
+  column: number
+  active: boolean
+}
+
+export function useDeclaredCursor({
+  line,
+  column,
+  active,
+}: UseDeclaredCursorOptions): (element: DOMElement | null) => void {
+  const setCursorDeclaration = useContext(CursorDeclarationContext)
+  const nodeRef = useRef<DOMElement | null>(null)
+
+  const setNode = useCallback((node: DOMElement | null) => {
+    nodeRef.current = node
+  }, [])
+
+  // When active, set unconditionally. When inactive, clear only if the
+  // currently-declared node is ours — the node-identity check guards two
+  // hazards:
+  //
+  //   1. A memoized active instance elsewhere (e.g. a search input inside
+  //      a memo'd Footer) doesn't re-render this commit; an inactive
+  //      instance re-rendering here must not clobber it.
+  //   2. Sibling handoff (menu focus moving between list items) — when
+  //      focus moves opposite to sibling order, the newly-inactive item's
+  //      effect runs AFTER the newly-active item's set. Without the node
+  //      check it would clobber the freshly-claimed declaration.
+  //
+  // No dep array on purpose: this must re-declare every commit so the
+  // active instance can re-claim ownership after a peer's unmount cleanup
+  // or sibling handoff nulled it.
+  useLayoutEffect(() => {
+    const node = nodeRef.current
+    if (active && node) {
+      setCursorDeclaration({ relativeX: column, relativeY: line, node })
+    } else {
+      setCursorDeclaration(null, node)
+    }
+  })
+
+  // Unmount cleanup is conditional too — by the time we unmount, another
+  // instance may already own the declaration. Kept in a separate effect
+  // with `[setCursorDeclaration]` so the cleanup runs only once at
+  // unmount, never on every line/column change (which would transiently
+  // null the declaration between commits).
+  useLayoutEffect(() => {
+    return () => {
+      setCursorDeclaration(null, nodeRef.current)
+    }
+  }, [setCursorDeclaration])
+
+  return setNode
+}

package/node_modules/ink/src/hooks/use-input.ts

@@ -0,0 +1,57 @@
+import { useEffect, useLayoutEffect } from 'react'
+import { useEventCallback } from 'usehooks-ts'
+import type { InputEvent, Key } from '../events/input-event.js'
+import useStdin from './use-stdin.js'
+
+type InputHandler = (input: string, key: Key, event: InputEvent) => void
+
+type UseInputOptions = {
+  /** Gate the handler without unmounting it. */
+  isActive?: boolean
+}
+
+/** Subscribe to keyboard input from the active stdin stream. */
+const useInput = (inputHandler: InputHandler, options: UseInputOptions = {}): void => {
+  const { setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = useStdin()
+
+  // Layout-phase raw-mode toggle: see header comment for why this can't be
+  // a regular useEffect.
+  useLayoutEffect(() => {
+    if (options.isActive === false) {
+      return
+    }
+
+    setRawMode(true)
+
+    return () => {
+      setRawMode(false)
+    }
+  }, [options.isActive, setRawMode])
+
+  // Stable-identity dispatcher that reads the latest options/handler from
+  // closure. See header comment on listener ordering.
+  const handleData = useEventCallback((event: InputEvent) => {
+    if (options.isActive === false) {
+      return
+    }
+    const { input, key } = event
+
+    // Ctrl+C is the host's exit signal when exitOnCtrlC is on — only
+    // forward it to the user handler when they've opted out. The emitter
+    // already runs listeners inside a high-priority React update, so we
+    // don't need to wrap our setState calls here.
+    if (!(input === 'c' && key.ctrl) || !internal_exitOnCtrlC) {
+      inputHandler(input, key, event)
+    }
+  })
+
+  useEffect(() => {
+    internal_eventEmitter?.on('input', handleData)
+
+    return () => {
+      internal_eventEmitter?.removeListener('input', handleData)
+    }
+  }, [internal_eventEmitter, handleData])
+}
+
+export default useInput

package/node_modules/ink/src/hooks/use-interval.ts

@@ -0,0 +1,53 @@
+import { useContext, useEffect, useRef, useState } from 'react'
+import { ClockContext } from '../components/ClockContext.js'
+
+/** Sample the shared clock at a fixed cadence. */
+export function useAnimationTimer(intervalMs: number): number {
+  const clock = useContext(ClockContext)
+  const [time, setTime] = useState(() => clock?.now() ?? 0)
+
+  useEffect(() => {
+    if (!clock) return
+
+    let lastUpdate = clock.now()
+
+    const onChange = (): void => {
+      const now = clock.now()
+      if (now - lastUpdate >= intervalMs) {
+        lastUpdate = now
+        setTime(now)
+      }
+    }
+
+    return clock.subscribe(onChange, false)
+  }, [clock, intervalMs])
+
+  return time
+}
+
+/** Periodic callback driven by the shared clock. */
+export function useInterval(
+  callback: () => void,
+  intervalMs: number | null,
+): void {
+  const callbackRef = useRef(callback)
+  callbackRef.current = callback
+
+  const clock = useContext(ClockContext)
+
+  useEffect(() => {
+    if (!clock || intervalMs === null) return
+
+    let lastUpdate = clock.now()
+
+    const onChange = (): void => {
+      const now = clock.now()
+      if (now - lastUpdate >= intervalMs) {
+        lastUpdate = now
+        callbackRef.current()
+      }
+    }
+
+    return clock.subscribe(onChange, false)
+  }, [clock, intervalMs])
+}

package/node_modules/ink/src/hooks/use-search-highlight.ts

@@ -0,0 +1,41 @@
+import { useContext, useMemo } from 'react'
+import StdinContext from '../components/StdinContext.js'
+import type { DOMElement } from '../dom.js'
+import instances from '../instances.js'
+import type { MatchPosition } from '../render-to-screen.js'
+
+type SearchPositionsState = {
+  positions: MatchPosition[]
+  rowOffset: number
+  currentIdx: number
+}
+
+type SearchHighlightApi = {
+  /** Set the live query. */
+  setQuery: (query: string) => void
+
+  scanElement: (el: DOMElement) => MatchPosition[]
+
+  /** Drive the "current match" highlight from a position list. */
+  setPositions: (state: SearchPositionsState | null) => void
+}
+
+/** Bridge React-land to the Ink instance's search-overlay machinery. */
+export function useSearchHighlight(): SearchHighlightApi {
+  useContext(StdinContext) // anchor to the App subtree so hook rules apply
+  const ink = instances.get(process.stdout)
+  return useMemo<SearchHighlightApi>(() => {
+    if (!ink) {
+      return {
+        setQuery: () => {},
+        scanElement: () => [],
+        setPositions: () => {},
+      }
+    }
+    return {
+      setQuery: (query: string) => ink.setSearchHighlight(query),
+      scanElement: (el: DOMElement) => ink.scanElementSubtree(el),
+      setPositions: state => ink.setSearchPositions(state),
+    }
+  }, [ink])
+}

package/node_modules/ink/src/hooks/use-selection.ts

@@ -0,0 +1,86 @@
+import { useContext, useMemo, useSyncExternalStore } from 'react'
+import StdinContext from '../components/StdinContext.js'
+import instances from '../instances.js'
+import {
+  type FocusMove,
+  type SelectionState,
+  shiftAnchor,
+} from '../selection.js'
+
+type SelectionApi = {
+  copySelection: () => string
+  /** Copy without clearing the highlight (for copy-on-select). */
+  copySelectionNoClear: () => string
+  clearSelection: () => void
+  hasSelection: () => boolean
+  /** Read the raw mutable selection state (used by drag-to-scroll). */
+  getState: () => SelectionState | null
+  /** Subscribe to selection mutations (start/update/finish/clear). */
+  subscribe: (cb: () => void) => () => void
+  /** Shift the anchor row by `dRow`, clamped to `[minRow, maxRow]`. */
+  shiftAnchor: (dRow: number, minRow: number, maxRow: number) => void
+  shiftSelection: (dRow: number, minRow: number, maxRow: number) => void
+  moveFocus: (move: FocusMove) => void
+  /** Capture text from rows about to scroll out of the viewport. */
+  captureScrolledRows: (
+    firstRow: number,
+    lastRow: number,
+    side: 'above' | 'below',
+  ) => void
+  setSelectionBgColor: (color: string) => void
+}
+
+export function useSelection(): SelectionApi {
+  // The Ink instance is looked up by stdout to match `instances` map keying.
+  // StdinContext is always provided in an Ink tree, so reading it here
+  // anchors us to a valid App subtree (and keeps hook-rules linting happy)
+  // without paying for unused values.
+  useContext(StdinContext)
+  const ink = instances.get(process.stdout)
+  return useMemo<SelectionApi>(() => {
+    if (!ink) {
+      return {
+        copySelection: () => '',
+        copySelectionNoClear: () => '',
+        clearSelection: () => {},
+        hasSelection: () => false,
+        getState: () => null,
+        subscribe: () => () => {},
+        shiftAnchor: () => {},
+        shiftSelection: () => {},
+        moveFocus: () => {},
+        captureScrolledRows: () => {},
+        setSelectionBgColor: () => {},
+      }
+    }
+    return {
+      copySelection: () => ink.copySelection(),
+      copySelectionNoClear: () => ink.copySelectionNoClear(),
+      clearSelection: () => ink.clearTextSelection(),
+      hasSelection: () => ink.hasTextSelection(),
+      getState: () => ink.selection,
+      subscribe: (cb: () => void) => ink.subscribeToSelectionChange(cb),
+      shiftAnchor: (dRow: number, minRow: number, maxRow: number) =>
+        shiftAnchor(ink.selection, dRow, minRow, maxRow),
+      shiftSelection: (dRow, minRow, maxRow) =>
+        ink.shiftSelectionForScroll(dRow, minRow, maxRow),
+      moveFocus: (move: FocusMove) => ink.moveSelectionFocus(move),
+      captureScrolledRows: (firstRow, lastRow, side) =>
+        ink.captureScrolledRows(firstRow, lastRow, side),
+      setSelectionBgColor: (color: string) => ink.setSelectionBgColor(color),
+    }
+  }, [ink])
+}
+
+const NO_SUBSCRIBE = (): (() => void) => () => {}
+const ALWAYS_FALSE = (): boolean => false
+
+/** Reactive "is there a selection?" flag. */
+export function useHasSelection(): boolean {
+  useContext(StdinContext)
+  const ink = instances.get(process.stdout)
+  return useSyncExternalStore(
+    ink ? ink.subscribeToSelectionChange : NO_SUBSCRIBE,
+    ink ? ink.hasTextSelection : ALWAYS_FALSE,
+  )
+}

package/node_modules/ink/src/hooks/use-stdin.ts

@@ -0,0 +1,6 @@
+import { useContext } from 'react'
+import StdinContext, { type Props as StdinContextValue } from '../components/StdinContext.js'
+
+/** Access the stdin handle plus the raw-mode toggle that Ink owns. */
+const useStdin = (): StdinContextValue => useContext(StdinContext)
+export default useStdin

package/node_modules/ink/src/hooks/use-tab-status.ts

@@ -0,0 +1,68 @@
+import { useContext, useEffect, useRef } from 'react'
+import {
+  CLEAR_TAB_STATUS,
+  supportsTabStatus,
+  tabStatus,
+  wrapForMultiplexer,
+} from '../termio/osc.js'
+import type { Color } from '../termio/types.js'
+import { TerminalWriteContext } from '../useTerminalNotification.js'
+
+export type TabStatusKind = 'idle' | 'busy' | 'waiting'
+
+const rgb = (r: number, g: number, b: number): Color => ({
+  type: 'rgb',
+  r,
+  g,
+  b,
+})
+
+type TabStatusPreset = {
+  indicator: Color
+  status: string
+  statusColor: Color
+}
+
+// Mapping mirrors the suggested defaults from the OSC 21337 usage guide;
+// terminals that support the sequence render these as a tab-sidebar dot
+// plus a short label.
+const TAB_STATUS_PRESETS: Record<TabStatusKind, TabStatusPreset> = {
+  idle: {
+    indicator: rgb(0, 215, 95),
+    status: 'Idle',
+    statusColor: rgb(136, 136, 136),
+  },
+  busy: {
+    indicator: rgb(255, 149, 0),
+    status: 'Working…',
+    statusColor: rgb(255, 149, 0),
+  },
+  waiting: {
+    indicator: rgb(95, 135, 255),
+    status: 'Waiting',
+    statusColor: rgb(95, 135, 255),
+  },
+}
+
+/** Declaratively project a tab-status indicator into the terminal sidebar. */
+export function useTabStatus(kind: TabStatusKind | null): void {
+  const writeRaw = useContext(TerminalWriteContext)
+  const prevKindRef = useRef<TabStatusKind | null>(null)
+
+  useEffect(() => {
+    // Transitioning from "had a dot" to "wants none" — clear it so the
+    // sidebar doesn't keep showing stale state after the consumer disabled
+    // the feature.
+    if (kind === null) {
+      if (prevKindRef.current !== null && writeRaw && supportsTabStatus()) {
+        writeRaw(wrapForMultiplexer(CLEAR_TAB_STATUS))
+      }
+      prevKindRef.current = null
+      return
+    }
+
+    prevKindRef.current = kind
+    if (!writeRaw || !supportsTabStatus()) return
+    writeRaw(wrapForMultiplexer(tabStatus(TAB_STATUS_PRESETS[kind])))
+  }, [kind, writeRaw])
+}

package/node_modules/ink/src/hooks/use-terminal-focus.ts

@@ -0,0 +1,8 @@
+import { useContext } from 'react'
+import TerminalFocusContext from '../components/TerminalFocusContext.js'
+
+/** Reports whether the host terminal currently has window focus. */
+export function useTerminalFocus(): boolean {
+  const { isTerminalFocused } = useContext(TerminalFocusContext)
+  return isTerminalFocused
+}

package/node_modules/ink/src/hooks/use-terminal-title.ts

@@ -0,0 +1,21 @@
+import { useContext, useEffect } from 'react'
+import stripAnsi from 'strip-ansi'
+import { OSC, osc } from '../termio/osc.js'
+import { TerminalWriteContext } from '../useTerminalNotification.js'
+
+/** Declaratively drive the terminal tab / window title. */
+export function useTerminalTitle(title: string | null): void {
+  const writeRaw = useContext(TerminalWriteContext)
+
+  useEffect(() => {
+    if (title === null || !writeRaw) return
+
+    const clean = stripAnsi(title)
+
+    if (process.platform === 'win32') {
+      process.title = clean
+    } else {
+      writeRaw(osc(OSC.SET_TITLE_AND_ICON, clean))
+    }
+  }, [title, writeRaw])
+}