terminfo.dev 3.1.2 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminfo.dev",
-  "version": "3.1.2",
+  "version": "3.3.0",
   "description": "Test your terminal's feature support and contribute to terminfo.dev",
   "keywords": [
     "ansi",

package/src/detect.ts

@@ -97,8 +97,10 @@ export function detectTerminal(): TerminalInfo {
   // Linux: check common env vars
   if (name === "unknown") {
     if (process.env.GNOME_TERMINAL_SCREEN) name = "gnome-terminal"
-    else if (process.env.KONSOLE_VERSION) { name = "konsole"; version = process.env.KONSOLE_VERSION }
-    else if (process.env.TILIX_ID) name = "tilix"
+    else if (process.env.KONSOLE_VERSION) {
+      name = "konsole"
+      version = process.env.KONSOLE_VERSION
+    } else if (process.env.TILIX_ID) name = "tilix"
   }
 
   // Windows: check for Windows Terminal

package/src/index.ts

@@ -272,10 +272,10 @@ program
           console.log(`\x1b[31m✗ HTTP ${res.status}\x1b[0m`)
           continue
         }
-        const data = await res.json() as any
+        const data = (await res.json()) as any
         const passed = Object.values(data.results).filter((v: any) => v).length
         const total = Object.keys(data.results).length
-        const pct = Math.round(passed / total * 100)
+        const pct = Math.round((passed / total) * 100)
         const color = pct >= 98 ? "\x1b[32m" : pct >= 90 ? "\x1b[33m" : "\x1b[31m"
         console.log(`${color}${passed}/${total} (${pct}%)\x1b[0m`)
 

package/src/probes/index.ts

@@ -12,7 +12,7 @@
  * 4. Query/response — send query sequence, match response pattern
  */
 
-import { query, queryCursorPosition, measureRenderedWidth, queryMode } from "../tty.ts"
+import { query, queryWithSentinel, queryCursorPosition, measureRenderedWidth, queryMode } from "../tty.ts"
 
 export interface ProbeResult {
   pass: boolean
@@ -379,6 +379,58 @@ const wideCharEmoji: Probe = {
   },
 }
 
+const wideCharEmojiZwj: Probe = {
+  id: "text.wide.emoji-zwj",
+  name: "Emoji ZWJ sequence width",
+  async run() {
+    const width = await measureRenderedWidth("👨‍👩‍👧‍👦")
+    if (width === null) return { pass: false, note: "Cannot measure width" }
+    return {
+      pass: width === 2,
+      note: width === 2 ? undefined : `width=${width}, expected 2`,
+    }
+  },
+}
+
+const wideCharEmojiFlags: Probe = {
+  id: "text.wide.emoji-flags",
+  name: "Regional indicator flag width",
+  async run() {
+    const width = await measureRenderedWidth("🇺🇸")
+    if (width === null) return { pass: false, note: "Cannot measure width" }
+    return {
+      pass: width === 2,
+      note: width === 2 ? undefined : `width=${width}, expected 2`,
+    }
+  },
+}
+
+const wideCharEmojiVs16: Probe = {
+  id: "text.wide.emoji-vs16",
+  name: "Variation selector 16 width",
+  async run() {
+    const width = await measureRenderedWidth("☺\uFE0F")
+    if (width === null) return { pass: false, note: "Cannot measure width" }
+    return {
+      pass: width === 2,
+      note: width === 2 ? undefined : `width=${width}, expected 2`,
+    }
+  },
+}
+
+const combiningChars: Probe = {
+  id: "text.combining",
+  name: "Combining character width",
+  async run() {
+    const width = await measureRenderedWidth("e\u0301")
+    if (width === null) return { pass: false, note: "Cannot measure width" }
+    return {
+      pass: width === 1,
+      note: width === 1 ? undefined : `width=${width}, expected 1`,
+    }
+  },
+}
+
 const tabStop: Probe = {
   id: "text.tab",
   name: "Tab stop (default 8-col)",
@@ -975,7 +1027,7 @@ const kittyKeyboard: Probe = {
   name: "Kitty keyboard protocol",
   async run() {
     // Query current keyboard mode flags — terminal responds with CSI ? flags u
-    const match = await query("\x1b[?u", /\x1b\[\?(\d+)u/, 1000)
+    const match = await queryWithSentinel("\x1b[?u", /\x1b\[\?(\d+)u/)
     if (!match) return { pass: false, note: "No kitty keyboard response" }
     return { pass: true, response: `flags=${match[1]}` }
   },
@@ -1045,7 +1097,7 @@ const osc10FgColor: Probe = {
   id: "extensions.osc10-fg-color",
   name: "Foreground color query (OSC 10)",
   async run() {
-    const match = await query("\x1b]10;?\x07", /\x1b\]10;([^\x07\x1b]+)[\x07\x1b]/, 1000)
+    const match = await queryWithSentinel("\x1b]10;?\x07", /\x1b\]10;([^\x07\x1b]+)[\x07\x1b]/)
     if (!match) return { pass: false, note: "No OSC 10 response" }
     return { pass: true, response: match[1] }
   },
@@ -1055,7 +1107,7 @@ const osc11BgColor: Probe = {
   id: "extensions.osc11-bg-color",
   name: "Background color query (OSC 11)",
   async run() {
-    const match = await query("\x1b]11;?\x07", /\x1b\]11;([^\x07\x1b]+)[\x07\x1b]/, 1000)
+    const match = await queryWithSentinel("\x1b]11;?\x07", /\x1b\]11;([^\x07\x1b]+)[\x07\x1b]/)
     if (!match) return { pass: false, note: "No OSC 11 response" }
     return { pass: true, response: match[1] }
   },
@@ -1170,6 +1222,10 @@ export const ALL_PROBES: Probe[] = [
   textNextLine,
   wideCharCJK,
   wideCharEmoji,
+  wideCharEmojiZwj,
+  wideCharEmojiFlags,
+  wideCharEmojiVs16,
+  combiningChars,
   tabStop,
   backspace,
 
@@ -1199,67 +1255,60 @@ export const ALL_PROBES: Probe[] = [
 
   // ── Modes (DECRPM with behavioral fallback) ──
   behavioralModeProbe(
-    "modes.mouse-tracking", "Mouse tracking (DECSET 1000)", 1000,
-    "\x1b[?1000h", "\x1b[?1000l",
+    "modes.mouse-tracking",
+    "Mouse tracking (DECSET 1000)",
+    1000,
+    "\x1b[?1000h",
+    "\x1b[?1000l",
     async () => {
       // Enable mouse tracking, verify terminal still responds
       const pos = await queryCursorPosition()
       return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
     },
   ),
+  behavioralModeProbe("modes.mouse-sgr", "SGR mouse (DECSET 1006)", 1006, "\x1b[?1006h", "\x1b[?1006l", async () => {
+    const pos = await queryCursorPosition()
+    return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
+  }),
   behavioralModeProbe(
-    "modes.mouse-sgr", "SGR mouse (DECSET 1006)", 1006,
-    "\x1b[?1006h", "\x1b[?1006l",
-    async () => {
-      const pos = await queryCursorPosition()
-      return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
-    },
-  ),
-  behavioralModeProbe(
-    "modes.focus-tracking", "Focus tracking (DECSET 1004)", 1004,
-    "\x1b[?1004h", "\x1b[?1004l",
-    async () => {
-      const pos = await queryCursorPosition()
-      return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
-    },
-  ),
-  behavioralModeProbe(
-    "modes.application-cursor", "App cursor keys (DECCKM)", 1,
-    "\x1b[?1h", "\x1b[?1l",
-    async () => {
-      // In DECCKM mode, arrow keys send ESC O A instead of ESC [ A
-      // Can't test without pressing keys — just verify responsive
-      const pos = await queryCursorPosition()
-      return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
-    },
-  ),
-  behavioralModeProbe(
-    "modes.origin", "Origin mode (DECOM)", 6,
-    "\x1b[?6h", "\x1b[?6l",
-    async () => {
-      // In origin mode, cursor is relative to scroll region
-      // Set scroll region, enable origin, move to 1;1, check actual position
-      process.stdout.write("\x1b[5;10r") // scroll region rows 5-10
-      const pos = await queryCursorPosition()
-      process.stdout.write("\x1b[r") // reset scroll region
-      if (!pos) return { pass: false, note: "No response" }
-      // In origin mode, cursor 1;1 maps to row 5 (top of region)
-      return { pass: pos[0] >= 5, note: `Behavioral: cursor at row ${pos[0]} (origin mapped)` }
-    },
-  ),
-  behavioralModeProbe(
-    "modes.reverse-video", "Reverse video (DECSCNM)", 5,
-    "\x1b[?5h", "\x1b[?5l",
+    "modes.focus-tracking",
+    "Focus tracking (DECSET 1004)",
+    1004,
+    "\x1b[?1004h",
+    "\x1b[?1004l",
     async () => {
-      // Reverse video swaps fg/bg — can't verify visually via PTY
-      // Just verify terminal is responsive after toggling
       const pos = await queryCursorPosition()
       return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
     },
   ),
+  behavioralModeProbe("modes.application-cursor", "App cursor keys (DECCKM)", 1, "\x1b[?1h", "\x1b[?1l", async () => {
+    // In DECCKM mode, arrow keys send ESC O A instead of ESC [ A
+    // Can't test without pressing keys — just verify responsive
+    const pos = await queryCursorPosition()
+    return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
+  }),
+  behavioralModeProbe("modes.origin", "Origin mode (DECOM)", 6, "\x1b[?6h", "\x1b[?6l", async () => {
+    // In origin mode, cursor is relative to scroll region
+    // Set scroll region, enable origin, move to 1;1, check actual position
+    process.stdout.write("\x1b[5;10r") // scroll region rows 5-10
+    const pos = await queryCursorPosition()
+    process.stdout.write("\x1b[r") // reset scroll region
+    if (!pos) return { pass: false, note: "No response" }
+    // In origin mode, cursor 1;1 maps to row 5 (top of region)
+    return { pass: pos[0] >= 5, note: `Behavioral: cursor at row ${pos[0]} (origin mapped)` }
+  }),
+  behavioralModeProbe("modes.reverse-video", "Reverse video (DECSCNM)", 5, "\x1b[?5h", "\x1b[?5l", async () => {
+    // Reverse video swaps fg/bg — can't verify visually via PTY
+    // Just verify terminal is responsive after toggling
+    const pos = await queryCursorPosition()
+    return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }
+  }),
   behavioralModeProbe(
-    "modes.synchronized-output", "Synchronized output (DECSET 2026)", 2026,
-    "\x1b[?2026h", "\x1b[?2026l",
+    "modes.synchronized-output",
+    "Synchronized output (DECSET 2026)",
+    2026,
+    "\x1b[?2026h",
+    "\x1b[?2026l",
     async () => {
       // Synchronized output batches rendering — just verify responsive
       const pos = await queryCursorPosition()
@@ -1341,14 +1390,10 @@ export const ALL_PROBES: Probe[] = [
       // APC G with a=T (transmit), f=100 (PNG), s=1, v=1, payload=minimal
       // The terminal responds with APC G if it supports the protocol
       const payload = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==" // 1x1 red PNG
-      process.stdout.write(`\x1b_Ga=T,f=100,s=1,v=1,t=d;${payload}\x1b\\`)
-      // Check for kitty graphics response: ESC _ G ... ESC backslash
-      const match = await query("", /\x1b_G([^\x1b]*)\x1b\\/, 1000)
+      // Send payload, then use DA1 sentinel to detect support quickly
+      const match = await queryWithSentinel(`\x1b_Ga=T,f=100,s=1,v=1,t=d;${payload}\x1b\\`, /\x1b_G([^\x1b]*)\x1b\\/)
       if (match) return { pass: true, response: match[1] }
-      // Fallback: check if cursor still responds (terminal didn't crash)
-      const pos = await queryCursorPosition()
-      if (!pos) return { pass: false, note: "No response after kitty graphics payload" }
-      return { pass: false, note: "Terminal responsive but no kitty graphics acknowledgment" }
+      return { pass: false, note: "No kitty graphics acknowledgment" }
     },
   } satisfies Probe,
 
@@ -1361,7 +1406,7 @@ export const ALL_PROBES: Probe[] = [
     name: "Text reflow on resize",
     async run() {
       // Check if terminal reports its size (needed for reflow to work)
-      const sizeMatch = await query("\x1b[18t", /\x1b\[8;(\d+);(\d+)t/, 1000)
+      const sizeMatch = await queryWithSentinel("\x1b[18t", /\x1b\[8;(\d+);(\d+)t/)
       if (!sizeMatch) return { pass: false, note: "No XTWINOPS 18 response (can't report size)" }
       const cols = parseInt(sizeMatch[2]!, 10)
       // Write a line longer than terminal width — verify it wraps correctly
@@ -1384,7 +1429,7 @@ export const ALL_PROBES: Probe[] = [
     name: "Scrollback accumulates",
     async run() {
       // Get terminal height first
-      const sizeMatch = await query("\x1b[18t", /\x1b\[8;(\d+);(\d+)t/, 1000)
+      const sizeMatch = await queryWithSentinel("\x1b[18t", /\x1b\[8;(\d+);(\d+)t/)
       const rows = sizeMatch ? parseInt(sizeMatch[1]!, 10) : 24
       process.stdout.write("\x1b[2J\x1b[H") // clear + home
       // Write more lines than the screen can hold
@@ -1444,7 +1489,10 @@ export const ALL_PROBES: Probe[] = [
       if (!pos2) return { pass: false, note: "No cursor response after alt screen exit" }
       return {
         pass: pos2[0] === pos1[0] && pos2[1] === pos1[1],
-        note: pos2[0] === pos1[0] && pos2[1] === pos1[1] ? undefined : `cursor at ${pos2[0]};${pos2[1]}, expected ${pos1[0]};${pos1[1]}`,
+        note:
+          pos2[0] === pos1[0] && pos2[1] === pos1[1]
+            ? undefined
+            : `cursor at ${pos2[0]};${pos2[1]}, expected ${pos1[0]};${pos1[1]}`,
       }
     },
   } satisfies Probe,
@@ -1465,8 +1513,11 @@ export const ALL_PROBES: Probe[] = [
 
   // Mouse all-motion (DECSET 1003)
   behavioralModeProbe(
-    "modes.mouse-all", "All-motion mouse tracking (DECSET 1003)", 1003,
-    "\x1b[?1003h", "\x1b[?1003l",
+    "modes.mouse-all",
+    "All-motion mouse tracking (DECSET 1003)",
+    1003,
+    "\x1b[?1003h",
+    "\x1b[?1003l",
     async () => {
       const pos = await queryCursorPosition()
       return { pass: pos !== null, note: pos ? "Behavioral: responsive after enable" : "No response" }

package/src/serve.ts

@@ -40,12 +40,14 @@ function register(info: DaemonInfo): string {
 }
 
 function unregister(filepath: string) {
-  try { unlinkSync(filepath) } catch {}
+  try {
+    unlinkSync(filepath)
+  } catch {}
 }
 
 export function listDaemons(): DaemonInfo[] {
   try {
-    const files = readdirSync(DAEMON_DIR).filter(f => f.endsWith(".json"))
+    const files = readdirSync(DAEMON_DIR).filter((f) => f.endsWith(".json"))
     const daemons: DaemonInfo[] = []
     for (const f of files) {
       try {
@@ -71,13 +73,15 @@ export async function startDaemon(port = 0): Promise<void> {
     const url = new URL(req.url ?? "/", `http://localhost`)
 
     if (url.pathname === "/info") {
-      res.end(JSON.stringify({
-        terminal: terminal.name,
-        terminalVersion: terminal.version,
-        os: terminal.os,
-        osVersion: terminal.osVersion,
-        probeCount: ALL_PROBES.length,
-      }))
+      res.end(
+        JSON.stringify({
+          terminal: terminal.name,
+          terminalVersion: terminal.version,
+          os: terminal.os,
+          osVersion: terminal.osVersion,
+          probeCount: ALL_PROBES.length,
+        }),
+      )
       return
     }
 
@@ -109,21 +113,23 @@ export async function startDaemon(port = 0): Promise<void> {
       // Reset terminal after probes
       process.stdout.write("\x1bc")
 
-      const passed = Object.values(results).filter(v => v).length
+      const passed = Object.values(results).filter((v) => v).length
       const total = Object.keys(results).length
-      console.log(`\x1b[32m✓\x1b[0m ${passed}/${total} (${Math.round(passed / total * 100)}%)`)
+      console.log(`\x1b[32m✓\x1b[0m ${passed}/${total} (${Math.round((passed / total) * 100)}%)`)
 
-      res.end(JSON.stringify({
-        terminal: terminal.name,
-        terminalVersion: terminal.version,
-        os: terminal.os,
-        osVersion: terminal.osVersion,
-        source: "daemon",
-        generated: new Date().toISOString(),
-        results,
-        notes,
-        responses,
-      }))
+      res.end(
+        JSON.stringify({
+          terminal: terminal.name,
+          terminalVersion: terminal.version,
+          os: terminal.os,
+          osVersion: terminal.osVersion,
+          source: "daemon",
+          generated: new Date().toISOString(),
+          results,
+          notes,
+          responses,
+        }),
+      )
       return
     }
 
@@ -134,7 +140,7 @@ export async function startDaemon(port = 0): Promise<void> {
         res.end(JSON.stringify({ error: "Missing ?id= parameter" }))
         return
       }
-      const probe = ALL_PROBES.find(p => p.id === probeId)
+      const probe = ALL_PROBES.find((p) => p.id === probeId)
       if (!probe) {
         res.statusCode = 404
         res.end(JSON.stringify({ error: `Unknown probe: ${probeId}` }))
@@ -158,16 +164,78 @@ export async function startDaemon(port = 0): Promise<void> {
       return
     }
 
+    if (url.pathname === "/exec" && req.method === "POST") {
+      // Execute raw escape sequence commands in this terminal
+      // POST body: { commands: [{ write: "\\x1b[6n", read: "\\x1b\\[(\\d+);(\\d+)R", timeout?: 1000 }, ...] }
+      const body = await readBody(req)
+      try {
+        const { commands } = JSON.parse(body) as {
+          commands: Array<{ write?: string; read?: string; timeout?: number; measure?: string }>
+        }
+        if (!Array.isArray(commands)) {
+          res.statusCode = 400
+          res.end(JSON.stringify({ error: "commands must be an array" }))
+          return
+        }
+
+        const results: Array<{ response?: string | null; width?: number | null; error?: string }> = []
+
+        await withRawMode(async () => {
+          process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+          for (const cmd of commands) {
+            try {
+              if (cmd.measure) {
+                // Measure rendered width of a string
+                const { measureRenderedWidth } = await import("./tty.ts")
+                const width = await measureRenderedWidth(cmd.measure)
+                results.push({ width })
+              } else if (cmd.write && cmd.read) {
+                // Write sequence, read response
+                const { query } = await import("./tty.ts")
+                const match = await query(
+                  unescapeSequence(cmd.write),
+                  new RegExp(cmd.read),
+                  cmd.timeout ?? 1000,
+                )
+                results.push({ response: match ? match[0] : null })
+              } else if (cmd.write) {
+                // Just write, no response expected
+                process.stdout.write(unescapeSequence(cmd.write))
+                results.push({ response: "ok" })
+              } else {
+                results.push({ error: "command needs write, read, or measure" })
+              }
+            } catch (err) {
+              results.push({ error: err instanceof Error ? err.message : String(err) })
+            }
+          }
+          process.stdout.write("\x1b[0m\x1b[2J\x1b[H")
+          await drainStdin(500)
+        })
+        process.stdout.write("\x1bc")
+
+        console.log(`\x1b[2m[${new Date().toISOString()}] Executed ${commands.length} commands\x1b[0m`)
+        res.end(JSON.stringify({ terminal: terminal.name, results }))
+      } catch (err) {
+        res.statusCode = 400
+        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+      }
+      return
+    }
+
     // Default: show help
-    res.end(JSON.stringify({
-      endpoints: {
-        "/info": "Terminal info",
-        "/probe": "Run all probes",
-        "/probe/single?id=sgr.bold": "Run single probe",
-      },
-      terminal: terminal.name,
-      version: terminal.version,
-    }))
+    res.end(
+      JSON.stringify({
+        endpoints: {
+          "/info": "Terminal info",
+          "/probe": "Run all probes",
+          "/probe/single?id=sgr.bold": "Run single probe",
+          "/exec": "POST — execute raw escape sequence commands",
+        },
+        terminal: terminal.name,
+        version: terminal.version,
+      }),
+    )
   })
 
   server.listen(port, "127.0.0.1", () => {
@@ -209,3 +277,22 @@ export async function startDaemon(port = 0): Promise<void> {
     process.on("SIGTERM", cleanup)
   })
 }
+
+/** Read full request body */
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    req.on("data", (chunk: Buffer) => chunks.push(chunk))
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()))
+    req.on("error", reject)
+  })
+}
+
+/** Convert \\x1b notation to actual escape characters */
+function unescapeSequence(s: string): string {
+  return s.replace(/\\x([0-9a-fA-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+    .replace(/\\e/g, "\x1b")
+    .replace(/\\n/g, "\n")
+    .replace(/\\r/g, "\r")
+    .replace(/\\t/g, "\t")
+}

package/src/tty.ts

@@ -39,13 +39,75 @@ export function readResponse(pattern: RegExp, timeoutMs: number): Promise<string
 
 /**
  * Send an escape sequence and read the response.
- * Handles raw mode setup/teardown.
  */
 export async function query(sequence: string, responsePattern: RegExp, timeoutMs = 1000): Promise<string[] | null> {
   process.stdout.write(sequence)
   return readResponse(responsePattern, timeoutMs)
 }
 
+/**
+ * DA1 response pattern — universally supported by all modern terminals.
+ * Used as a sentinel: if DA1 arrives without the expected response, the
+ * terminal doesn't support the queried feature.
+ */
+const DA1_PATTERN = /\x1b\[\?[0-9;]+c/
+
+/**
+ * Query with DA1 sentinel — faster than timeout-based detection.
+ *
+ * Sends the query sequence followed by DA1 (ESC [ c). Reads responses
+ * looking for either the expected response OR the DA1 sentinel:
+ * - If the query response arrives first → feature is supported, return match
+ * - If DA1 arrives first (without query response) → not supported, return null
+ * - If timeout expires → return null (fallback safety net)
+ *
+ * Inspired by terminal-colorsaurus. Turns 1000ms timeouts into near-instant
+ * negative detection for unsupported features.
+ */
+export async function queryWithSentinel(
+  sequence: string,
+  responsePattern: RegExp,
+  timeoutMs = 2000,
+): Promise<string[] | null> {
+  // Send query + DA1 sentinel back-to-back
+  process.stdout.write(sequence + "\x1b[c")
+
+  let buf = ""
+  let queryMatch: string[] | null = null
+
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      cleanup()
+      resolve(queryMatch)
+    }, timeoutMs)
+
+    function onData(chunk: Buffer) {
+      buf += chunk.toString()
+
+      // Always check for the query response (accumulates across chunks)
+      if (!queryMatch) {
+        const match = buf.match(responsePattern)
+        if (match) queryMatch = [...match]
+      }
+
+      // DA1 is the termination signal in all cases.
+      // - If query matched: DA1 confirms we've consumed the sentinel, safe to return
+      // - If query didn't match: DA1 means the terminal doesn't support the feature
+      if (DA1_PATTERN.test(buf)) {
+        cleanup()
+        resolve(queryMatch)
+      }
+    }
+
+    function cleanup() {
+      clearTimeout(timer)
+      process.stdin.off("data", onData)
+    }
+
+    process.stdin.on("data", onData)
+  })
+}
+
 /**
  * Query cursor position via DSR 6 (Device Status Report).
  * Returns [row, col] (1-based) or null if no response.
@@ -71,10 +133,11 @@ export async function measureRenderedWidth(text: string): Promise<number | null>
 
 /**
  * Query whether a DEC private mode is recognized via DECRPM.
+ * Uses DA1 sentinel for fast negative detection.
  * Returns "set", "reset", "unknown", or null (no response).
  */
 export async function queryMode(modeNumber: number): Promise<"set" | "reset" | "unknown" | null> {
-  const match = await query(`\x1b[?${modeNumber}$p`, /\x1b\[\?(\d+);(\d+)\$y/)
+  const match = await queryWithSentinel(`\x1b[?${modeNumber}$p`, /\x1b\[\?(\d+);(\d+)\$y/)
   if (!match) return null
   const status = parseInt(match[2]!, 10)
   switch (status) {