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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alchemy.run/sigil",
-  "version": "0.0.0-alpha.9",
+  "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/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-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/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 [];
     });
   }