@vsuryav/agent-sim 0.1.0

package/src/engine/ink/components/ErrorOverview.tsx

@@ -0,0 +1,109 @@
+import codeExcerpt, { type CodeExcerpt } from 'code-excerpt';
+import { readFileSync } from 'fs';
+import React from 'react';
+import StackUtils from 'stack-utils';
+import Box from './Box.js';
+import Text from './Text.js';
+
+/* eslint-disable custom-rules/no-process-cwd -- stack trace file:// paths are relative to the real OS cwd, not the virtual cwd */
+
+// Error's source file is reported as file:///home/user/file.js
+// This function removes the file://[cwd] part
+const cleanupPath = (path: string | undefined): string | undefined => {
+  return path?.replace(`file://${process.cwd()}/`, '');
+};
+let stackUtils: StackUtils | undefined;
+function getStackUtils(): StackUtils {
+  return stackUtils ??= new StackUtils({
+    cwd: process.cwd(),
+    internals: StackUtils.nodeInternals()
+  });
+}
+
+/* eslint-enable custom-rules/no-process-cwd */
+
+type Props = {
+  readonly error: Error;
+};
+export default function ErrorOverview({
+  error
+}: Props) {
+  const stack = error.stack ? error.stack.split('\n').slice(1) : undefined;
+  const origin = stack ? getStackUtils().parseLine(stack[0]!) : undefined;
+  const filePath = cleanupPath(origin?.file);
+  let excerpt: CodeExcerpt[] | undefined;
+  let lineWidth = 0;
+  if (filePath && origin?.line) {
+    try {
+      // eslint-disable-next-line custom-rules/no-sync-fs -- sync render path; error overlay can't go async without suspense restructuring
+      const sourceCode = readFileSync(filePath, 'utf8');
+      excerpt = codeExcerpt(sourceCode, origin.line);
+      if (excerpt) {
+        for (const {
+          line
+        } of excerpt) {
+          lineWidth = Math.max(lineWidth, String(line).length);
+        }
+      }
+    } catch {
+      // file not readable — skip source context
+    }
+  }
+  return <Box flexDirection="column" padding={1}>
+      <Box>
+        <Text backgroundColor="ansi:red" color="ansi:white">
+          {' '}
+          ERROR{' '}
+        </Text>
+
+        <Text> {error.message}</Text>
+      </Box>
+
+      {origin && filePath && <Box marginTop={1}>
+          <Text dim>
+            {filePath}:{origin.line}:{origin.column}
+          </Text>
+        </Box>}
+
+      {origin && excerpt && <Box marginTop={1} flexDirection="column">
+          {excerpt.map(({
+        line: line_0,
+        value
+      }) => <Box key={line_0}>
+              <Box width={lineWidth + 1}>
+                <Text dim={line_0 !== origin.line} backgroundColor={line_0 === origin.line ? 'ansi:red' : undefined} color={line_0 === origin.line ? 'ansi:white' : undefined}>
+                  {String(line_0).padStart(lineWidth, ' ')}:
+                </Text>
+              </Box>
+
+              <Text key={line_0} backgroundColor={line_0 === origin.line ? 'ansi:red' : undefined} color={line_0 === origin.line ? 'ansi:white' : undefined}>
+                {' ' + value}
+              </Text>
+            </Box>)}
+        </Box>}
+
+      {error.stack && <Box marginTop={1} flexDirection="column">
+          {error.stack.split('\n').slice(1).map(line_1 => {
+        const parsedLine = getStackUtils().parseLine(line_1);
+
+        // If the line from the stack cannot be parsed, we print out the unparsed line.
+        if (!parsedLine) {
+          return <Box key={line_1}>
+                    <Text dim>- </Text>
+                    <Text bold>{line_1}</Text>
+                  </Box>;
+        }
+        return <Box key={line_1}>
+                  <Text dim>- </Text>
+                  <Text bold>{parsedLine.function}</Text>
+                  <Text dim>
+                    {' '}
+                    ({cleanupPath(parsedLine.file) ?? ''}:{parsedLine.line}:
+                    {parsedLine.column})
+                  </Text>
+                </Box>;
+      })}
+        </Box>}
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["codeExcerpt","CodeExcerpt","readFileSync","React","StackUtils","Box","Text","cleanupPath","path","replace","process","cwd","stackUtils","getStackUtils","internals","nodeInternals","Props","error","Error","ErrorOverview","stack","split","slice","undefined","origin","parseLine","filePath","file","excerpt","lineWidth","line","sourceCode","Math","max","String","length","message","column","map","value","padStart","parsedLine","function"],"sources":["ErrorOverview.tsx"],"sourcesContent":["import codeExcerpt, { type CodeExcerpt } from 'code-excerpt'\nimport { readFileSync } from 'fs'\nimport React from 'react'\nimport StackUtils from 'stack-utils'\nimport Box from './Box.js'\nimport Text from './Text.js'\n\n/* eslint-disable custom-rules/no-process-cwd -- stack trace file:// paths are relative to the real OS cwd, not the virtual cwd */\n\n// Error's source file is reported as file:///home/user/file.js\n// This function removes the file://[cwd] part\nconst cleanupPath = (path: string | undefined): string | undefined => {\n  return path?.replace(`file://${process.cwd()}/`, '')\n}\n\nlet stackUtils: StackUtils | undefined\nfunction getStackUtils(): StackUtils {\n  return (stackUtils ??= new StackUtils({\n    cwd: process.cwd(),\n    internals: StackUtils.nodeInternals(),\n  }))\n}\n\n/* eslint-enable custom-rules/no-process-cwd */\n\ntype Props = {\n  readonly error: Error\n}\n\nexport default function ErrorOverview({ error }: Props) {\n  const stack = error.stack ? error.stack.split('\\n').slice(1) : undefined\n  const origin = stack ? getStackUtils().parseLine(stack[0]!) : undefined\n  const filePath = cleanupPath(origin?.file)\n  let excerpt: CodeExcerpt[] | undefined\n  let lineWidth = 0\n\n  if (filePath && origin?.line) {\n    try {\n      // eslint-disable-next-line custom-rules/no-sync-fs -- sync render path; error overlay can't go async without suspense restructuring\n      const sourceCode = readFileSync(filePath, 'utf8')\n      excerpt = codeExcerpt(sourceCode, origin.line)\n\n      if (excerpt) {\n        for (const { line } of excerpt) {\n          lineWidth = Math.max(lineWidth, String(line).length)\n        }\n      }\n    } catch {\n      // file not readable — skip source context\n    }\n  }\n\n  return (\n    <Box flexDirection=\"column\" padding={1}>\n      <Box>\n        <Text backgroundColor=\"ansi:red\" color=\"ansi:white\">\n          {' '}\n          ERROR{' '}\n        </Text>\n\n        <Text> {error.message}</Text>\n      </Box>\n\n      {origin && filePath && (\n        <Box marginTop={1}>\n          <Text dim>\n            {filePath}:{origin.line}:{origin.column}\n          </Text>\n        </Box>\n      )}\n\n      {origin && excerpt && (\n        <Box marginTop={1} flexDirection=\"column\">\n          {excerpt.map(({ line, value }) => (\n            <Box key={line}>\n              <Box width={lineWidth + 1}>\n                <Text\n                  dim={line !== origin.line}\n                  backgroundColor={\n                    line === origin.line ? 'ansi:red' : undefined\n                  }\n                  color={line === origin.line ? 'ansi:white' : undefined}\n                >\n                  {String(line).padStart(lineWidth, ' ')}:\n                </Text>\n              </Box>\n\n              <Text\n                key={line}\n                backgroundColor={line === origin.line ? 'ansi:red' : undefined}\n                color={line === origin.line ? 'ansi:white' : undefined}\n              >\n                {' ' + value}\n              </Text>\n            </Box>\n          ))}\n        </Box>\n      )}\n\n      {error.stack && (\n        <Box marginTop={1} flexDirection=\"column\">\n          {error.stack\n            .split('\\n')\n            .slice(1)\n            .map(line => {\n              const parsedLine = getStackUtils().parseLine(line)\n\n              // If the line from the stack cannot be parsed, we print out the unparsed line.\n              if (!parsedLine) {\n                return (\n                  <Box key={line}>\n                    <Text dim>- </Text>\n                    <Text bold>{line}</Text>\n                  </Box>\n                )\n              }\n\n              return (\n                <Box key={line}>\n                  <Text dim>- </Text>\n                  <Text bold>{parsedLine.function}</Text>\n                  <Text dim>\n                    {' '}\n                    ({cleanupPath(parsedLine.file) ?? ''}:{parsedLine.line}:\n                    {parsedLine.column})\n                  </Text>\n                </Box>\n              )\n            })}\n        </Box>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/engine/ink/components/Link.tsx

@@ -0,0 +1,42 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ReactNode } from 'react';
+import React from 'react';
+import { supportsHyperlinks } from '../supports-hyperlinks.js';
+import Text from './Text.js';
+export type Props = {
+  readonly children?: ReactNode;
+  readonly url: string;
+  readonly fallback?: ReactNode;
+};
+export default function Link(t0) {
+  const $ = _c(5);
+  const {
+    children,
+    url,
+    fallback
+  } = t0;
+  const content = children ?? url;
+  if (supportsHyperlinks()) {
+    let t1;
+    if ($[0] !== content || $[1] !== url) {
+      t1 = <Text><ink-link href={url}>{content}</ink-link></Text>;
+      $[0] = content;
+      $[1] = url;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    return t1;
+  }
+  const t1 = fallback ?? content;
+  let t2;
+  if ($[3] !== t1) {
+    t2 = <Text>{t1}</Text>;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/engine/ink/components/Newline.tsx

@@ -0,0 +1,39 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+export type Props = {
+  /**
+   * Number of newlines to insert.
+   *
+   * @default 1
+   */
+  readonly count?: number;
+};
+
+/**
+ * Adds one or more newline (\n) characters. Must be used within <Text> components.
+ */
+export default function Newline(t0) {
+  const $ = _c(4);
+  const {
+    count: t1
+  } = t0;
+  const count = t1 === undefined ? 1 : t1;
+  let t2;
+  if ($[0] !== count) {
+    t2 = "\n".repeat(count);
+    $[0] = count;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== t2) {
+    t3 = <ink-text>{t2}</ink-text>;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlByb3BzIiwiY291bnQiLCJOZXdsaW5lIiwidDAiLCIkIiwiX2MiLCJ0MSIsInVuZGVmaW5lZCIsInQyIiwicmVwZWF0IiwidDMiXSwic291cmNlcyI6WyJOZXdsaW5lLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnXG5cbmV4cG9ydCB0eXBlIFByb3BzID0ge1xuICAvKipcbiAgICogTnVtYmVyIG9mIG5ld2xpbmVzIHRvIGluc2VydC5cbiAgICpcbiAgICogQGRlZmF1bHQgMVxuICAgKi9cbiAgcmVhZG9ubHkgY291bnQ/OiBudW1iZXJcbn1cblxuLyoqXG4gKiBBZGRzIG9uZSBvciBtb3JlIG5ld2xpbmUgKFxcbikgY2hhcmFjdGVycy4gTXVzdCBiZSB1c2VkIHdpdGhpbiA8VGV4dD4gY29tcG9uZW50cy5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gTmV3bGluZSh7IGNvdW50ID0gMSB9OiBQcm9wcykge1xuICByZXR1cm4gPGluay10ZXh0PnsnXFxuJy5yZXBlYXQoY291bnQpfTwvaW5rLXRleHQ+XG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxLQUFLLE1BQU0sT0FBTztBQUV6QixPQUFPLEtBQUtDLEtBQUssR0FBRztFQUNsQjtBQUNGO0FBQ0E7QUFDQTtBQUNBO0VBQ0UsU0FBU0MsS0FBSyxDQUFDLEVBQUUsTUFBTTtBQUN6QixDQUFDOztBQUVEO0FBQ0E7QUFDQTtBQUNBLGVBQWUsU0FBQUMsUUFBQUMsRUFBQTtFQUFBLE1BQUFDLENBQUEsR0FBQUMsRUFBQTtFQUFpQjtJQUFBSixLQUFBLEVBQUFLO0VBQUEsSUFBQUgsRUFBb0I7RUFBbEIsTUFBQUYsS0FBQSxHQUFBSyxFQUFTLEtBQVRDLFNBQVMsR0FBVCxDQUFTLEdBQVRELEVBQVM7RUFBQSxJQUFBRSxFQUFBO0VBQUEsSUFBQUosQ0FBQSxRQUFBSCxLQUFBO0lBQ3ZCTyxFQUFBLE9BQUksQ0FBQUMsTUFBTyxDQUFDUixLQUFLLENBQUM7SUFBQUcsQ0FBQSxNQUFBSCxLQUFBO0lBQUFHLENBQUEsTUFBQUksRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUosQ0FBQTtFQUFBO0VBQUEsSUFBQU0sRUFBQTtFQUFBLElBQUFOLENBQUEsUUFBQUksRUFBQTtJQUE3QkUsRUFBQSxZQUF5QyxDQUE5QixDQUFBRixFQUFpQixDQUFFLEVBQTlCLFFBQXlDO0lBQUFKLENBQUEsTUFBQUksRUFBQTtJQUFBSixDQUFBLE1BQUFNLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFOLENBQUE7RUFBQTtFQUFBLE9BQXpDTSxFQUF5QztBQUFBIiwiaWdub3JlTGlzdCI6W119

package/src/engine/ink/components/NoSelect.tsx

@@ -0,0 +1,68 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type PropsWithChildren } from 'react';
+import Box, { type Props as BoxProps } from './Box.js';
+type Props = Omit<BoxProps, 'noSelect'> & {
+  /**
+   * Extend the exclusion zone from column 0 to this box's right edge,
+   * for every row this box occupies. Use for gutters rendered inside a
+   * wider indented container (e.g. a diff inside a tool message row):
+   * without this, a multi-row drag picks up the container's leading
+   * indent on rows below the prefix.
+   *
+   * @default false
+   */
+  fromLeftEdge?: boolean;
+};
+
+/**
+ * Marks its contents as non-selectable in fullscreen text selection.
+ * Cells inside this box are skipped by both the selection highlight and
+ * the copied text — the gutter stays visually unchanged while the user
+ * drags, making it clear what will be copied.
+ *
+ * Use to fence off gutters (line numbers, diff +/- sigils, list bullets)
+ * so click-drag over rendered code yields clean pasteable content:
+ *
+ *   <Box flexDirection="row">
+ *     <NoSelect fromLeftEdge><Text dimColor> 42 +</Text></NoSelect>
+ *     <Text>const x = 1</Text>
+ *   </Box>
+ *
+ * Only affects alt-screen text selection (<AlternateScreen> with mouse
+ * tracking). No-op in the main-screen scrollback render where the
+ * terminal's native selection is used instead.
+ */
+export function NoSelect(t0) {
+  const $ = _c(8);
+  let boxProps;
+  let children;
+  let fromLeftEdge;
+  if ($[0] !== t0) {
+    ({
+      children,
+      fromLeftEdge,
+      ...boxProps
+    } = t0);
+    $[0] = t0;
+    $[1] = boxProps;
+    $[2] = children;
+    $[3] = fromLeftEdge;
+  } else {
+    boxProps = $[1];
+    children = $[2];
+    fromLeftEdge = $[3];
+  }
+  const t1 = fromLeftEdge ? "from-left-edge" : true;
+  let t2;
+  if ($[4] !== boxProps || $[5] !== children || $[6] !== t1) {
+    t2 = <Box {...boxProps} noSelect={t1}>{children}</Box>;
+    $[4] = boxProps;
+    $[5] = children;
+    $[6] = t1;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/engine/ink/components/RawAnsi.tsx

@@ -0,0 +1,57 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+type Props = {
+  /**
+   * Pre-rendered ANSI lines. Each element must be exactly one terminal row
+   * (already wrapped to `width` by the producer) with ANSI escape codes inline.
+   */
+  lines: string[];
+  /** Column width the producer wrapped to. Sent to Yoga as the fixed leaf width. */
+  width: number;
+};
+
+/**
+ * Bypass the <Ansi> → React tree → Yoga → squash → re-serialize roundtrip for
+ * content that is already terminal-ready.
+ *
+ * Use this when an external renderer (e.g. the ColorDiff NAPI module) has
+ * already produced ANSI-escaped, width-wrapped output. A normal <Ansi> mount
+ * reparses that output into one React <Text> per style span, lays out each
+ * span as a Yoga flex child, then walks the tree to re-emit the same escape
+ * codes it was given. For a long transcript full of syntax-highlighted diffs
+ * that roundtrip is the dominant cost of the render.
+ *
+ * This component emits a single Yoga leaf with a constant-time measure func
+ * (width × lines.length) and hands the joined string straight to output.write(),
+ * which already splits on '\n' and parses ANSI into the screen buffer.
+ */
+export function RawAnsi(t0) {
+  const $ = _c(6);
+  const {
+    lines,
+    width
+  } = t0;
+  if (lines.length === 0) {
+    return null;
+  }
+  let t1;
+  if ($[0] !== lines) {
+    t1 = lines.join("\n");
+    $[0] = lines;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== lines.length || $[3] !== t1 || $[4] !== width) {
+    t2 = <ink-raw-ansi rawText={t1} rawWidth={width} rawHeight={lines.length} />;
+    $[2] = lines.length;
+    $[3] = t1;
+    $[4] = width;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/engine/ink/components/ScrollBox.tsx

@@ -0,0 +1,237 @@
+import React, { type PropsWithChildren, type Ref, useImperativeHandle, useRef, useState } from 'react';
+import type { Except } from 'type-fest';
+import { markScrollActivity } from '../../bootstrap/state.js';
+import type { DOMElement } from '../dom.js';
+import { markDirty, scheduleRenderFrom } from '../dom.js';
+import { markCommitStart } from '../reconciler.js';
+import type { Styles } from '../styles.js';
+import '../global.d.ts';
+import Box from './Box.js';
+export type ScrollBoxHandle = {
+  scrollTo: (y: number) => void;
+  scrollBy: (dy: number) => void;
+  /**
+   * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike
+   * scrollTo which bakes a number that's stale by the time the throttled
+   * render fires, this defers the position read to render time —
+   * render-node-to-output reads `el.yogaNode.getComputedTop()` in the
+   * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.
+   */
+  scrollToElement: (el: DOMElement, offset?: number) => void;
+  scrollToBottom: () => void;
+  getScrollTop: () => number;
+  getPendingDelta: () => number;
+  getScrollHeight: () => number;
+  /**
+   * Like getScrollHeight, but reads Yoga directly instead of the cached
+   * value written by render-node-to-output (throttled, up to 16ms stale).
+   * Use when you need a fresh value in useLayoutEffect after a React commit
+   * that grew content. Slightly more expensive (native Yoga call).
+   */
+  getFreshScrollHeight: () => number;
+  getViewportHeight: () => number;
+  /**
+   * Absolute screen-buffer row of the first visible content line (inside
+   * padding). Used for drag-to-scroll edge detection.
+   */
+  getViewportTop: () => number;
+  /**
+   * True when scroll is pinned to the bottom. Set by scrollToBottom, the
+   * initial stickyScroll attribute, and by the renderer when positional
+   * follow fires (scrollTop at prevMax, content grows). Cleared by
+   * scrollTo/scrollBy. Stable signal for "at bottom" that doesn't depend on
+   * layout values (unlike scrollTop+viewportH >= scrollHeight).
+   */
+  isSticky: () => boolean;
+  /**
+   * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).
+   * Does NOT fire for stickyScroll updates done by the Ink renderer — those
+   * happen during Ink's render phase after React has committed. Callers that
+   * care about the sticky case should treat "at bottom" as a fallback.
+   */
+  subscribe: (listener: () => void) => () => void;
+  /**
+   * Set the render-time scrollTop clamp to the currently-mounted children's
+   * coverage span. Called by useVirtualScroll after computing its range;
+   * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo
+   * calls that race past React's async re-render show the edge of mounted
+   * content instead of blank spacer. Pass undefined to disable (sticky,
+   * cold start).
+   */
+  setClampBounds: (min: number | undefined, max: number | undefined) => void;
+};
+export type ScrollBoxProps = Except<Styles, 'textWrap' | 'overflow' | 'overflowX' | 'overflowY'> & {
+  ref?: Ref<ScrollBoxHandle>;
+  /**
+   * When true, automatically pins scroll position to the bottom when content
+   * grows. Unset manually via scrollTo/scrollBy to break the stickiness.
+   */
+  stickyScroll?: boolean;
+};
+
+/**
+ * A Box with `overflow: scroll` and an imperative scroll API.
+ *
+ * Children are laid out at their full Yoga-computed height inside a
+ * constrained container. At render time, only children intersecting the
+ * visible window (scrollTop..scrollTop+height) are rendered (viewport
+ * culling). Content is translated by -scrollTop and clipped to the box bounds.
+ *
+ * Works best inside a fullscreen (constrained-height root) Ink tree.
+ */
+function ScrollBox({
+  children,
+  ref,
+  stickyScroll,
+  ...style
+}: PropsWithChildren<ScrollBoxProps>): React.ReactNode {
+  const domRef = useRef<DOMElement>(null);
+  // scrollTo/scrollBy bypass React: they mutate scrollTop on the DOM node,
+  // mark it dirty, and call the root's throttled scheduleRender directly.
+  // The Ink renderer reads scrollTop from the node — no React state needed,
+  // no reconciler overhead per wheel event. The microtask defer coalesces
+  // multiple scrollBy calls in one input batch (discreteUpdates) into one
+  // render — otherwise scheduleRender's leading edge fires on the FIRST
+  // event before subsequent events mutate scrollTop. scrollToBottom still
+  // forces a React render: sticky is attribute-observed, no DOM-only path.
+  const [, forceRender] = useState(0);
+  const listenersRef = useRef(new Set<() => void>());
+  const renderQueuedRef = useRef(false);
+  const notify = () => {
+    for (const l of listenersRef.current) l();
+  };
+  function scrollMutated(el: DOMElement): void {
+    // Signal background intervals (IDE poll, LSP poll, GCS fetch, orphan
+    // check) to skip their next tick — they compete for the event loop and
+    // contributed to 1402ms max frame gaps during scroll drain.
+    markScrollActivity();
+    markDirty(el);
+    markCommitStart();
+    notify();
+    if (renderQueuedRef.current) return;
+    renderQueuedRef.current = true;
+    queueMicrotask(() => {
+      renderQueuedRef.current = false;
+      scheduleRenderFrom(el);
+    });
+  }
+  useImperativeHandle(ref, (): ScrollBoxHandle => ({
+    scrollTo(y: number) {
+      const el = domRef.current;
+      if (!el) return;
+      // Explicit false overrides the DOM attribute so manual scroll
+      // breaks stickiness. Render code checks ?? precedence.
+      el.stickyScroll = false;
+      el.pendingScrollDelta = undefined;
+      el.scrollAnchor = undefined;
+      el.scrollTop = Math.max(0, Math.floor(y));
+      scrollMutated(el);
+    },
+    scrollToElement(el: DOMElement, offset = 0) {
+      const box = domRef.current;
+      if (!box) return;
+      box.stickyScroll = false;
+      box.pendingScrollDelta = undefined;
+      box.scrollAnchor = {
+        el,
+        offset
+      };
+      scrollMutated(box);
+    },
+    scrollBy(dy: number) {
+      const el = domRef.current;
+      if (!el) return;
+      el.stickyScroll = false;
+      // Wheel input cancels any in-flight anchor seek — user override.
+      el.scrollAnchor = undefined;
+      // Accumulate in pendingScrollDelta; renderer drains it at a capped
+      // rate so fast flicks show intermediate frames. Pure accumulator:
+      // scroll-up followed by scroll-down naturally cancels.
+      el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+      scrollMutated(el);
+    },
+    scrollToBottom() {
+      const el = domRef.current;
+      if (!el) return;
+      el.pendingScrollDelta = undefined;
+      el.stickyScroll = true;
+      markDirty(el);
+      notify();
+      forceRender(n => n + 1);
+    },
+    getScrollTop() {
+      return domRef.current?.scrollTop ?? 0;
+    },
+    getPendingDelta() {
+      // Accumulated-but-not-yet-drained delta. useVirtualScroll needs
+      // this to mount the union [committed, committed+pending] range —
+      // otherwise intermediate drain frames find no children (blank).
+      return domRef.current?.pendingScrollDelta ?? 0;
+    },
+    getScrollHeight() {
+      return domRef.current?.scrollHeight ?? 0;
+    },
+    getFreshScrollHeight() {
+      const content = domRef.current?.childNodes[0] as DOMElement | undefined;
+      return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+    },
+    getViewportHeight() {
+      return domRef.current?.scrollViewportHeight ?? 0;
+    },
+    getViewportTop() {
+      return domRef.current?.scrollViewportTop ?? 0;
+    },
+    isSticky() {
+      const el = domRef.current;
+      if (!el) return false;
+      return el.stickyScroll ?? Boolean(el.attributes['stickyScroll']);
+    },
+    subscribe(listener: () => void) {
+      listenersRef.current.add(listener);
+      return () => listenersRef.current.delete(listener);
+    },
+    setClampBounds(min, max) {
+      const el = domRef.current;
+      if (!el) return;
+      el.scrollClampMin = min;
+      el.scrollClampMax = max;
+    }
+  }),
+  // notify/scrollMutated are inline (no useCallback) but only close over
+  // refs + imports — stable. Empty deps avoids rebuilding the handle on
+  // every render (which re-registers the ref = churn).
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+
+  // Structure: outer viewport (overflow:scroll, constrained height) >
+  // inner content (flexGrow:1, flexShrink:0 — fills at least the viewport
+  // but grows beyond it for tall content). flexGrow:1 lets children use
+  // spacers to pin elements to the bottom of the scroll area. Yoga's
+  // Overflow.Scroll prevents the viewport from growing to fit the content.
+  // The renderer computes scrollHeight from the content box and culls
+  // content's children based on scrollTop.
+  //
+  // stickyScroll is passed as a DOM attribute (via ink-box directly) so it's
+  // available on the first render — ref callbacks fire after the initial
+  // commit, which is too late for the first frame.
+  return <ink-box ref={el => {
+    domRef.current = el;
+    if (el) el.scrollTop ??= 0;
+  }} style={{
+    flexWrap: 'nowrap',
+    flexDirection: style.flexDirection ?? 'row',
+    flexGrow: style.flexGrow ?? 0,
+    flexShrink: style.flexShrink ?? 1,
+    ...style,
+    overflowX: 'scroll',
+    overflowY: 'scroll'
+  }} {...stickyScroll ? {
+    stickyScroll: true
+  } : {}}>
+      <Box flexDirection="column" flexGrow={1} flexShrink={0} width="100%">
+        {children}
+      </Box>
+    </ink-box>;
+}
+export default ScrollBox;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","PropsWithChildren","Ref","useImperativeHandle","useRef","useState","Except","markScrollActivity","DOMElement","markDirty","scheduleRenderFrom","markCommitStart","Styles","Box","ScrollBoxHandle","scrollTo","y","scrollBy","dy","scrollToElement","el","offset","scrollToBottom","getScrollTop","getPendingDelta","getScrollHeight","getFreshScrollHeight","getViewportHeight","getViewportTop","isSticky","subscribe","listener","setClampBounds","min","max","ScrollBoxProps","ref","stickyScroll","ScrollBox","children","style","ReactNode","domRef","forceRender","listenersRef","Set","renderQueuedRef","notify","l","current","scrollMutated","queueMicrotask","pendingScrollDelta","undefined","scrollAnchor","scrollTop","Math","floor","box","n","scrollHeight","content","childNodes","yogaNode","getComputedHeight","scrollViewportHeight","scrollViewportTop","Boolean","attributes","add","delete","scrollClampMin","scrollClampMax","flexWrap","flexDirection","flexGrow","flexShrink","overflowX","overflowY"],"sources":["ScrollBox.tsx"],"sourcesContent":["import React, {\n  type PropsWithChildren,\n  type Ref,\n  useImperativeHandle,\n  useRef,\n  useState,\n} from 'react'\nimport type { Except } from 'type-fest'\nimport { markScrollActivity } from '../../bootstrap/state.js'\nimport type { DOMElement } from '../dom.js'\nimport { markDirty, scheduleRenderFrom } from '../dom.js'\nimport { markCommitStart } from '../reconciler.js'\nimport type { Styles } from '../styles.js'\nimport '../global.d.ts'\nimport Box from './Box.js'\n\nexport type ScrollBoxHandle = {\n  scrollTo: (y: number) => void\n  scrollBy: (dy: number) => void\n  /**\n   * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike\n   * scrollTo which bakes a number that's stale by the time the throttled\n   * render fires, this defers the position read to render time —\n   * render-node-to-output reads `el.yogaNode.getComputedTop()` in the\n   * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.\n   */\n  scrollToElement: (el: DOMElement, offset?: number) => void\n  scrollToBottom: () => void\n  getScrollTop: () => number\n  getPendingDelta: () => number\n  getScrollHeight: () => number\n  /**\n   * Like getScrollHeight, but reads Yoga directly instead of the cached\n   * value written by render-node-to-output (throttled, up to 16ms stale).\n   * Use when you need a fresh value in useLayoutEffect after a React commit\n   * that grew content. Slightly more expensive (native Yoga call).\n   */\n  getFreshScrollHeight: () => number\n  getViewportHeight: () => number\n  /**\n   * Absolute screen-buffer row of the first visible content line (inside\n   * padding). Used for drag-to-scroll edge detection.\n   */\n  getViewportTop: () => number\n  /**\n   * True when scroll is pinned to the bottom. Set by scrollToBottom, the\n   * initial stickyScroll attribute, and by the renderer when positional\n   * follow fires (scrollTop at prevMax, content grows). Cleared by\n   * scrollTo/scrollBy. Stable signal for \"at bottom\" that doesn't depend on\n   * layout values (unlike scrollTop+viewportH >= scrollHeight).\n   */\n  isSticky: () => boolean\n  /**\n   * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).\n   * Does NOT fire for stickyScroll updates done by the Ink renderer — those\n   * happen during Ink's render phase after React has committed. Callers that\n   * care about the sticky case should treat \"at bottom\" as a fallback.\n   */\n  subscribe: (listener: () => void) => () => void\n  /**\n   * Set the render-time scrollTop clamp to the currently-mounted children's\n   * coverage span. Called by useVirtualScroll after computing its range;\n   * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo\n   * calls that race past React's async re-render show the edge of mounted\n   * content instead of blank spacer. Pass undefined to disable (sticky,\n   * cold start).\n   */\n  setClampBounds: (min: number | undefined, max: number | undefined) => void\n}\n\nexport type ScrollBoxProps = Except<\n  Styles,\n  'textWrap' | 'overflow' | 'overflowX' | 'overflowY'\n> & {\n  ref?: Ref<ScrollBoxHandle>\n  /**\n   * When true, automatically pins scroll position to the bottom when content\n   * grows. Unset manually via scrollTo/scrollBy to break the stickiness.\n   */\n  stickyScroll?: boolean\n}\n\n/**\n * A Box with `overflow: scroll` and an imperative scroll API.\n *\n * Children are laid out at their full Yoga-computed height inside a\n * constrained container. At render time, only children intersecting the\n * visible window (scrollTop..scrollTop+height) are rendered (viewport\n * culling). Content is translated by -scrollTop and clipped to the box bounds.\n *\n * Works best inside a fullscreen (constrained-height root) Ink tree.\n */\nfunction ScrollBox({\n  children,\n  ref,\n  stickyScroll,\n  ...style\n}: PropsWithChildren<ScrollBoxProps>): React.ReactNode {\n  const domRef = useRef<DOMElement>(null)\n  // scrollTo/scrollBy bypass React: they mutate scrollTop on the DOM node,\n  // mark it dirty, and call the root's throttled scheduleRender directly.\n  // The Ink renderer reads scrollTop from the node — no React state needed,\n  // no reconciler overhead per wheel event. The microtask defer coalesces\n  // multiple scrollBy calls in one input batch (discreteUpdates) into one\n  // render — otherwise scheduleRender's leading edge fires on the FIRST\n  // event before subsequent events mutate scrollTop. scrollToBottom still\n  // forces a React render: sticky is attribute-observed, no DOM-only path.\n  const [, forceRender] = useState(0)\n  const listenersRef = useRef(new Set<() => void>())\n  const renderQueuedRef = useRef(false)\n\n  const notify = () => {\n    for (const l of listenersRef.current) l()\n  }\n\n  function scrollMutated(el: DOMElement): void {\n    // Signal background intervals (IDE poll, LSP poll, GCS fetch, orphan\n    // check) to skip their next tick — they compete for the event loop and\n    // contributed to 1402ms max frame gaps during scroll drain.\n    markScrollActivity()\n    markDirty(el)\n    markCommitStart()\n    notify()\n    if (renderQueuedRef.current) return\n    renderQueuedRef.current = true\n    queueMicrotask(() => {\n      renderQueuedRef.current = false\n      scheduleRenderFrom(el)\n    })\n  }\n\n  useImperativeHandle(\n    ref,\n    (): ScrollBoxHandle => ({\n      scrollTo(y: number) {\n        const el = domRef.current\n        if (!el) return\n        // Explicit false overrides the DOM attribute so manual scroll\n        // breaks stickiness. Render code checks ?? precedence.\n        el.stickyScroll = false\n        el.pendingScrollDelta = undefined\n        el.scrollAnchor = undefined\n        el.scrollTop = Math.max(0, Math.floor(y))\n        scrollMutated(el)\n      },\n      scrollToElement(el: DOMElement, offset = 0) {\n        const box = domRef.current\n        if (!box) return\n        box.stickyScroll = false\n        box.pendingScrollDelta = undefined\n        box.scrollAnchor = { el, offset }\n        scrollMutated(box)\n      },\n      scrollBy(dy: number) {\n        const el = domRef.current\n        if (!el) return\n        el.stickyScroll = false\n        // Wheel input cancels any in-flight anchor seek — user override.\n        el.scrollAnchor = undefined\n        // Accumulate in pendingScrollDelta; renderer drains it at a capped\n        // rate so fast flicks show intermediate frames. Pure accumulator:\n        // scroll-up followed by scroll-down naturally cancels.\n        el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy)\n        scrollMutated(el)\n      },\n      scrollToBottom() {\n        const el = domRef.current\n        if (!el) return\n        el.pendingScrollDelta = undefined\n        el.stickyScroll = true\n        markDirty(el)\n        notify()\n        forceRender(n => n + 1)\n      },\n      getScrollTop() {\n        return domRef.current?.scrollTop ?? 0\n      },\n      getPendingDelta() {\n        // Accumulated-but-not-yet-drained delta. useVirtualScroll needs\n        // this to mount the union [committed, committed+pending] range —\n        // otherwise intermediate drain frames find no children (blank).\n        return domRef.current?.pendingScrollDelta ?? 0\n      },\n      getScrollHeight() {\n        return domRef.current?.scrollHeight ?? 0\n      },\n      getFreshScrollHeight() {\n        const content = domRef.current?.childNodes[0] as DOMElement | undefined\n        return (\n          content?.yogaNode?.getComputedHeight() ??\n          domRef.current?.scrollHeight ??\n          0\n        )\n      },\n      getViewportHeight() {\n        return domRef.current?.scrollViewportHeight ?? 0\n      },\n      getViewportTop() {\n        return domRef.current?.scrollViewportTop ?? 0\n      },\n      isSticky() {\n        const el = domRef.current\n        if (!el) return false\n        return el.stickyScroll ?? Boolean(el.attributes['stickyScroll'])\n      },\n      subscribe(listener: () => void) {\n        listenersRef.current.add(listener)\n        return () => listenersRef.current.delete(listener)\n      },\n      setClampBounds(min, max) {\n        const el = domRef.current\n        if (!el) return\n        el.scrollClampMin = min\n        el.scrollClampMax = max\n      },\n    }),\n    // notify/scrollMutated are inline (no useCallback) but only close over\n    // refs + imports — stable. Empty deps avoids rebuilding the handle on\n    // every render (which re-registers the ref = churn).\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [],\n  )\n\n  // Structure: outer viewport (overflow:scroll, constrained height) >\n  // inner content (flexGrow:1, flexShrink:0 — fills at least the viewport\n  // but grows beyond it for tall content). flexGrow:1 lets children use\n  // spacers to pin elements to the bottom of the scroll area. Yoga's\n  // Overflow.Scroll prevents the viewport from growing to fit the content.\n  // The renderer computes scrollHeight from the content box and culls\n  // content's children based on scrollTop.\n  //\n  // stickyScroll is passed as a DOM attribute (via ink-box directly) so it's\n  // available on the first render — ref callbacks fire after the initial\n  // commit, which is too late for the first frame.\n  return (\n    <ink-box\n      ref={el => {\n        domRef.current = el\n        if (el) el.scrollTop ??= 0\n      }}\n      style={{\n        flexWrap: 'nowrap',\n        flexDirection: style.flexDirection ?? 'row',\n        flexGrow: style.flexGrow ?? 0,\n        flexShrink: style.flexShrink ?? 1,\n        ...style,\n        overflowX: 'scroll',\n        overflowY: 'scroll',\n      }}\n      {...(stickyScroll ? { stickyScroll: true } : {})}\n    >\n      <Box flexDirection=\"column\" flexGrow={1} flexShrink={0} width=\"100%\">\n        {children}\n      </Box>\n    </ink-box>\n  )\n}\n\nexport default ScrollBox\n"],"mappings":"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","ignoreList":[]}