openhorse 0.1.5

package/dist/ink/supports-hyperlinks.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADDITIONAL_HYPERLINK_TERMINALS = void 0;
+exports.supportsHyperlinks = supportsHyperlinks;
+const supports_hyperlinks_1 = __importDefault(require("supports-hyperlinks"));
+// Additional terminals that support OSC 8 hyperlinks but aren't detected by supports-hyperlinks.
+// Checked against both TERM_PROGRAM and LC_TERMINAL (the latter is preserved inside tmux).
+exports.ADDITIONAL_HYPERLINK_TERMINALS = [
+    'ghostty',
+    'Hyper',
+    'kitty',
+    'alacritty',
+    'iTerm.app',
+    'iTerm2',
+];
+/**
+ * Returns whether stdout supports OSC 8 hyperlinks.
+ * Extends the supports-hyperlinks library with additional terminal detection.
+ * @param options Optional overrides for testing (env, stdoutSupported)
+ */
+function supportsHyperlinks(options) {
+    const stdoutSupported = options?.stdoutSupported ?? supports_hyperlinks_1.default.stdout;
+    if (stdoutSupported) {
+        return true;
+    }
+    const env = options?.env ?? process.env;
+    // Check for additional terminals not detected by supports-hyperlinks
+    const termProgram = env['TERM_PROGRAM'];
+    if (termProgram && exports.ADDITIONAL_HYPERLINK_TERMINALS.includes(termProgram)) {
+        return true;
+    }
+    // LC_TERMINAL is set by some terminals (e.g. iTerm2) and preserved inside tmux,
+    // where TERM_PROGRAM is overwritten to 'tmux'.
+    const lcTerminal = env['LC_TERMINAL'];
+    if (lcTerminal && exports.ADDITIONAL_HYPERLINK_TERMINALS.includes(lcTerminal)) {
+        return true;
+    }
+    // Kitty sets TERM=xterm-kitty
+    const term = env['TERM'];
+    if (term?.includes('kitty')) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=supports-hyperlinks.js.map

package/dist/ink/supports-hyperlinks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supports-hyperlinks.js","sourceRoot":"","sources":["../../src/ink/supports-hyperlinks.ts"],"names":[],"mappings":";;;;;;AAyBA,gDA+BC;AAxDD,8EAAuD;AAEvD,iGAAiG;AACjG,2FAA2F;AAC9E,QAAA,8BAA8B,GAAG;IAC5C,SAAS;IACT,OAAO;IACP,OAAO;IACP,WAAW;IACX,WAAW;IACX,QAAQ;CACT,CAAA;AASD;;;;GAIG;AACH,SAAgB,kBAAkB,CAChC,OAAmC;IAEnC,MAAM,eAAe,GACnB,OAAO,EAAE,eAAe,IAAI,6BAAqB,CAAC,MAAM,CAAA;IAC1D,IAAI,eAAe,EAAE,CAAC;QACpB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,MAAM,GAAG,GAAG,OAAO,EAAE,GAAG,IAAI,OAAO,CAAC,GAAG,CAAA;IAEvC,qEAAqE;IACrE,MAAM,WAAW,GAAG,GAAG,CAAC,cAAc,CAAC,CAAA;IACvC,IAAI,WAAW,IAAI,sCAA8B,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;QACxE,OAAO,IAAI,CAAA;IACb,CAAC;IAED,gFAAgF;IAChF,+CAA+C;IAC/C,MAAM,UAAU,GAAG,GAAG,CAAC,aAAa,CAAC,CAAA;IACrC,IAAI,UAAU,IAAI,sCAA8B,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QACtE,OAAO,IAAI,CAAA;IACb,CAAC;IAED,8BAA8B;IAC9B,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAA;IACxB,IAAI,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAA;IACb,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/ink/tabstops.d.ts

@@ -0,0 +1,2 @@
+export declare function expandTabs(text: string, interval?: number): string;
+//# sourceMappingURL=tabstops.d.ts.map

package/dist/ink/tabstops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabstops.d.ts","sourceRoot":"","sources":["../../src/ink/tabstops.ts"],"names":[],"mappings":"AAQA,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,SAAuB,GAC9B,MAAM,CAkCR"}

package/dist/ink/tabstops.js

@@ -0,0 +1,43 @@
+"use strict";
+// Tab expansion, inspired by Ghostty's Tabstops.zig
+// Uses 8-column intervals (POSIX default, hardcoded in terminals like Ghostty)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandTabs = expandTabs;
+const stringWidth_js_1 = require("./stringWidth.js");
+const tokenize_js_1 = require("./termio/tokenize.js");
+const DEFAULT_TAB_INTERVAL = 8;
+function expandTabs(text, interval = DEFAULT_TAB_INTERVAL) {
+    if (!text.includes('\t')) {
+        return text;
+    }
+    const tokenizer = (0, tokenize_js_1.createTokenizer)();
+    const tokens = tokenizer.feed(text);
+    tokens.push(...tokenizer.flush());
+    let result = '';
+    let column = 0;
+    for (const token of tokens) {
+        if (token.type === 'sequence') {
+            result += token.value;
+        }
+        else {
+            const parts = token.value.split(/(\t|\n)/);
+            for (const part of parts) {
+                if (part === '\t') {
+                    const spaces = interval - (column % interval);
+                    result += ' '.repeat(spaces);
+                    column += spaces;
+                }
+                else if (part === '\n') {
+                    result += part;
+                    column = 0;
+                }
+                else {
+                    result += part;
+                    column += (0, stringWidth_js_1.stringWidth)(part);
+                }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=tabstops.js.map

package/dist/ink/tabstops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabstops.js","sourceRoot":"","sources":["../../src/ink/tabstops.ts"],"names":[],"mappings":";AAAA,oDAAoD;AACpD,+EAA+E;;AAO/E,gCAqCC;AA1CD,qDAA8C;AAC9C,sDAAsD;AAEtD,MAAM,oBAAoB,GAAG,CAAC,CAAA;AAE9B,SAAgB,UAAU,CACxB,IAAY,EACZ,QAAQ,GAAG,oBAAoB;IAE/B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,MAAM,SAAS,GAAG,IAAA,6BAAe,GAAE,CAAA;IACnC,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACnC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,CAAA;IAEjC,IAAI,MAAM,GAAG,EAAE,CAAA;IACf,IAAI,MAAM,GAAG,CAAC,CAAA;IAEd,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,KAAK,CAAA;QACvB,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;YAC1C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,MAAM,MAAM,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAA;oBAC7C,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;oBAC5B,MAAM,IAAI,MAAM,CAAA;gBAClB,CAAC;qBAAM,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBACzB,MAAM,IAAI,IAAI,CAAA;oBACd,MAAM,GAAG,CAAC,CAAA;gBACZ,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,IAAI,CAAA;oBACd,MAAM,IAAI,IAAA,4BAAW,EAAC,IAAI,CAAC,CAAA;gBAC7B,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/ink/terminal-focus-state.d.ts

@@ -0,0 +1,7 @@
+export type TerminalFocusState = 'focused' | 'blurred' | 'unknown';
+export declare function setTerminalFocused(v: boolean): void;
+export declare function getTerminalFocused(): boolean;
+export declare function getTerminalFocusState(): TerminalFocusState;
+export declare function subscribeTerminalFocus(cb: () => void): () => void;
+export declare function resetTerminalFocusState(): void;
+//# sourceMappingURL=terminal-focus-state.d.ts.map

package/dist/ink/terminal-focus-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-focus-state.d.ts","sourceRoot":"","sources":["../../src/ink/terminal-focus-state.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;AAMlE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAYnD;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED,wBAAgB,qBAAqB,IAAI,kBAAkB,CAE1D;AAGD,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKjE;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAK9C"}

package/dist/ink/terminal-focus-state.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTerminalFocused = setTerminalFocused;
+exports.getTerminalFocused = getTerminalFocused;
+exports.getTerminalFocusState = getTerminalFocusState;
+exports.subscribeTerminalFocus = subscribeTerminalFocus;
+exports.resetTerminalFocusState = resetTerminalFocusState;
+let focusState = 'unknown';
+const resolvers = new Set();
+const subscribers = new Set();
+function setTerminalFocused(v) {
+    focusState = v ? 'focused' : 'blurred';
+    // Notify useSyncExternalStore subscribers
+    for (const cb of subscribers) {
+        cb();
+    }
+    if (!v) {
+        for (const resolve of resolvers) {
+            resolve();
+        }
+        resolvers.clear();
+    }
+}
+function getTerminalFocused() {
+    return focusState !== 'blurred';
+}
+function getTerminalFocusState() {
+    return focusState;
+}
+// For useSyncExternalStore
+function subscribeTerminalFocus(cb) {
+    subscribers.add(cb);
+    return () => {
+        subscribers.delete(cb);
+    };
+}
+function resetTerminalFocusState() {
+    focusState = 'unknown';
+    for (const cb of subscribers) {
+        cb();
+    }
+}
+//# sourceMappingURL=terminal-focus-state.js.map

package/dist/ink/terminal-focus-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-focus-state.js","sourceRoot":"","sources":["../../src/ink/terminal-focus-state.ts"],"names":[],"mappings":";;AAWA,gDAYC;AAED,gDAEC;AAED,sDAEC;AAGD,wDAKC;AAED,0DAKC;AAvCD,IAAI,UAAU,GAAuB,SAAS,CAAA;AAC9C,MAAM,SAAS,GAAoB,IAAI,GAAG,EAAE,CAAA;AAC5C,MAAM,WAAW,GAAoB,IAAI,GAAG,EAAE,CAAA;AAE9C,SAAgB,kBAAkB,CAAC,CAAU;IAC3C,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAA;IACtC,0CAA0C;IAC1C,KAAK,MAAM,EAAE,IAAI,WAAW,EAAE,CAAC;QAC7B,EAAE,EAAE,CAAA;IACN,CAAC;IACD,IAAI,CAAC,CAAC,EAAE,CAAC;QACP,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;YAChC,OAAO,EAAE,CAAA;QACX,CAAC;QACD,SAAS,CAAC,KAAK,EAAE,CAAA;IACnB,CAAC;AACH,CAAC;AAED,SAAgB,kBAAkB;IAChC,OAAO,UAAU,KAAK,SAAS,CAAA;AACjC,CAAC;AAED,SAAgB,qBAAqB;IACnC,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,2BAA2B;AAC3B,SAAgB,sBAAsB,CAAC,EAAc;IACnD,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACnB,OAAO,GAAG,EAAE;QACV,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;IACxB,CAAC,CAAA;AACH,CAAC;AAED,SAAgB,uBAAuB;IACrC,UAAU,GAAG,SAAS,CAAA;IACtB,KAAK,MAAM,EAAE,IAAI,WAAW,EAAE,CAAC;QAC7B,EAAE,EAAE,CAAA;IACN,CAAC;AACH,CAAC"}

package/dist/ink/terminal-querier.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Query the terminal and await responses without timeouts.
+ *
+ * Terminal queries (DECRQM, DA1, OSC 11, etc.) share the stdin stream
+ * with keyboard input. Response sequences are syntactically
+ * distinguishable from key events, so the input parser recognizes them
+ * and dispatches them here.
+ *
+ * To avoid timeouts, each query batch is terminated by a DA1 sentinel
+ * (CSI c) — every terminal since VT100 responds to DA1, and terminals
+ * answer queries in order. So: if your query's response arrives before
+ * DA1's, the terminal supports it; if DA1 arrives first, it doesn't.
+ *
+ * Usage:
+ *   const [sync, grapheme] = await Promise.all([
+ *     querier.send(decrqm(2026)),
+ *     querier.send(decrqm(2027)),
+ *     querier.flush(),
+ *   ])
+ *   // sync and grapheme are DECRPM responses or undefined if unsupported
+ */
+import type { TerminalResponse } from './parse-keypress.js';
+/** A terminal query: an outbound request sequence paired with a matcher
+ *  that recognizes the expected inbound response. Built by `decrqm()`,
+ *  `oscColor()`, `kittyKeyboard()`, etc. */
+export type TerminalQuery<T extends TerminalResponse = TerminalResponse> = {
+    /** Escape sequence to write to stdout */
+    request: string;
+    /** Recognizes the expected response in the inbound stream */
+    match: (r: TerminalResponse) => r is T;
+};
+type DecrpmResponse = Extract<TerminalResponse, {
+    type: 'decrpm';
+}>;
+type Da1Response = Extract<TerminalResponse, {
+    type: 'da1';
+}>;
+type Da2Response = Extract<TerminalResponse, {
+    type: 'da2';
+}>;
+type KittyResponse = Extract<TerminalResponse, {
+    type: 'kittyKeyboard';
+}>;
+type CursorPosResponse = Extract<TerminalResponse, {
+    type: 'cursorPosition';
+}>;
+type OscResponse = Extract<TerminalResponse, {
+    type: 'osc';
+}>;
+type XtversionResponse = Extract<TerminalResponse, {
+    type: 'xtversion';
+}>;
+/** DECRQM: request DEC private mode status (CSI ? mode $ p).
+ *  Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores. */
+export declare function decrqm(mode: number): TerminalQuery<DecrpmResponse>;
+/** Primary Device Attributes query (CSI c). Every terminal answers this —
+ *  used internally by flush() as a universal sentinel. Call directly if
+ *  you want the DA1 params. */
+export declare function da1(): TerminalQuery<Da1Response>;
+/** Secondary Device Attributes query (CSI > c). Returns terminal version. */
+export declare function da2(): TerminalQuery<Da2Response>;
+/** Query current Kitty keyboard protocol flags (CSI ? u).
+ *  Terminal replies with CSI ? flags u or ignores. */
+export declare function kittyKeyboard(): TerminalQuery<KittyResponse>;
+/** DECXCPR: request cursor position with DEC-private marker (CSI ? 6 n).
+ *  Terminal replies with CSI ? row ; col R. The `?` marker is critical —
+ *  the plain DSR form (CSI 6 n → CSI row;col R) is ambiguous with
+ *  modified F3 keys (Shift+F3 = CSI 1;2 R, etc.). */
+export declare function cursorPosition(): TerminalQuery<CursorPosResponse>;
+/** OSC dynamic color query (e.g. OSC 11 for bg color, OSC 10 for fg).
+ *  The `?` data slot asks the terminal to reply with the current value. */
+export declare function oscColor(code: number): TerminalQuery<OscResponse>;
+/** XTVERSION: request terminal name/version (CSI > 0 q).
+ *  Terminal replies with DCS > | name ST (e.g. "xterm.js(5.5.0)") or ignores.
+ *  This survives SSH — the query goes through the pty, not the environment,
+ *  so it identifies the *client* terminal even when TERM_PROGRAM isn't
+ *  forwarded. Used to detect xterm.js for wheel-scroll compensation. */
+export declare function xtversion(): TerminalQuery<XtversionResponse>;
+export declare class TerminalQuerier {
+    private stdout;
+    /**
+     * Interleaved queue of queries and sentinels in send order. Terminals
+     * respond in order, so each flush() barrier only drains queries queued
+     * before it — concurrent batches from independent callers stay isolated.
+     */
+    private queue;
+    constructor(stdout: NodeJS.WriteStream);
+    /**
+     * Send a query and wait for its response.
+     *
+     * Resolves with the response when `query.match` matches an incoming
+     * TerminalResponse, or with `undefined` when a flush() sentinel arrives
+     * before any matching response (meaning the terminal ignored the query).
+     *
+     * Never rejects; never times out on its own. If you never call flush()
+     * and the terminal doesn't respond, the promise remains pending.
+     */
+    send<T extends TerminalResponse>(query: TerminalQuery<T>): Promise<T | undefined>;
+    /**
+     * Send the DA1 sentinel. Resolves when DA1's response arrives.
+     *
+     * As a side effect, all queries still pending when DA1 arrives are
+     * resolved with `undefined` (terminal didn't respond → doesn't support
+     * the query). This is the barrier that makes send() timeout-free.
+     *
+     * Safe to call with no pending queries — still waits for a round-trip.
+     */
+    flush(): Promise<void>;
+    /**
+     * Dispatch a response parsed from stdin. Called by App.tsx's
+     * processKeysInBatch for every `kind: 'response'` item.
+     *
+     * Matching strategy:
+     * - First, try to match a pending query (FIFO, first match wins).
+     *   This lets callers send(da1()) explicitly if they want the DA1
+     *   params — a separate DA1 write means the terminal sends TWO DA1
+     *   responses. The first matches the explicit query; the second
+     *   (unmatched) fires the sentinel.
+     * - Otherwise, if this is a DA1, fire the FIRST pending sentinel:
+     *   resolve any queries queued before that sentinel with undefined
+     *   (the terminal answered DA1 without answering them → unsupported)
+     *   and signal its flush() completion. Only draining up to the first
+     *   sentinel keeps later batches intact when multiple callers have
+     *   concurrent queries in flight.
+     * - Unsolicited responses (no match, no sentinel) are silently dropped.
+     */
+    onResponse(r: TerminalResponse): void;
+}
+export {};
+//# sourceMappingURL=terminal-querier.d.ts.map

package/dist/ink/terminal-querier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-querier.d.ts","sourceRoot":"","sources":["../../src/ink/terminal-querier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAI3D;;4CAE4C;AAC5C,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,IAAI;IACzE,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,6DAA6D;IAC7D,KAAK,EAAE,CAAC,CAAC,EAAE,gBAAgB,KAAK,CAAC,IAAI,CAAC,CAAA;CACvC,CAAA;AAED,KAAK,cAAc,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA;AACnE,KAAK,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAC7D,KAAK,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAC7D,KAAK,aAAa,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC,CAAA;AACzE,KAAK,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAA;AAC9E,KAAK,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAC7D,KAAK,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAA;AAIzE;yEACyE;AACzE,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,cAAc,CAAC,CAKlE;AAED;;+BAE+B;AAC/B,wBAAgB,GAAG,IAAI,aAAa,CAAC,WAAW,CAAC,CAKhD;AAED,6EAA6E;AAC7E,wBAAgB,GAAG,IAAI,aAAa,CAAC,WAAW,CAAC,CAKhD;AAED;sDACsD;AACtD,wBAAgB,aAAa,IAAI,aAAa,CAAC,aAAa,CAAC,CAK5D;AAED;;;qDAGqD;AACrD,wBAAgB,cAAc,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAKjE;AAED;2EAC2E;AAC3E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,CAKjE;AAED;;;;wEAIwE;AACxE,wBAAgB,SAAS,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAK5D;AAeD,qBAAa,eAAe;IAQd,OAAO,CAAC,MAAM;IAP1B;;;;OAIG;IACH,OAAO,CAAC,KAAK,CAAgB;gBAET,MAAM,EAAE,MAAM,CAAC,WAAW;IAE9C;;;;;;;;;OASG;IACH,IAAI,CAAC,CAAC,SAAS,gBAAgB,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAWzB;;;;;;;;OAQG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI;CAiBtC"}

package/dist/ink/terminal-querier.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Query the terminal and await responses without timeouts.
+ *
+ * Terminal queries (DECRQM, DA1, OSC 11, etc.) share the stdin stream
+ * with keyboard input. Response sequences are syntactically
+ * distinguishable from key events, so the input parser recognizes them
+ * and dispatches them here.
+ *
+ * To avoid timeouts, each query batch is terminated by a DA1 sentinel
+ * (CSI c) — every terminal since VT100 responds to DA1, and terminals
+ * answer queries in order. So: if your query's response arrives before
+ * DA1's, the terminal supports it; if DA1 arrives first, it doesn't.
+ *
+ * Usage:
+ *   const [sync, grapheme] = await Promise.all([
+ *     querier.send(decrqm(2026)),
+ *     querier.send(decrqm(2027)),
+ *     querier.flush(),
+ *   ])
+ *   // sync and grapheme are DECRPM responses or undefined if unsupported
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalQuerier = void 0;
+exports.decrqm = decrqm;
+exports.da1 = da1;
+exports.da2 = da2;
+exports.kittyKeyboard = kittyKeyboard;
+exports.cursorPosition = cursorPosition;
+exports.oscColor = oscColor;
+exports.xtversion = xtversion;
+const csi_js_1 = require("./termio/csi.js");
+const osc_js_1 = require("./termio/osc.js");
+// -- Query builders --
+/** DECRQM: request DEC private mode status (CSI ? mode $ p).
+ *  Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores. */
+function decrqm(mode) {
+    return {
+        request: (0, csi_js_1.csi)(`?${mode}$p`),
+        match: (r) => r.type === 'decrpm' && r.mode === mode,
+    };
+}
+/** Primary Device Attributes query (CSI c). Every terminal answers this —
+ *  used internally by flush() as a universal sentinel. Call directly if
+ *  you want the DA1 params. */
+function da1() {
+    return {
+        request: (0, csi_js_1.csi)('c'),
+        match: (r) => r.type === 'da1',
+    };
+}
+/** Secondary Device Attributes query (CSI > c). Returns terminal version. */
+function da2() {
+    return {
+        request: (0, csi_js_1.csi)('>c'),
+        match: (r) => r.type === 'da2',
+    };
+}
+/** Query current Kitty keyboard protocol flags (CSI ? u).
+ *  Terminal replies with CSI ? flags u or ignores. */
+function kittyKeyboard() {
+    return {
+        request: (0, csi_js_1.csi)('?u'),
+        match: (r) => r.type === 'kittyKeyboard',
+    };
+}
+/** DECXCPR: request cursor position with DEC-private marker (CSI ? 6 n).
+ *  Terminal replies with CSI ? row ; col R. The `?` marker is critical —
+ *  the plain DSR form (CSI 6 n → CSI row;col R) is ambiguous with
+ *  modified F3 keys (Shift+F3 = CSI 1;2 R, etc.). */
+function cursorPosition() {
+    return {
+        request: (0, csi_js_1.csi)('?6n'),
+        match: (r) => r.type === 'cursorPosition',
+    };
+}
+/** OSC dynamic color query (e.g. OSC 11 for bg color, OSC 10 for fg).
+ *  The `?` data slot asks the terminal to reply with the current value. */
+function oscColor(code) {
+    return {
+        request: (0, osc_js_1.osc)(code, '?'),
+        match: (r) => r.type === 'osc' && r.code === code,
+    };
+}
+/** XTVERSION: request terminal name/version (CSI > 0 q).
+ *  Terminal replies with DCS > | name ST (e.g. "xterm.js(5.5.0)") or ignores.
+ *  This survives SSH — the query goes through the pty, not the environment,
+ *  so it identifies the *client* terminal even when TERM_PROGRAM isn't
+ *  forwarded. Used to detect xterm.js for wheel-scroll compensation. */
+function xtversion() {
+    return {
+        request: (0, csi_js_1.csi)('>0q'),
+        match: (r) => r.type === 'xtversion',
+    };
+}
+// -- Querier --
+/** Sentinel request sequence (DA1). Kept internal; flush() writes it. */
+const SENTINEL = (0, csi_js_1.csi)('c');
+class TerminalQuerier {
+    constructor(stdout) {
+        this.stdout = stdout;
+        /**
+         * Interleaved queue of queries and sentinels in send order. Terminals
+         * respond in order, so each flush() barrier only drains queries queued
+         * before it — concurrent batches from independent callers stay isolated.
+         */
+        this.queue = [];
+    }
+    /**
+     * Send a query and wait for its response.
+     *
+     * Resolves with the response when `query.match` matches an incoming
+     * TerminalResponse, or with `undefined` when a flush() sentinel arrives
+     * before any matching response (meaning the terminal ignored the query).
+     *
+     * Never rejects; never times out on its own. If you never call flush()
+     * and the terminal doesn't respond, the promise remains pending.
+     */
+    send(query) {
+        return new Promise(resolve => {
+            this.queue.push({
+                kind: 'query',
+                match: query.match,
+                resolve: r => resolve(r),
+            });
+            this.stdout.write(query.request);
+        });
+    }
+    /**
+     * Send the DA1 sentinel. Resolves when DA1's response arrives.
+     *
+     * As a side effect, all queries still pending when DA1 arrives are
+     * resolved with `undefined` (terminal didn't respond → doesn't support
+     * the query). This is the barrier that makes send() timeout-free.
+     *
+     * Safe to call with no pending queries — still waits for a round-trip.
+     */
+    flush() {
+        return new Promise(resolve => {
+            this.queue.push({ kind: 'sentinel', resolve });
+            this.stdout.write(SENTINEL);
+        });
+    }
+    /**
+     * Dispatch a response parsed from stdin. Called by App.tsx's
+     * processKeysInBatch for every `kind: 'response'` item.
+     *
+     * Matching strategy:
+     * - First, try to match a pending query (FIFO, first match wins).
+     *   This lets callers send(da1()) explicitly if they want the DA1
+     *   params — a separate DA1 write means the terminal sends TWO DA1
+     *   responses. The first matches the explicit query; the second
+     *   (unmatched) fires the sentinel.
+     * - Otherwise, if this is a DA1, fire the FIRST pending sentinel:
+     *   resolve any queries queued before that sentinel with undefined
+     *   (the terminal answered DA1 without answering them → unsupported)
+     *   and signal its flush() completion. Only draining up to the first
+     *   sentinel keeps later batches intact when multiple callers have
+     *   concurrent queries in flight.
+     * - Unsolicited responses (no match, no sentinel) are silently dropped.
+     */
+    onResponse(r) {
+        const idx = this.queue.findIndex(p => p.kind === 'query' && p.match(r));
+        if (idx !== -1) {
+            const [q] = this.queue.splice(idx, 1);
+            if (q?.kind === 'query')
+                q.resolve(r);
+            return;
+        }
+        if (r.type === 'da1') {
+            const s = this.queue.findIndex(p => p.kind === 'sentinel');
+            if (s === -1)
+                return;
+            for (const p of this.queue.splice(0, s + 1)) {
+                if (p.kind === 'query')
+                    p.resolve(undefined);
+                else
+                    p.resolve();
+            }
+        }
+    }
+}
+exports.TerminalQuerier = TerminalQuerier;
+//# sourceMappingURL=terminal-querier.js.map

package/dist/ink/terminal-querier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-querier.js","sourceRoot":"","sources":["../../src/ink/terminal-querier.ts"],"names":[],"mappings":"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"}

package/dist/ink/terminal.d.ts

@@ -0,0 +1,56 @@
+import type { Writable } from 'stream';
+import type { Diff } from './frame.js';
+export type Progress = {
+    state: 'running' | 'completed' | 'error' | 'indeterminate';
+    percentage?: number;
+};
+/**
+ * Checks if the terminal supports OSC 9;4 progress reporting.
+ * Supported terminals:
+ * - ConEmu (Windows) - all versions
+ * - Ghostty 1.2.0+
+ * - iTerm2 3.6.6+
+ *
+ * Note: Windows Terminal interprets OSC 9;4 as notifications, not progress.
+ */
+export declare function isProgressReportingAvailable(): boolean;
+/**
+ * Checks if the terminal supports DEC mode 2026 (synchronized output).
+ * When supported, BSU/ESU sequences prevent visible flicker during redraws.
+ */
+export declare function isSynchronizedOutputSupported(): boolean;
+/** Record the XTVERSION response. Called once from App.tsx when the reply
+ *  arrives on stdin. No-op if already set (defend against re-probe). */
+export declare function setXtversionName(name: string): void;
+export declare function isGhosttyTerminal(): boolean;
+/** True if running in an xterm.js-based terminal (VS Code, Cursor, Windsurf
+ *  integrated terminals). Combines TERM_PROGRAM env check (fast, sync, but
+ *  not forwarded over SSH) with the XTVERSION probe result (async, survives
+ *  SSH — query/reply goes through the pty). Early calls may miss the probe
+ *  reply — call lazily (e.g. in an event handler) if SSH detection matters. */
+export declare function isXtermJs(): boolean;
+/** Ghostty currently repaints main-screen prompt updates more reliably
+ *  without DEC 2026 synchronized output. Prefer explicit terminal identity
+ *  (TERM_PROGRAM/TERM or XTVERSION) in real sessions, but keep tests
+ *  deterministic by disabling the env-based detection under NODE_ENV=test. */
+export declare function shouldSkipMainScreenSyncMarkers(): boolean;
+/** Ghostty's main-screen prompt updates are currently more reliable when we
+ *  bypass the incremental diff path and rewrite the visible prompt block. */
+export declare function shouldUseMainScreenRewrite(): boolean;
+/** True if this terminal correctly handles extended key reporting
+ *  (Kitty keyboard protocol + xterm modifyOtherKeys). */
+export declare function supportsExtendedKeys(): boolean;
+/** True if the terminal scrolls the viewport when it receives cursor-up
+ *  sequences that reach above the visible area. On Windows, conhost's
+ *  SetConsoleCursorPosition follows the cursor into scrollback
+ *  (microsoft/terminal#14774), yanking users to the top of their buffer
+ *  mid-stream. WT_SESSION catches WSL-in-Windows-Terminal where platform
+ *  is linux but output still routes through conhost. */
+export declare function hasCursorUpViewportYankBug(): boolean;
+export declare const SYNC_OUTPUT_SUPPORTED: boolean;
+export type Terminal = {
+    stdout: Writable;
+    stderr: Writable;
+};
+export declare function writeDiffToTerminal(terminal: Terminal, diff: Diff, skipSyncMarkers?: boolean): void;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/ink/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/ink/terminal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAItC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAKtC,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,eAAe,CAAA;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAuCtD;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAgDvD;AAcD;wEACwE;AACxE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAK3C;AAED;;;;+EAI+E;AAC/E,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAED;;;8EAG8E;AAC9E,wBAAgB,+BAA+B,IAAI,OAAO,CAEzD;AAED;6EAC6E;AAC7E,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAmBD;yDACyD;AACzD,wBAAgB,oBAAoB,IAAI,OAAO,CAQ9C;AAED;;;;;wDAKwD;AACxD,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAID,eAAO,MAAM,qBAAqB,SAAkC,CAAA;AAEpE,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,EACV,eAAe,UAAQ,GACtB,IAAI,CAsDN"}