terminfo.dev 0.1.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "terminfo.dev",
+  "version": "0.1.0",
+  "description": "Test your terminal's feature support and contribute to terminfo.dev",
+  "keywords": [
+    "ansi",
+    "conformance",
+    "escape-sequences",
+    "terminal",
+    "terminal-emulator",
+    "testing"
+  ],
+  "homepage": "https://terminfo.dev/",
+  "bugs": {
+    "url": "https://github.com/beorn/terminfo.dev/issues"
+  },
+  "license": "MIT",
+  "author": "Beorn",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beorn/terminfo.dev.git",
+    "directory": "cli"
+  },
+  "bin": {
+    "terminfo": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=23.6.0"
+  }
+}

package/src/detect.ts

@@ -0,0 +1,103 @@
+/**
+ * Terminal detection — identify the running terminal emulator.
+ *
+ * Uses environment variables, DA2 response parsing, and fallback heuristics.
+ */
+
+import { release } from "node:os"
+
+export interface TerminalInfo {
+  name: string
+  version: string
+  os: string
+  osVersion: string
+}
+
+/** Known terminal detection via environment variables */
+const ENV_DETECTORS: Array<{ env: string; name: string; versionEnv?: string }> = [
+  { env: "GHOSTTY_RESOURCES_DIR", name: "ghostty" },
+  { env: "KITTY_WINDOW_ID", name: "kitty" },
+  { env: "WEZTERM_EXECUTABLE", name: "wezterm" },
+  { env: "ALACRITTY_WINDOW_ID", name: "alacritty" },
+]
+
+/** Detect from $TERM_PROGRAM */
+const TERM_PROGRAM_MAP: Record<string, string> = {
+  iTerm: "iterm2",
+  "iTerm.app": "iterm2",
+  Apple_Terminal: "terminal-app",
+  WezTerm: "wezterm",
+  vscode: "vscode",
+  Hyper: "hyper",
+  tmux: "tmux",
+  WarpTerminal: "warp",
+}
+
+export function detectTerminal(): TerminalInfo {
+  const os = detectOS()
+  const osVersion = detectOSVersion()
+
+  // Check specific env vars first
+  for (const { env, name } of ENV_DETECTORS) {
+    if (process.env[env]) {
+      return { name, version: "", os, osVersion }
+    }
+  }
+
+  // Check $TERM_PROGRAM
+  const termProgram = process.env.TERM_PROGRAM
+  if (termProgram) {
+    const name = TERM_PROGRAM_MAP[termProgram] ?? termProgram.toLowerCase()
+    const version = process.env.TERM_PROGRAM_VERSION ?? ""
+    return { name, version, os, osVersion }
+  }
+
+  // Check $TERMINAL_EMULATOR (set by some Linux terminals)
+  const termEmu = process.env.TERMINAL_EMULATOR
+  if (termEmu) {
+    return { name: termEmu.toLowerCase(), version: "", os, osVersion }
+  }
+
+  // Fallback: use $TERM
+  const term = process.env.TERM ?? "unknown"
+  return { name: term, version: "", os, osVersion }
+}
+
+function detectOS(): string {
+  switch (process.platform) {
+    case "darwin":
+      return "macos"
+    case "linux":
+      return "linux"
+    case "win32":
+      return "windows"
+    default:
+      return process.platform
+  }
+}
+
+function detectOSVersion(): string {
+  try {
+    return release()
+  } catch {
+    return ""
+  }
+}
+
+/**
+ * Query terminal identity via DA2 (Secondary Device Attributes).
+ * Sends CSI > 0 c and parses the response.
+ *
+ * Must be called with raw mode enabled on stdin.
+ */
+export async function queryDA2(
+  readResponse: (pattern: RegExp, timeoutMs: number) => Promise<string[] | null>,
+): Promise<{ terminalId: number; version: number } | null> {
+  process.stdout.write("\x1b[>0c")
+  const match = await readResponse(/\x1b\[>(\d+);(\d+);(\d+)c/, 1000)
+  if (!match) return null
+  return {
+    terminalId: parseInt(match[1]!, 10),
+    version: parseInt(match[2]!, 10),
+  }
+}

package/src/index.ts

@@ -0,0 +1,143 @@
+#!/usr/bin/env bun
+/**
+ * terminfo CLI — test your terminal's feature support.
+ *
+ * Runs probes against the real terminal you're using (not a headless library),
+ * shows results, and optionally submits them to terminfo.dev.
+ *
+ * @example
+ * ```bash
+ * npx terminfo          # Run all probes
+ * npx terminfo --json   # Output JSON results
+ * npx terminfo --submit # Submit results to terminfo.dev
+ * ```
+ */
+
+import { detectTerminal } from "./detect.ts"
+import { ALL_PROBES } from "./probes/index.ts"
+import { withRawMode } from "./tty.ts"
+import { submitResults } from "./submit.ts"
+
+interface ResultEntry {
+  terminal: string
+  terminalVersion: string
+  os: string
+  osVersion: string
+  source: "community"
+  generated: string
+  results: Record<string, boolean>
+  notes: Record<string, string>
+  responses: Record<string, string>
+}
+
+async function main() {
+  const args = process.argv.slice(2)
+  const jsonMode = args.includes("--json")
+  const submitMode = args.includes("--submit")
+
+  // Detect terminal
+  const terminal = detectTerminal()
+
+  if (!jsonMode) {
+    console.log(`\x1b[1mterminfo\x1b[0m — terminal feature testing for terminfo.dev\n`)
+    console.log(
+      `Detected: \x1b[1m${terminal.name}\x1b[0m${terminal.version ? ` ${terminal.version}` : ""} on ${terminal.os}${terminal.osVersion ? ` ${terminal.osVersion}` : ""}`,
+    )
+    console.log(`Running ${ALL_PROBES.length} probes...\n`)
+  }
+
+  // Save/restore screen state
+  process.stdout.write("\x1b7") // save cursor
+  process.stdout.write("\x1b[?1049h") // alt screen
+  process.stdout.write("\x1b[2J\x1b[H") // clear + home
+
+  const results: Record<string, boolean> = {}
+  const notes: Record<string, string> = {}
+  const responses: Record<string, string> = {}
+  let passed = 0
+  let failed = 0
+
+  await withRawMode(async () => {
+    for (const probe of ALL_PROBES) {
+      try {
+        const result = await probe.run()
+        results[probe.id] = result.pass
+        if (result.note) notes[probe.id] = result.note
+        if (result.response) responses[probe.id] = result.response
+        if (result.pass) passed++
+        else failed++
+      } catch (err) {
+        results[probe.id] = false
+        notes[probe.id] = `error: ${err instanceof Error ? err.message : String(err)}`
+        failed++
+      }
+    }
+  })
+
+  // Restore screen
+  process.stdout.write("\x1b[?1049l") // exit alt screen
+  process.stdout.write("\x1b8") // restore cursor
+
+  const total = ALL_PROBES.length
+  const pct = Math.round((passed / total) * 100)
+
+  const entry: ResultEntry = {
+    terminal: terminal.name,
+    terminalVersion: terminal.version,
+    os: terminal.os,
+    osVersion: terminal.osVersion,
+    source: "community",
+    generated: new Date().toISOString(),
+    results,
+    notes,
+    responses,
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify(entry, null, 2))
+    return
+  }
+
+  // Display results
+  console.log(`\n\x1b[1mResults: ${passed}/${total} (${pct}%)\x1b[0m\n`)
+
+  // Show categories
+  const categories = new Map<string, Array<{ id: string; name: string; pass: boolean; note?: string }>>()
+  for (const probe of ALL_PROBES) {
+    const cat = probe.id.split(".")[0]!
+    if (!categories.has(cat)) categories.set(cat, [])
+    categories.get(cat)!.push({
+      id: probe.id,
+      name: probe.name,
+      pass: results[probe.id] ?? false,
+      note: notes[probe.id],
+    })
+  }
+
+  for (const [cat, probes] of categories) {
+    const catPassed = probes.filter((p) => p.pass).length
+    const color = catPassed === probes.length ? "\x1b[32m" : catPassed > 0 ? "\x1b[33m" : "\x1b[31m"
+    console.log(`${color}${cat}\x1b[0m (${catPassed}/${probes.length})`)
+    for (const p of probes) {
+      const icon = p.pass ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m"
+      const note = p.note ? ` \x1b[2m— ${p.note}\x1b[0m` : ""
+      console.log(`  ${icon} ${p.name}${note}`)
+    }
+  }
+
+  if (submitMode) {
+    console.log(`\nSubmitting results to terminfo.dev...`)
+    const url = await submitResults(entry)
+    if (url) {
+      console.log(`\x1b[32m✓ Issue created:\x1b[0m ${url}`)
+    }
+  } else {
+    console.log(`\n\x1b[2mSubmit results to terminfo.dev: npx terminfo --submit\x1b[0m`)
+    console.log(`\x1b[2mJSON output: npx terminfo --json\x1b[0m`)
+  }
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/src/probes/index.ts

@@ -0,0 +1,460 @@
+/**
+ * Real-terminal probes — test actual terminal capabilities via PTY I/O.
+ *
+ * Unlike headless probes (which read cell state programmatically), these send
+ * escape sequences to stdout and read responses from stdin. They verify what
+ * the terminal *claims* to support, not just what a headless library exposes.
+ */
+
+import { query, queryCursorPosition, measureRenderedWidth, queryMode } from "../tty.ts"
+
+export interface ProbeResult {
+  pass: boolean
+  note?: string
+  response?: string
+}
+
+export interface Probe {
+  id: string
+  name: string
+  run: () => Promise<ProbeResult>
+}
+
+// ── Cursor probes ──
+
+const cursorPositionReport: Probe = {
+  id: "cursor.position-report",
+  name: "Cursor position report (DSR 6)",
+  async run() {
+    process.stdout.write("\x1b[3;5H") // Move to row 3, col 5
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No DSR 6 response" }
+    return {
+      pass: pos[0] === 3 && pos[1] === 5,
+      note: pos[0] === 3 && pos[1] === 5 ? undefined : `got ${pos[0]};${pos[1]}, expected 3;5`,
+      response: `${pos[0]};${pos[1]}`,
+    }
+  },
+}
+
+const cursorShape: Probe = {
+  id: "cursor.shape",
+  name: "Cursor shape (DECSCUSR)",
+  async run() {
+    // Set cursor to bar shape, then query via DECRPM-like
+    // Most terminals accept DECSCUSR but we can't read shape back via PTY
+    // Instead, verify the sequence doesn't crash and cursor still responds
+    process.stdout.write("\x1b[5 q") // blinking bar
+    const pos = await queryCursorPosition()
+    process.stdout.write("\x1b[0 q") // restore default
+    return {
+      pass: pos !== null,
+      note: pos ? undefined : "No response after DECSCUSR",
+    }
+  },
+}
+
+// ── Device probes ──
+
+const primaryDA: Probe = {
+  id: "device.primary-da",
+  name: "Primary device attributes (DA1)",
+  async run() {
+    const match = await query("\x1b[c", /\x1b\[\?([0-9;]+)c/, 1000)
+    if (!match) return { pass: false, note: "No DA1 response" }
+    return { pass: true, response: match[0] }
+  },
+}
+
+const deviceStatusReport: Probe = {
+  id: "device.status-report",
+  name: "Device status report (DSR 5)",
+  async run() {
+    const match = await query("\x1b[5n", /\x1b\[(\d+)n/, 1000)
+    if (!match) return { pass: false, note: "No DSR 5 response" }
+    return {
+      pass: match[1] === "0",
+      note: match[1] === "0" ? undefined : `status ${match[1]}`,
+      response: match[0],
+    }
+  },
+}
+
+// ── Mode probes (DECRPM) ──
+
+function modeProbe(id: string, name: string, modeNum: number): Probe {
+  return {
+    id,
+    name,
+    async run() {
+      const result = await queryMode(modeNum)
+      if (result === null) return { pass: false, note: "No DECRPM response" }
+      return {
+        pass: result !== "unknown",
+        note: result === "unknown" ? "Mode not recognized" : `Mode ${result}`,
+        response: result,
+      }
+    },
+  }
+}
+
+// ── Text width probes ──
+
+const wideCharCJK: Probe = {
+  id: "text.wide.cjk",
+  name: "CJK wide chars (2 cols)",
+  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 wideCharEmoji: Probe = {
+  id: "text.wide.emoji",
+  name: "Emoji wide chars (2 cols)",
+  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`,
+    }
+  },
+}
+
+// ── SGR probes (write + cursor position to verify parsing) ──
+
+function sgrProbe(id: string, name: string, sequence: string): Probe {
+  return {
+    id,
+    name,
+    async run() {
+      // Write SGR sequence + text, verify cursor advances (sequence was parsed, not printed)
+      process.stdout.write("\x1b[1;1H\x1b[2K") // clear line
+      process.stdout.write(sequence + "X\x1b[0m")
+      const pos = await queryCursorPosition()
+      if (!pos) return { pass: false, note: "No cursor response" }
+      // Cursor should be at col 2 (wrote 1 char "X")
+      return {
+        pass: pos[1] === 2,
+        note: pos[1] === 2 ? undefined : `cursor at col ${pos[1]}, expected 2`,
+      }
+    },
+  }
+}
+
+// ── Cursor save/restore ──
+
+const cursorSaveRestore: Probe = {
+  id: "cursor.save-restore",
+  name: "Cursor save/restore (DECSC/DECRC)",
+  async run() {
+    process.stdout.write("\x1b[3;5H") // Move to row 3, col 5
+    process.stdout.write("\x1b7") // DECSC — save cursor
+    process.stdout.write("\x1b[10;10H") // Move somewhere else
+    process.stdout.write("\x1b8") // DECRC — restore cursor
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response after restore" }
+    return {
+      pass: pos[0] === 3 && pos[1] === 5,
+      note: pos[0] === 3 && pos[1] === 5 ? undefined : `got ${pos[0]};${pos[1]}, expected 3;5`,
+      response: `${pos[0]};${pos[1]}`,
+    }
+  },
+}
+
+// ── Erase probes ──
+
+const eraseLineRight: Probe = {
+  id: "erase.line.right",
+  name: "Erase line right (EL 0)",
+  async run() {
+    process.stdout.write("\x1b[1;1H\x1b[2K") // Clear line
+    process.stdout.write("ABCDE")
+    process.stdout.write("\x1b[1;3H") // Move to col 3
+    process.stdout.write("\x1b[0K") // EL 0 — erase to right
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response" }
+    return {
+      pass: pos[1] === 3,
+      note: pos[1] === 3 ? undefined : `cursor at col ${pos[1]}, expected 3`,
+    }
+  },
+}
+
+const eraseScreenScrollback: Probe = {
+  id: "erase.screen.scrollback",
+  name: "Erase scrollback (ED 3)",
+  async run() {
+    process.stdout.write("\x1b[5;5H") // Move to known position
+    process.stdout.write("\x1b[3J") // ED 3 — erase scrollback
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response after ED 3" }
+    return {
+      pass: pos[0] === 5 && pos[1] === 5,
+      note: pos[0] === 5 && pos[1] === 5 ? undefined : `cursor at ${pos[0]};${pos[1]}, expected 5;5`,
+    }
+  },
+}
+
+// ── Scroll region ──
+
+const scrollRegion: Probe = {
+  id: "scrollback.set-region",
+  name: "Scroll region (DECSTBM)",
+  async run() {
+    process.stdout.write("\x1b[5;10r") // Set scroll region rows 5–10
+    process.stdout.write("\x1b[r") // Reset scroll region
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response after DECSTBM" }
+    // After reset, cursor should still respond — terminal didn't crash
+    return { pass: true }
+  },
+}
+
+// ── Tab and backspace ──
+
+const tabStop: Probe = {
+  id: "text.tab",
+  name: "Tab stop (default 8-col)",
+  async run() {
+    process.stdout.write("\x1b[1;1H\x1b[2K") // Clear line, move to col 1
+    process.stdout.write("\t") // Tab
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response" }
+    return {
+      pass: pos[1] === 9,
+      note: pos[1] === 9 ? undefined : `cursor at col ${pos[1]}, expected 9`,
+    }
+  },
+}
+
+const backspace: Probe = {
+  id: "text.backspace",
+  name: "Backspace (BS)",
+  async run() {
+    process.stdout.write("\x1b[1;5H") // Move to col 5
+    process.stdout.write("\b") // BS
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response" }
+    return {
+      pass: pos[1] === 4,
+      note: pos[1] === 4 ? undefined : `cursor at col ${pos[1]}, expected 4`,
+    }
+  },
+}
+
+// ── Insert/delete character probes ──
+
+const insertChars: Probe = {
+  id: "editing.insert-chars",
+  name: "Insert characters (ICH)",
+  async run() {
+    process.stdout.write("\x1b[1;1H\x1b[2K") // Clear line
+    process.stdout.write("ABCD")
+    process.stdout.write("\x1b[1;2H") // Move to col 2
+    process.stdout.write("\x1b[1@") // ICH 1 — insert 1 blank char
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response" }
+    // Cursor should remain at col 2 after insert
+    return {
+      pass: pos[1] === 2,
+      note: pos[1] === 2 ? undefined : `cursor at col ${pos[1]}, expected 2`,
+    }
+  },
+}
+
+const deleteChars: Probe = {
+  id: "editing.delete-chars",
+  name: "Delete characters (DCH)",
+  async run() {
+    process.stdout.write("\x1b[1;1H\x1b[2K") // Clear line
+    process.stdout.write("ABCD")
+    process.stdout.write("\x1b[1;2H") // Move to col 2
+    process.stdout.write("\x1b[1P") // DCH 1 — delete 1 char
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response" }
+    // Cursor should remain at col 2 after delete
+    return {
+      pass: pos[1] === 2,
+      note: pos[1] === 2 ? undefined : `cursor at col ${pos[1]}, expected 2`,
+    }
+  },
+}
+
+// ── Reset ──
+
+const resetRIS: Probe = {
+  id: "reset.ris",
+  name: "Full reset (RIS)",
+  async run() {
+    process.stdout.write("\x1b[5;5H") // Move somewhere away from 1;1
+    process.stdout.write("\x1bc") // RIS — full reset
+    const pos = await queryCursorPosition()
+    if (!pos) return { pass: false, note: "No cursor response after RIS" }
+    return {
+      pass: pos[0] === 1 && pos[1] === 1,
+      note: pos[0] === 1 && pos[1] === 1 ? undefined : `cursor at ${pos[0]};${pos[1]}, expected 1;1`,
+    }
+  },
+}
+
+// ── Extensions probes ──
+
+const kittyKeyboard: Probe = {
+  id: "extensions.kitty-keyboard",
+  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)
+    if (!match) return { pass: false, note: "No kitty keyboard response" }
+    return { pass: true, response: `flags=${match[1]}` }
+  },
+}
+
+const sixelSupport: Probe = {
+  id: "extensions.sixel",
+  name: "Sixel graphics (DA1 bit 4)",
+  async run() {
+    const match = await query("\x1b[c", /\x1b\[\?([0-9;]+)c/, 1000)
+    if (!match) return { pass: false, note: "No DA1 response" }
+    const attrs = match[1]!.split(";")
+    const hasSixel = attrs.includes("4")
+    return {
+      pass: hasSixel,
+      note: hasSixel ? undefined : "DA1 response missing ;4 (sixel)",
+      response: match[1],
+    }
+  },
+}
+
+const osc52Clipboard: Probe = {
+  id: "extensions.osc52-clipboard",
+  name: "Clipboard query (OSC 52)",
+  async run() {
+    const match = await query("\x1b]52;c;?\x07", /\x1b\]52;([^\x07\x1b]+)[\x07\x1b]/, 1000)
+    if (!match) return { pass: false, note: "No OSC 52 response" }
+    return { pass: true, response: match[1] }
+  },
+}
+
+const osc7Cwd: Probe = {
+  id: "extensions.osc7-cwd",
+  name: "Current directory (OSC 7)",
+  async run() {
+    // OSC 7 sets the working directory — can't read it back, just verify no crash
+    process.stdout.write("\x1b]7;file:///tmp\x07")
+    const pos = await queryCursorPosition()
+    return { pass: pos !== null }
+  },
+}
+
+// ── OSC probes ──
+
+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)
+    if (!match) return { pass: false, note: "No OSC 10 response" }
+    return { pass: true, response: match[1] }
+  },
+}
+
+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)
+    if (!match) return { pass: false, note: "No OSC 11 response" }
+    return { pass: true, response: match[1] }
+  },
+}
+
+const osc2Title: Probe = {
+  id: "extensions.osc2-title",
+  name: "Window title (OSC 2)",
+  async run() {
+    // Set title and verify no crash; can't read it back via PTY
+    process.stdout.write("\x1b]2;terminfo-test\x07")
+    const pos = await queryCursorPosition()
+    process.stdout.write("\x1b]2;\x07") // reset title
+    return { pass: pos !== null }
+  },
+}
+
+// ── All probes ──
+
+export const ALL_PROBES: Probe[] = [
+  // Cursor
+  cursorPositionReport,
+  cursorShape,
+  cursorSaveRestore,
+
+  // Device
+  primaryDA,
+  deviceStatusReport,
+
+  // Modes via DECRPM
+  modeProbe("modes.alt-screen.enter", "Alt screen (DECSET 1049)", 1049),
+  modeProbe("modes.bracketed-paste", "Bracketed paste (DECSET 2004)", 2004),
+  modeProbe("modes.mouse-tracking", "Mouse tracking (DECSET 1000)", 1000),
+  modeProbe("modes.mouse-sgr", "SGR mouse (DECSET 1006)", 1006),
+  modeProbe("modes.focus-tracking", "Focus tracking (DECSET 1004)", 1004),
+  modeProbe("modes.auto-wrap", "Auto-wrap (DECAWM)", 7),
+  modeProbe("modes.application-cursor", "App cursor keys (DECCKM)", 1),
+  modeProbe("modes.origin", "Origin mode (DECOM)", 6),
+  modeProbe("modes.reverse-video", "Reverse video (DECSCNM)", 5),
+  modeProbe("modes.synchronized-output", "Synchronized output (DECSET 2026)", 2026),
+
+  // Text width
+  wideCharCJK,
+  wideCharEmoji,
+
+  // Text behavior
+  tabStop,
+  backspace,
+
+  // Erase
+  eraseLineRight,
+  eraseScreenScrollback,
+
+  // Editing
+  insertChars,
+  deleteChars,
+
+  // Scroll region
+  scrollRegion,
+
+  // Reset
+  resetRIS,
+
+  // SGR (verify sequence is parsed, not printed)
+  sgrProbe("sgr.bold", "Bold (SGR 1)", "\x1b[1m"),
+  sgrProbe("sgr.faint", "Faint (SGR 2)", "\x1b[2m"),
+  sgrProbe("sgr.italic", "Italic (SGR 3)", "\x1b[3m"),
+  sgrProbe("sgr.underline.single", "Underline (SGR 4)", "\x1b[4m"),
+  sgrProbe("sgr.underline.double", "Double underline (SGR 21)", "\x1b[21m"),
+  sgrProbe("sgr.underline.curly", "Curly underline (SGR 4:3)", "\x1b[4:3m"),
+  sgrProbe("sgr.underline.dotted", "Dotted underline (SGR 4:4)", "\x1b[4:4m"),
+  sgrProbe("sgr.underline.dashed", "Dashed underline (SGR 4:5)", "\x1b[4:5m"),
+  sgrProbe("sgr.blink", "Blink (SGR 5)", "\x1b[5m"),
+  sgrProbe("sgr.inverse", "Inverse (SGR 7)", "\x1b[7m"),
+  sgrProbe("sgr.strikethrough", "Strikethrough (SGR 9)", "\x1b[9m"),
+  sgrProbe("sgr.overline", "Overline (SGR 53)", "\x1b[53m"),
+
+  // Extensions
+  kittyKeyboard,
+  sixelSupport,
+  osc52Clipboard,
+  osc7Cwd,
+
+  // OSC
+  osc10FgColor,
+  osc11BgColor,
+  osc2Title,
+]

package/src/submit.ts

@@ -0,0 +1,125 @@
+/**
+ * Submit results to terminfo.dev via GitHub issue.
+ *
+ * Creates an issue on beorn/terminfo.dev with the JSON results
+ * attached as a code block. Maintainers review and merge into
+ * the results database.
+ */
+
+const REPO = "beorn/terminfo.dev"
+const ISSUE_LABEL = "community-results"
+
+interface SubmitResult {
+  terminal: string
+  terminalVersion: string
+  os: string
+  osVersion: string
+  results: Record<string, boolean>
+  notes: Record<string, string>
+  responses: Record<string, string>
+  generated: string
+}
+
+/**
+ * Submit results by creating a GitHub issue.
+ * Requires `gh` CLI to be installed and authenticated.
+ */
+export async function submitResults(data: SubmitResult): Promise<string | null> {
+  const passed = Object.values(data.results).filter(Boolean).length
+  const total = Object.keys(data.results).length
+  const pct = Math.round((passed / total) * 100)
+
+  const title = `[census] ${data.terminal}${data.terminalVersion ? ` ${data.terminalVersion}` : ""} on ${data.os} — ${pct}% (${passed}/${total})`
+
+  const body = `## Community Census Result
+
+| Field | Value |
+|-------|-------|
+| Terminal | ${data.terminal} |
+| Version | ${data.terminalVersion || "unknown"} |
+| OS | ${data.os} ${data.osVersion || ""} |
+| Score | ${passed}/${total} (${pct}%) |
+| Generated | ${data.generated} |
+
+### Results
+
+<details>
+<summary>Full JSON (click to expand)</summary>
+
+\`\`\`json
+${JSON.stringify(data, null, 2)}
+\`\`\`
+
+</details>
+
+### Summary
+
+${formatSummary(data)}
+
+---
+*Submitted via \`npx terminfo\`*`
+
+  // Try gh CLI first
+  if (await hasGhCli()) {
+    try {
+      const { execSync } = await import("node:child_process")
+      const result = execSync(
+        `gh issue create --repo ${REPO} --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --label ${ISSUE_LABEL}`,
+        { encoding: "utf-8", timeout: 30000 },
+      )
+      const url = result.trim()
+      return url
+    } catch (err) {
+      console.error(`\x1b[31mFailed to create issue via gh CLI\x1b[0m`)
+      console.error(err instanceof Error ? err.message : String(err))
+      return null
+    }
+  }
+
+  // Fallback: write to file and give instructions
+  const { writeFileSync } = await import("node:fs")
+  const filename = `terminfo-${data.terminal}-${data.os}-${Date.now()}.json`
+  writeFileSync(filename, JSON.stringify(data, null, 2))
+  console.log(`\n\x1b[33mgh CLI not found. Results saved to ${filename}\x1b[0m`)
+  console.log(`To submit manually:`)
+  console.log(`  1. Go to https://github.com/${REPO}/issues/new`)
+  console.log(`  2. Title: ${title}`)
+  console.log(`  3. Paste the contents of ${filename}`)
+  return null
+}
+
+async function hasGhCli(): Promise<boolean> {
+  try {
+    const { execSync } = await import("node:child_process")
+    execSync("gh --version", { stdio: "ignore", timeout: 5000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function formatSummary(data: SubmitResult): string {
+  const categories = new Map<string, { pass: number; fail: number; failList: string[] }>()
+
+  for (const [id, pass] of Object.entries(data.results)) {
+    const cat = id.split(".")[0]!
+    if (!categories.has(cat)) categories.set(cat, { pass: 0, fail: 0, failList: [] })
+    const entry = categories.get(cat)!
+    if (pass) entry.pass++
+    else {
+      entry.fail++
+      const note = data.notes[id]
+      entry.failList.push(note ? `- \`${id}\`: ${note}` : `- \`${id}\``)
+    }
+  }
+
+  const lines: string[] = []
+  for (const [cat, { pass, fail, failList }] of categories) {
+    const total = pass + fail
+    const icon = fail === 0 ? "✅" : "⚠️"
+    lines.push(`${icon} **${cat}**: ${pass}/${total}`)
+    if (failList.length > 0) lines.push(...failList)
+  }
+
+  return lines.join("\n")
+}

package/src/tty.ts

@@ -0,0 +1,110 @@
+/**
+ * TTY utilities — raw mode, response reading, escape sequence I/O.
+ *
+ * The core primitive: write an escape sequence to stdout, read a response
+ * from stdin within a timeout.
+ */
+
+/**
+ * Read a response matching a pattern from stdin within a timeout.
+ * Must be called while stdin is in raw mode.
+ */
+export function readResponse(pattern: RegExp, timeoutMs: number): Promise<string[] | null> {
+  return new Promise((resolve) => {
+    let buf = ""
+    let timer: ReturnType<typeof setTimeout>
+
+    const onData = (chunk: Buffer) => {
+      buf += chunk.toString()
+      const match = buf.match(pattern)
+      if (match) {
+        cleanup()
+        resolve([...match])
+      }
+    }
+
+    const cleanup = () => {
+      clearTimeout(timer)
+      process.stdin.off("data", onData)
+    }
+
+    timer = setTimeout(() => {
+      cleanup()
+      resolve(null)
+    }, timeoutMs)
+
+    process.stdin.on("data", onData)
+  })
+}
+
+/**
+ * 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)
+}
+
+/**
+ * Query cursor position via DSR 6 (Device Status Report).
+ * Returns [row, col] (1-based) or null if no response.
+ */
+export async function queryCursorPosition(): Promise<[number, number] | null> {
+  const match = await query("\x1b[6n", /\x1b\[(\d+);(\d+)R/)
+  if (!match) return null
+  return [parseInt(match[1]!, 10), parseInt(match[2]!, 10)]
+}
+
+/**
+ * Write text, then query cursor position to determine rendered width.
+ */
+export async function measureRenderedWidth(text: string): Promise<number | null> {
+  // Save cursor, move to col 1, write text, query position
+  process.stdout.write("\x1b7\x1b[1G" + text)
+  const pos = await queryCursorPosition()
+  // Restore cursor
+  process.stdout.write("\x1b8")
+  if (!pos) return null
+  return pos[1] - 1 // col is 1-based, width is 0-based
+}
+
+/**
+ * Query whether a DEC private mode is recognized via DECRPM.
+ * 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/)
+  if (!match) return null
+  const status = parseInt(match[2]!, 10)
+  switch (status) {
+    case 1:
+      return "set"
+    case 2:
+      return "reset"
+    case 0:
+      return "unknown"
+    default:
+      return null
+  }
+}
+
+/**
+ * Run a function with stdin in raw mode.
+ * Restores original mode on exit.
+ */
+export async function withRawMode<T>(fn: () => Promise<T>): Promise<T> {
+  const wasRaw = process.stdin.isRaw
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true)
+    process.stdin.resume()
+  }
+  try {
+    return await fn()
+  } finally {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(wasRaw ?? false)
+      process.stdin.pause()
+    }
+  }
+}