@alchemy.run/sigil 0.0.0-alpha.8 → 0.1.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alchemy.run/sigil",
-  "version": "0.0.0-alpha.8",
+  "version": "0.1.0-alpha.1",
   "description": "React for CLIs. A self-contained fork of Ink with an integrated TypeScript Yoga layout engine.",
   "keywords": [
     "cli",
@@ -75,22 +75,33 @@
       "import": "./dist/terminal.js",
       "types": "./dist/terminal.d.ts",
       "default": "./dist/terminal.js"
+    },
+    "./react": {
+      "import": "./dist/react.js",
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./jsx-runtime": {
+      "import": "./dist/jsx-runtime.js",
+      "types": "./dist/jsx-runtime.d.ts",
+      "default": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "import": "./dist/jsx-dev-runtime.js",
+      "types": "./dist/jsx-dev-runtime.d.ts",
+      "default": "./dist/jsx-dev-runtime.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "react-reconciler": "^0.33.0",
-    "scheduler": "^0.27.0"
-  },
   "devDependencies": {
     "@slopus/ghostty-wasm": "^1.3.6",
-    "@types/node": "^25.5.2",
-    "@types/react": "^19.2.18",
+    "@types/node": "^26.6.1",
+    "@types/react": "^19.3.0",
     "@types/react-reconciler": "^0.33.0",
-    "@types/scheduler": "^0.26.0",
-    "@vitest/ui": "^4.1.11",
+    "@types/scheduler": "^0.28.0",
+    "@vitest/ui": "^5.0.1",
     "@xterm/addon-clipboard": "^0.2.0",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-image": "^0.9.0",
@@ -99,18 +110,19 @@
     "@xterm/addon-webgl": "^0.19.0",
     "@xterm/headless": "^6.0.0",
     "@xterm/xterm": "^6.0.0",
-    "react": "^19.2.8",
-    "react-devtools-core": "^7.0.1",
-    "tsx": "^4.21.0",
+    "react": "^19.3.0",
+    "react-devtools-core": "^8.0.0",
+    "react-reconciler": "^0.34.0",
+    "scheduler": "^0.28.0",
+    "tsx": "^4.23.13",
     "typescript": "^7.0.2",
-    "vite": "npm:@voidzero-dev/vite-plus-core@^0.2.9",
-    "vite-plus": "^0.2.9",
+    "vite": "npm:@voidzero-dev/vite-plus-core@^0.3.2",
+    "vite-plus": "^0.3.2",
     "vitest": "4.1.11",
     "zigpty": "^0.2.1"
   },
   "peerDependencies": {
     "@types/react": ">=19.2.0",
-    "react": ">=19.2.0",
     "react-devtools-core": ">=6.1.2"
   },
   "peerDependenciesMeta": {

package/src/ansi/strip.ts

@@ -5,8 +5,8 @@ import { stripVTControlCharacters } from "node:util";
 // `\u001B[38:2::255:100:0m` — which Sigil deliberately preserves in output
 // (see sanitize-ansi.ts) — would leave `:2::255:100:0m` behind. Remove those
 // first, then let Node handle everything else.
-// https://github.com/nodejs/node/pull/65379 fixes this upstream; this wrapper
-// can go once the minimum supported Node version ships it.
+// https://github.com/nodejs/node/pull/65379 fixed this upstream (Node 24.21+);
+// this wrapper can go once the minimum supported Node version ships it.
 const colonSgrRegex = /(?:\u001B\[|\u009B)[\d;]*:[\d;:]*m/g;
 
 export const stripAnsi = (input: string): string =>

package/src/capabilities/query.ts

@@ -253,6 +253,23 @@ const winopsResponse = new RegExp(`${ESC}\\[(4|6);(\\d+);(\\d+)t`);
 const colorSchemeResponse = new RegExp(`${ESC}\\[\\?997;(\\d+)n`);
 const da1Response = new RegExp(`${ESC}\\[\\?([\\d;]*)c`);
 
+// Also used by the normal input decoder: replies can outlive the query timeout
+// or arrive after its DA1 sentinel. Never deliver those bytes as keystrokes.
+const terminalResponses = [
+  oscColorResponse,
+  kittyKeyboardResponse,
+  decrqmResponse,
+  xtversionResponse,
+  xtgettcapResponse,
+  kittyGraphicsResponse,
+  winopsResponse,
+  colorSchemeResponse,
+  da1Response,
+].map((pattern) => new RegExp(`^(?:${pattern.source})$`));
+
+export const isTerminalQueryResponse = (sequence: string): boolean =>
+  terminalResponses.some((pattern) => pattern.test(sequence));
+
 const buildQuery = (palette: boolean, scope: "full" | "dynamic"): string => {
   const queries = [
     `${OSC}10;?${BEL}`, // foreground color
@@ -346,6 +363,10 @@ export const queryTerminal = async (
 
       done = true;
       clearTimeout(timer);
+      // Stop flowing before returning buffered bytes. Without this, unshift()
+      // can discard a partial reply between removing this data listener and
+      // the application's readable listener reattaching (especially on timeout).
+      stdin.pause();
       stdin.removeListener("data", onData);
 
       if (paletteColors.size === paletteSize) {
@@ -505,6 +526,7 @@ export const queryTerminal = async (
     // Attach before writing so immediate responses aren't missed.
     stdin.on("data", onData);
     const timer = setTimeout(finish, timeout);
+    stdin.resume();
 
     stdout.write(buildQuery(palette, scope));
   });

package/src/components/VirtualList.tsx

@@ -0,0 +1,128 @@
+/** @jsxImportSource react */
+import { useEffect, useLayoutEffect, useRef, useState, type Key, type ReactNode } from "react";
+
+import { Box } from "#/components/Box.tsx";
+import { addLayoutListener, type DOMElement } from "#/dom.ts";
+import { useVirtualScroll } from "#/hooks/use-virtual-scroll.ts";
+
+export type Props<Item> = {
+  /**
+	Items to window over.
+	*/
+  readonly items: ReadonlyArray<Item>;
+
+  /**
+	Height of an item in rows. It must match what `renderItem` produces for it:
+	the window is computed from these numbers, never from the rendered output.
+	*/
+  readonly itemHeight: (item: Item, index: number) => number;
+
+  /**
+	Render one item. Only items intersecting the viewport are rendered.
+	*/
+  readonly renderItem: (item: Item, index: number) => ReactNode;
+
+  /**
+	React key for an item. Defaults to its index.
+	*/
+  readonly getKey?: (item: Item, index: number) => Key;
+
+  /**
+	Item to keep fully visible. When it changes, the list scrolls as little as
+	necessary to show it.
+	*/
+  readonly focusedIndex?: number;
+
+  /**
+	Viewport height in rows. When omitted the list takes the height of its
+	content and shrinks to whatever space its container leaves: bound an
+	ancestor (`height` or `maxHeight`) and give the siblings that must keep
+	their size `flexShrink={0}`.
+	*/
+  readonly height?: number;
+};
+
+const rootOf = (node: DOMElement | null): DOMElement | undefined => {
+  let current = node;
+  while (current?.parentNode) {
+    current = current.parentNode;
+  }
+  return current?.nodeName === "ink-root" ? current : undefined;
+};
+
+/**
+A vertically windowed list: only the items intersecting the viewport are
+rendered, inside a clipped box that scrolls by whole rows. Items may have
+different heights, and the item at the top edge may be partially visible.
+
+Until the first layout pass has measured the viewport, every item is rendered
+inside the clipped box so the first frame already looks right.
+*/
+export function VirtualList<Item>({
+  items,
+  itemHeight,
+  renderItem,
+  getKey,
+  focusedIndex,
+  height,
+}: Props<Item>) {
+  const ref = useRef<DOMElement>(null);
+  const [measured, setMeasured] = useState<number>();
+
+  const measure = () => {
+    const next = ref.current?.yogaNode?.getComputedHeight();
+    if (next !== undefined) {
+      setMeasured((previous) => (previous === next ? previous : next));
+    }
+  };
+
+  // Yoga has laid out the tree by the time layout effects run, so the height
+  // this box ended up with is readable synchronously after every commit.
+  useLayoutEffect(() => {
+    if (height === undefined) measure();
+  });
+
+  // Sibling-driven changes (a resize, chrome growing) re-layout without
+  // re-rendering this component; follow the root's layout commits for those.
+  useEffect(() => {
+    if (height !== undefined) return;
+    const root = rootOf(ref.current);
+    return root ? addLayoutListener(root, measure) : undefined;
+  });
+
+  const viewportHeight = height ?? measured;
+  const windowed = viewportHeight !== undefined;
+  const window = useVirtualScroll({
+    count: items.length,
+    itemHeight: (index) => itemHeight(items[index]!, index),
+    viewportHeight: viewportHeight ?? 0,
+    // Following the focus against an unmeasured (zero-row) viewport would pin
+    // the item to the top; wait for the real height so it moves minimally.
+    focusedIndex: windowed ? focusedIndex : undefined,
+  });
+  const start = windowed ? window.start : 0;
+  const end = windowed ? window.end : items.length;
+  const offset = windowed ? window.offset : 0;
+
+  return (
+    <Box
+      ref={ref}
+      flexDirection="column"
+      overflowY="hidden"
+      {...(height === undefined
+        ? { height: window.totalHeight, minHeight: 0, flexShrink: 1 }
+        : { height, flexShrink: 0 })}
+    >
+      <Box flexDirection="column" flexShrink={0} marginTop={offset}>
+        {items.slice(start, end).map((item, sliceIndex) => {
+          const index = start + sliceIndex;
+          return (
+            <Box key={getKey ? getKey(item, index) : index} flexDirection="column" flexShrink={0}>
+              {renderItem(item, index)}
+            </Box>
+          );
+        })}
+      </Box>
+    </Box>
+  );
+}

package/src/devtools.ts

@@ -70,8 +70,13 @@ Object.defineProperty(globalThis, "__REACT_DEVTOOLS_COMPONENT_FILTERS__", {
 const isDevToolsReachable = () =>
   new Promise<boolean>((resolve) => {
     const socket = new WebSocket("ws://localhost:8097");
+    let settled = false;
 
     const settle = (reachable: boolean) => {
+      // Node 22 can emit another error synchronously when closing a failed
+      // connection. Mark it settled before close() re-enters this handler.
+      if (settled) return;
+      settled = true;
       clearTimeout(timeout);
       socket.close();
       resolve(reachable);

package/src/hooks/use-virtual-scroll.ts

@@ -0,0 +1,84 @@
+import { useCallback, useEffect, useState } from "react";
+
+import {
+  virtualScrollWindow,
+  type VirtualScrollOptions,
+  type VirtualScrollWindow,
+} from "#/virtual-scroll.ts";
+
+export type UseVirtualScrollOptions = Omit<VirtualScrollOptions, "scrollTop">;
+
+export type UseVirtualScrollResult = VirtualScrollWindow & {
+  /**
+	Scroll so the viewport starts `top` rows from the top of the list.
+	*/
+  readonly scrollTo: (top: number) => void;
+
+  /**
+	Scroll by `delta` rows; negative values scroll up.
+	*/
+  readonly scrollBy: (delta: number) => void;
+};
+
+/**
+A React hook that owns the scroll position of a windowed list and returns which
+items to render for it. The position is clamped to the scrollable range and,
+while `focusedIndex` is set, moved as little as necessary to keep that item
+fully visible. Render the items in `[start, end)` inside an `overflowY="hidden"`
+box of `viewportHeight` rows, shifted up by `offset` rows.
+
+`<VirtualList>` wraps this hook; use it directly to draw your own chrome such
+as overflow markers or a scrollbar around the window.
+
+@example
+```tsx
+import { Box, Text, useVirtualScroll } from "@alchemy.run/sigil";
+
+const Example = ({ lines, cursor }: { lines: string[]; cursor: number }) => {
+	const { start, end, offset, hiddenAbove, hiddenBelow } = useVirtualScroll({
+		count: lines.length,
+		itemHeight: () => 1,
+		viewportHeight: 10,
+		focusedIndex: cursor,
+	});
+
+	return (
+		<Box flexDirection="column">
+			<Text dimColor>{hiddenAbove > 0 ? `↑ ${hiddenAbove} more` : ""}</Text>
+			<Box flexDirection="column" height={10} overflowY="hidden">
+				<Box flexDirection="column" flexShrink={0} marginTop={offset}>
+					{lines.slice(start, end).map((line, index) => (
+						<Text key={start + index} inverse={start + index === cursor}>
+							{line}
+						</Text>
+					))}
+				</Box>
+			</Box>
+			<Text dimColor>{hiddenBelow > 0 ? `↓ ${hiddenBelow} more` : ""}</Text>
+		</Box>
+	);
+};
+```
+*/
+export const useVirtualScroll = (options: UseVirtualScrollOptions): UseVirtualScrollResult => {
+  const [position, setPosition] = useState(0);
+  const window = virtualScrollWindow({ ...options, scrollTop: position });
+
+  // Persist clamping and follow-focus corrections so the next scroll starts
+  // from where the viewport actually is, not from the stale request.
+  useEffect(() => {
+    if (window.scrollTop !== position) {
+      setPosition(window.scrollTop);
+    }
+  }, [window.scrollTop, position]);
+
+  const scrollTo = useCallback((top: number) => {
+    setPosition(top);
+  }, []);
+
+  const scrollBy = useCallback((delta: number) => {
+    setPosition((current) => current + delta);
+  }, []);
+
+  return { ...window, scrollTo, scrollBy };
+};

package/src/hooks/use-window-size.ts

@@ -1,6 +1,8 @@
-import { useMemo } from "react";
+import { useMemo, useSyncExternalStore } from "react";
 
-import { useCapabilities } from "#/hooks/use-capabilities.ts";
+import { getCapabilities } from "#/capabilities/store.ts";
+import { useStdinContext } from "#/hooks/use-stdin.ts";
+import { useStdout } from "#/hooks/use-stdout.ts";
 
 /**
 Dimensions of the terminal window.
@@ -23,8 +25,13 @@ A React hook that returns the current terminal window dimensions and re-renders
 Reads the capabilities store, so on terminals that send in-band size reports
 (mode 2048) the dimensions are the emulator's own, arriving after it has
 rewrapped its screen; elsewhere they are the stream's `columns`/`rows`.
+Subscribing to dimensions does not initiate capability queries. In-band reports
+are used when another consumer has explicitly enabled capability discovery.
 */
 export const useWindowSize = (): WindowSize => {
-  const { size } = useCapabilities();
+  const { stdin } = useStdinContext();
+  const { stdout } = useStdout();
+  const store = getCapabilities(stdin, stdout);
+  const { size } = useSyncExternalStore(store.subscribe, () => store.current);
   return useMemo(() => ({ columns: size.columns, rows: size.rows }), [size.columns, size.rows]);
 };

package/src/index.ts

@@ -22,6 +22,8 @@ export { Hyperlink } from "#/components/Hyperlink.tsx";
 export type { Props as NewlineProps } from "#/components/Newline.tsx";
 export { Newline } from "#/components/Newline.tsx";
 export { Spacer } from "#/components/Spacer.tsx";
+export type { Props as VirtualListProps } from "#/components/VirtualList.tsx";
+export { VirtualList } from "#/components/VirtualList.tsx";
 // Keep the Ink-compatible root surface fixed. New terminal-core APIs live on
 // their focused subpaths rather than leaking through this entry point.
 export type {
@@ -80,6 +82,12 @@ export type { WindowSize } from "#/hooks/use-window-size.ts";
 export { useWindowSize } from "#/hooks/use-window-size.ts";
 export type { BoxMetrics, UseBoxMetricsResult } from "#/hooks/use-box-metrics.ts";
 export { useBoxMetrics } from "#/hooks/use-box-metrics.ts";
+export type { VirtualScrollWindow } from "#/virtual-scroll.ts";
+export type {
+  UseVirtualScrollOptions,
+  UseVirtualScrollResult,
+} from "#/hooks/use-virtual-scroll.ts";
+export { useVirtualScroll } from "#/hooks/use-virtual-scroll.ts";
 export type { CursorPosition } from "#/cursor-position.ts";
 export { measureElement } from "#/measure-element.ts";
 export type { ElementMetrics } from "#/measure-element.ts";

package/src/input-parser.ts

@@ -42,6 +42,12 @@ const parseCsiSequence = (
       return "pending";
     }
 
+    // A new Escape or Ctrl+C cancels a truncated control sequence. Keep the
+    // cancelling byte for the next event, never insert the abandoned prefix.
+    if (byte === 0x1b || byte === 0x03) {
+      return { sequence: "", nextIndex: index };
+    }
+
     if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) {
       continue;
     }
@@ -99,6 +105,25 @@ const parseControlSequence = (
     return parseCsiSequence(input, startIndex, prefixLength);
   }
 
+  // OSC, DCS and APC replies are single events, even across stdin chunks.
+  if (sequenceType === "]" || sequenceType === "P" || sequenceType === "_") {
+    for (let index = startIndex + prefixLength + 1; index < input.length; index++) {
+      if (
+        input[index] === "\u0003" ||
+        (input[index] === escape && index + 1 < input.length && input[index + 1] !== "\\")
+      ) {
+        return { sequence: "", nextIndex: index };
+      }
+      const bel = sequenceType === "]" && input[index] === "\u0007";
+      const st = input[index] === escape && input[index + 1] === "\\";
+      if (bel || st) {
+        const nextIndex = index + (st ? 2 : 1);
+        return { sequence: input.slice(startIndex, nextIndex), nextIndex };
+      }
+    }
+    return "pending";
+  }
+
   if (sequenceType === "O") {
     return parseSs3Sequence(input, startIndex, prefixLength);
   }
@@ -232,7 +257,7 @@ const parseKeypresses = (input: string): ParsedInput => {
       continue;
     }
 
-    events.push(parsedEscapeSequence.sequence);
+    if (parsedEscapeSequence.sequence.length > 0) events.push(parsedEscapeSequence.sequence);
     index = parsedEscapeSequence.nextIndex;
   }
 
@@ -251,6 +276,9 @@ export type InputParser = {
 
 export const createInputParser = (): InputParser => {
   let pending = "";
+  // Only ambiguous Escape/Alt prefixes may time out. Once a control
+  // sequence starts, keep it intact until its terminator arrives.
+  const hasPendingEscape = () => pending.startsWith(escape) && !/^\u001B{1,2}[[\]P_]/.test(pending);
 
   return {
     push(chunk) {
@@ -258,17 +286,9 @@ export const createInputParser = (): InputParser => {
       pending = parsedInput.pending;
       return parsedInput.events;
     },
-    hasPendingEscape() {
-      // Don't trigger the escape flush timer while assembling a paste start
-      // marker (`\u001B[200` and then `~`) or while waiting for paste end.
-      return (
-        pending.startsWith(escape) &&
-        !pending.startsWith(pasteStart) &&
-        pending !== pasteStart.slice(0, -1)
-      );
-    },
+    hasPendingEscape,
     flushPendingEscape() {
-      if (!pending.startsWith(escape)) {
+      if (!hasPendingEscape()) {
         return;
       }
 

package/src/jsx-dev-runtime.ts

@@ -0,0 +1,3 @@
+// Accept development JSX transforms while using the production runtime.
+export { Fragment, jsx as jsxDEV } from "react/jsx-runtime";
+export type { JSX } from "react/jsx-dev-runtime";

package/src/jsx-runtime.ts

@@ -0,0 +1,6 @@
+// `react/jsx-runtime` is CommonJS; a star re-export carries no static names
+// through the bundler, so the automatic-runtime surface is spelled out.
+export { Fragment, jsx, jsxs } from "react/jsx-runtime";
+// `jsxImportSource` looks up the `JSX` namespace on this module to type
+// elements and props. Type-only, so the bundle is unaffected.
+export type { JSX } from "react/jsx-runtime";

package/src/react.ts

@@ -0,0 +1,53 @@
+// Sigil ships its own React. Consumers reach React's runtime through this
+// entry (and `jsxImportSource: "@alchemy.run/sigil"`) so the hooks a component
+// calls and the dispatcher the reconciler installs share one module identity.
+//
+// `@types/react` is an `export =` module, so `export *` is rejected at the type
+// level; the runtime surface is enumerated instead. Types stay type-only
+// imports from `react` (erased at runtime, so no identity concern).
+export {
+  Activity,
+  Children,
+  Component,
+  Fragment,
+  Profiler,
+  PureComponent,
+  StrictMode,
+  Suspense,
+  ViewTransition,
+  act,
+  addTransitionType,
+  cache,
+  cacheSignal,
+  captureOwnerStack,
+  cloneElement,
+  createContext,
+  createElement,
+  createRef,
+  forwardRef,
+  isValidElement,
+  lazy,
+  memo,
+  startTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useEffectEvent,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  version,
+} from "react";
+export { default } from "react";

package/src/reconciler.ts

@@ -132,6 +132,56 @@ type HostContext = {
 
 let currentUpdatePriority = NoEventPriority;
 
+/**
+ * Host hooks react-reconciler 0.34 (React 19.3) added for View Transitions
+ * and Fragment refs. `@types/react-reconciler` (0.33) does not declare them
+ * yet, so they are spread in rather than written inline (excess-property
+ * checks would reject them on the literal).
+ *
+ * A terminal has no view transitions, so a `<ViewTransition>` commits like
+ * any other update: `startViewTransition` mirrors react-dom's fallback when
+ * the document can't animate — run the commit phases synchronously and
+ * return no transition handle. `suspendOnActiveViewTransition` is on the
+ * hot path: the reconciler calls it for every transition-lane commit, so
+ * without it `startTransition` / `useTransition` updates never land.
+ */
+const viewTransitionHostConfig = {
+  suspendOnActiveViewTransition() {},
+  startViewTransition(
+    _suspendedState: unknown,
+    _rootContainer: DOMElement,
+    _transitionTypes: unknown,
+    mutationCallback: () => void,
+    layoutCallback: () => void,
+    _afterMutationCallback: () => void,
+    spawnedWorkCallback: () => void,
+    _passiveCallback: () => void,
+    _errorCallback: (error: unknown) => void,
+    _blockedCallback: (reason: string) => void,
+    finishedAnimation: () => void,
+  ): null {
+    mutationCallback();
+    layoutCallback();
+    finishedAnimation();
+    spawnedWorkCallback();
+    return null;
+  },
+  stopViewTransition() {},
+  createViewTransitionInstance: (name: string) => ({ name }),
+  measureInstance: () => null,
+  measureClonedInstance: () => null,
+  wasInstanceInViewport: () => false,
+  hasInstanceChanged: () => false,
+  hasInstanceAffectedParent: () => false,
+  applyViewTransitionName() {},
+  restoreViewTransitionName() {},
+  cancelViewTransitionName() {},
+  cancelRootViewTransitionName() {},
+  restoreRootViewTransitionName() {},
+  createFragmentInstance: (fiber: unknown) => ({ fiber }),
+  updateFragmentInstanceFiber() {},
+};
+
 export const reconciler = createReconciler<
   ElementNames,
   Props,
@@ -422,4 +472,5 @@ export const reconciler = createReconciler<
   },
   rendererPackageName: pkg.name,
   rendererVersion: pkg.version,
+  ...viewTransitionHostConfig,
 });

package/src/terminal/input.ts

@@ -1,3 +1,4 @@
+import { isTerminalQueryResponse } from "#/capabilities/query.ts";
 import type { CapabilitiesStore } from "#/capabilities/store.ts";
 import { createInputParser, type InputEvent } from "#/input-parser.ts";
 
@@ -25,13 +26,18 @@ export class TerminalInput {
   }
 
   push(chunk: string): InputEvent[] {
-    return this.#parser.push(chunk).filter((event) => {
-      if (typeof event !== "string") return true;
-      if (this.#capabilities.ingest(event)) return false;
+    return this.#parser.push(chunk).flatMap((event): InputEvent[] => {
+      if (typeof event !== "string") return [event];
+      // A user Escape immediately before a reply is not an Alt-modified key.
+      if (event.startsWith("\u001B\u001B") && isTerminalQueryResponse(event.slice(1))) {
+        return ["\u001B"];
+      }
+      if (this.#capabilities.ingest(event)) return [];
+      if (isTerminalQueryResponse(event)) return [];
       const mouse = parseMouseEvent(event);
-      if (!mouse) return true;
+      if (!mouse) return [event];
       for (const listener of this.#mouseListeners) listener(mouse);
-      return false;
+      return [];
     });
   }