nastech-tui 0.0.1

package/packages/nastech-ink/src/ink/supports-hyperlinks.ts

@@ -0,0 +1,51 @@
+import supportsHyperlinksLib from '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).
+export const ADDITIONAL_HYPERLINK_TERMINALS = ['ghostty', 'Hyper', 'kitty', 'alacritty', 'iTerm.app', 'iTerm2']
+
+type EnvLike = Record<string, string | undefined>
+
+type SupportsHyperlinksOptions = {
+  env?: EnvLike
+  stdoutSupported?: boolean
+}
+
+/**
+ * Returns whether stdout supports OSC 8 hyperlinks.
+ * Extends the supports-hyperlinks library with additional terminal detection.
+ * @param options Optional overrides for testing (env, stdoutSupported)
+ */
+export function supportsHyperlinks(options?: SupportsHyperlinksOptions): boolean {
+  const stdoutSupported = options?.stdoutSupported ?? supportsHyperlinksLib.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 && 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 && ADDITIONAL_HYPERLINK_TERMINALS.includes(lcTerminal)) {
+    return true
+  }
+
+  // Kitty sets TERM=xterm-kitty
+  const term = env['TERM']
+
+  if (term?.includes('kitty')) {
+    return true
+  }
+
+  return false
+}

package/packages/nastech-ink/src/ink/tabstops.ts

@@ -0,0 +1,44 @@
+// Tab expansion, inspired by Ghostty's Tabstops.zig
+// Uses 8-column intervals (POSIX default, hardcoded in terminals like Ghostty)
+
+import { stringWidth } from './stringWidth.js'
+import { createTokenizer } from './termio/tokenize.js'
+
+const DEFAULT_TAB_INTERVAL = 8
+
+export function expandTabs(text: string, interval = DEFAULT_TAB_INTERVAL): string {
+  if (!text.includes('\t')) {
+    return text
+  }
+
+  const tokenizer = 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 += stringWidth(part)
+        }
+      }
+    }
+  }
+
+  return result
+}

package/packages/nastech-ink/src/ink/terminal-focus-state.ts

@@ -0,0 +1,52 @@
+// Terminal focus state signal — non-React access to DECSET 1004 focus events.
+// 'unknown' is the default for terminals that don't support focus reporting;
+// consumers treat 'unknown' identically to 'focused' (no throttling).
+// Subscribers are notified synchronously when focus changes, used by
+// TerminalFocusProvider to avoid polling.
+export type TerminalFocusState = 'focused' | 'blurred' | 'unknown'
+
+let focusState: TerminalFocusState = 'unknown'
+const resolvers: Set<() => void> = new Set()
+const subscribers: Set<() => void> = new Set()
+
+export function setTerminalFocused(v: boolean): void {
+  focusState = v ? 'focused' : 'blurred'
+
+  // Notify useSyncExternalStore subscribers
+  for (const cb of subscribers) {
+    cb()
+  }
+
+  if (!v) {
+    for (const resolve of resolvers) {
+      resolve()
+    }
+
+    resolvers.clear()
+  }
+}
+
+export function getTerminalFocused(): boolean {
+  return focusState !== 'blurred'
+}
+
+export function getTerminalFocusState(): TerminalFocusState {
+  return focusState
+}
+
+// For useSyncExternalStore
+export function subscribeTerminalFocus(cb: () => void): () => void {
+  subscribers.add(cb)
+
+  return () => {
+    subscribers.delete(cb)
+  }
+}
+
+export function resetTerminalFocusState(): void {
+  focusState = 'unknown'
+
+  for (const cb of subscribers) {
+    cb()
+  }
+}

package/packages/nastech-ink/src/ink/terminal-querier.ts

@@ -0,0 +1,222 @@
+/**
+ * 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'
+import { csi } from './termio/csi.js'
+import { osc } from './termio/osc.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' }>
+
+// -- Query builders --
+
+/** DECRQM: request DEC private mode status (CSI ? mode $ p).
+ *  Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores. */
+export function decrqm(mode: number): TerminalQuery<DecrpmResponse> {
+  return {
+    request: csi(`?${mode}$p`),
+    match: (r): r is DecrpmResponse => 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. */
+export function da1(): TerminalQuery<Da1Response> {
+  return {
+    request: csi('c'),
+    match: (r): r is Da1Response => r.type === 'da1'
+  }
+}
+
+/** Secondary Device Attributes query (CSI > c). Returns terminal version. */
+export function da2(): TerminalQuery<Da2Response> {
+  return {
+    request: csi('>c'),
+    match: (r): r is Da2Response => r.type === 'da2'
+  }
+}
+
+/** Query current Kitty keyboard protocol flags (CSI ? u).
+ *  Terminal replies with CSI ? flags u or ignores. */
+export function kittyKeyboard(): TerminalQuery<KittyResponse> {
+  return {
+    request: csi('?u'),
+    match: (r): r is KittyResponse => 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.). */
+export function cursorPosition(): TerminalQuery<CursorPosResponse> {
+  return {
+    request: csi('?6n'),
+    match: (r): r is CursorPosResponse => 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. */
+export function oscColor(code: number): TerminalQuery<OscResponse> {
+  return {
+    request: osc(code, '?'),
+    match: (r): r is OscResponse => 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. */
+export function xtversion(): TerminalQuery<XtversionResponse> {
+  return {
+    request: csi('>0q'),
+    match: (r): r is XtversionResponse => r.type === 'xtversion'
+  }
+}
+
+// -- Querier --
+
+/** Sentinel request sequence (DA1). Kept internal; flush() writes it. */
+const SENTINEL = csi('c')
+
+type Pending =
+  | {
+      kind: 'query'
+      match: (r: TerminalResponse) => boolean
+      resolve: (r: TerminalResponse | undefined) => void
+    }
+  | { kind: 'sentinel'; resolve: () => void }
+
+export class TerminalQuerier {
+  /**
+   * 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: Pending[] = []
+
+  constructor(private 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> {
+    return new Promise(resolve => {
+      this.queue.push({
+        kind: 'query',
+        match: query.match,
+        resolve: r => resolve(r as T | undefined)
+      })
+      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(): Promise<void> {
+    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: TerminalResponse): void {
+    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()
+        }
+      }
+    }
+  }
+}

package/packages/nastech-ink/src/ink/terminal.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+
+import { needsAltScreenResizeScrollbackClear } from './terminal.js'
+
+describe('terminal resize quirks', () => {
+  it('uses a deeper alt-screen resize clear for Apple Terminal', () => {
+    expect(needsAltScreenResizeScrollbackClear({ TERM_PROGRAM: 'Apple_Terminal' })).toBe(true)
+    expect(needsAltScreenResizeScrollbackClear({ TERM_PROGRAM: ' Apple_Terminal ' })).toBe(true)
+  })
+
+  it('keeps the normal resize repaint path for modern terminals', () => {
+    expect(needsAltScreenResizeScrollbackClear({ TERM_PROGRAM: 'vscode' })).toBe(false)
+    expect(needsAltScreenResizeScrollbackClear({ TERM_PROGRAM: 'iTerm.app' })).toBe(false)
+  })
+})

package/packages/nastech-ink/src/ink/terminal.ts

@@ -0,0 +1,299 @@
+import type { Writable } from 'stream'
+
+import { coerce } from 'semver'
+
+import { env } from '../utils/env.js'
+import { gte } from '../utils/semver.js'
+
+import { getClearTerminalSequence } from './clearTerminal.js'
+import type { Diff } from './frame.js'
+import { cursorMove, cursorTo, eraseLines } from './termio/csi.js'
+import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js'
+import { link } from './termio/osc.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 function isProgressReportingAvailable(): boolean {
+  // Only available if we have a TTY (not piped)
+  if (!process.stdout.isTTY) {
+    return false
+  }
+
+  // Explicitly exclude Windows Terminal, which interprets OSC 9;4 as
+  // notifications rather than progress indicators
+  if (process.env.WT_SESSION) {
+    return false
+  }
+
+  // ConEmu supports OSC 9;4 for progress (all versions)
+  if (process.env.ConEmuANSI || process.env.ConEmuPID || process.env.ConEmuTask) {
+    return true
+  }
+
+  const version = coerce(process.env.TERM_PROGRAM_VERSION)
+
+  if (!version) {
+    return false
+  }
+
+  // Ghostty 1.2.0+ supports OSC 9;4 for progress
+  // https://ghostty.org/docs/install/release-notes/1-2-0
+  if (process.env.TERM_PROGRAM === 'ghostty') {
+    return gte(version.version, '1.2.0')
+  }
+
+  // iTerm2 3.6.6+ supports OSC 9;4 for progress
+  // https://iterm2.com/downloads.html
+  if (process.env.TERM_PROGRAM === 'iTerm.app') {
+    return gte(version.version, '3.6.6')
+  }
+
+  return false
+}
+
+/**
+ * Checks if the terminal supports DEC mode 2026 (synchronized output).
+ * When supported, BSU/ESU sequences prevent visible flicker during redraws.
+ */
+export function isSynchronizedOutputSupported(): boolean {
+  // tmux parses and proxies every byte but doesn't implement DEC 2026.
+  // BSU/ESU pass through to the outer terminal but tmux has already
+  // broken atomicity by chunking. Skip to save 16 bytes/frame + parser work.
+  if (process.env.TMUX) {
+    return false
+  }
+
+  const termProgram = process.env.TERM_PROGRAM
+  const term = process.env.TERM
+
+  // Modern terminals with known DEC 2026 support
+  if (
+    termProgram === 'iTerm.app' ||
+    termProgram === 'WezTerm' ||
+    termProgram === 'WarpTerminal' ||
+    termProgram === 'ghostty' ||
+    termProgram === 'contour' ||
+    termProgram === 'vscode' ||
+    termProgram === 'alacritty'
+  ) {
+    return true
+  }
+
+  // kitty sets TERM=xterm-kitty or KITTY_WINDOW_ID
+  if (term?.includes('kitty') || process.env.KITTY_WINDOW_ID) {
+    return true
+  }
+
+  // Ghostty may set TERM=xterm-ghostty without TERM_PROGRAM
+  if (term === 'xterm-ghostty') {
+    return true
+  }
+
+  // foot sets TERM=foot or TERM=foot-extra
+  if (term?.startsWith('foot')) {
+    return true
+  }
+
+  // Alacritty may set TERM containing 'alacritty'
+  if (term?.includes('alacritty')) {
+    return true
+  }
+
+  // Zed uses the alacritty_terminal crate which supports DEC 2026
+  if (process.env.ZED_TERM) {
+    return true
+  }
+
+  // Windows Terminal
+  if (process.env.WT_SESSION) {
+    return true
+  }
+
+  // VTE-based terminals (GNOME Terminal, Tilix, etc.) since VTE 0.68
+  const vteVersion = process.env.VTE_VERSION
+
+  if (vteVersion) {
+    const version = parseInt(vteVersion, 10)
+
+    if (version >= 6800) {
+      return true
+    }
+  }
+
+  return false
+}
+
+// -- XTVERSION-detected terminal name (populated async at startup) --
+//
+// TERM_PROGRAM is not forwarded over SSH by default, so env-based detection
+// fails when the process runs remotely inside a VS Code integrated terminal.
+// XTVERSION (CSI > 0 q → DCS > | name ST) goes through the pty — the query
+// reaches the *client* terminal and the reply comes back through stdin.
+// App.tsx fires the query when raw mode enables; setXtversionName() is called
+// from the response handler. Readers should treat undefined as "not yet known"
+// and fall back to env-var detection.
+
+let xtversionName: string | undefined
+
+/** 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 function setXtversionName(name: string): void {
+  if (xtversionName === undefined) {
+    xtversionName = name
+  }
+}
+
+/** 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 function isXtermJs(): boolean {
+  if (process.env.TERM_PROGRAM === 'vscode') {
+    return true
+  }
+
+  return xtversionName?.startsWith('xterm.js') ?? false
+}
+
+export function needsAltScreenResizeScrollbackClear(env: NodeJS.ProcessEnv = process.env): boolean {
+  return (env.TERM_PROGRAM ?? '').trim() === 'Apple_Terminal'
+}
+
+// Terminals known to correctly implement the Kitty keyboard protocol
+// (CSI >1u) and/or xterm modifyOtherKeys (CSI >4;2m) for ctrl+shift+<letter>
+// disambiguation. We previously enabled unconditionally (#23350), assuming
+// terminals silently ignore unknown CSI — but some terminals honor the enable
+// and emit codepoints our input parser doesn't handle (notably over SSH and
+// in xterm.js-based terminals like VS Code). tmux is allowlisted because it
+// accepts modifyOtherKeys and doesn't forward the kitty sequence to the outer
+// terminal.
+const EXTENDED_KEYS_TERMINALS = ['iTerm.app', 'kitty', 'WezTerm', 'ghostty', 'tmux', 'windows-terminal', 'vscode']
+
+/** True if this terminal correctly handles extended key reporting
+ *  (Kitty keyboard protocol + xterm modifyOtherKeys). */
+export function supportsExtendedKeys(): boolean {
+  return EXTENDED_KEYS_TERMINALS.includes(env.terminal ?? '')
+}
+
+/** 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 function hasCursorUpViewportYankBug(): boolean {
+  return process.platform === 'win32' || !!process.env.WT_SESSION
+}
+
+// Computed once at module load — terminal capabilities don't change mid-session.
+// Exported so callers can pass a sync-skip hint gated to specific modes.
+export const SYNC_OUTPUT_SUPPORTED = isSynchronizedOutputSupported()
+
+export type Terminal = {
+  stdout: Writable
+  stderr: Writable
+}
+
+export function writeDiffToTerminal(
+  terminal: Terminal,
+  diff: Diff,
+  skipSyncMarkers = false,
+  onDrain?: () => void
+): { bytes: number; backpressure: boolean } {
+  // No output if there are no patches
+  if (diff.length === 0) {
+    return { bytes: 0, backpressure: false }
+  }
+
+  // BSU/ESU wrapping is opt-out to keep main-screen behavior unchanged.
+  // Callers pass skipSyncMarkers=true when the terminal doesn't support
+  // DEC 2026 (e.g. tmux) AND the cost matters (high-frequency alt-screen).
+  const useSync = !skipSyncMarkers
+
+  // Buffer all writes into a single string to avoid multiple write calls
+  let buffer = useSync ? BSU : ''
+
+  for (const patch of diff) {
+    switch (patch.type) {
+      case 'stdout':
+        buffer += patch.content
+
+        break
+
+      case 'clear':
+        if (patch.count > 0) {
+          buffer += eraseLines(patch.count)
+        }
+
+        break
+
+      case 'clearTerminal':
+        buffer += getClearTerminalSequence()
+
+        break
+
+      case 'cursorHide':
+        buffer += HIDE_CURSOR
+
+        break
+
+      case 'cursorShow':
+        buffer += SHOW_CURSOR
+
+        break
+
+      case 'cursorMove':
+        buffer += cursorMove(patch.x, patch.y)
+
+        break
+
+      case 'cursorTo':
+        buffer += cursorTo(patch.col)
+
+        break
+
+      case 'carriageReturn':
+        buffer += '\r'
+
+        break
+
+      case 'hyperlink':
+        buffer += link(patch.uri)
+
+        break
+
+      case 'styleStr':
+        buffer += patch.str
+
+        break
+    }
+  }
+
+  // Add synchronized update end and flush buffer
+  if (useSync) {
+    buffer += ESU
+  }
+
+  // Node's Writable.write returns false when the internal buffer is full
+  // (backpressure). On a slow terminal parser that's the tell: we're
+  // producing bytes faster than the outer terminal can consume them.
+  // The 2-arg form attaches a drain callback that fires once the chunk
+  // is actually flushed to the OS socket/pipe — giving us end-to-end
+  // drain timing, not just "queued in Node".
+  const wrote = onDrain ? terminal.stdout.write(buffer, () => onDrain()) : terminal.stdout.write(buffer)
+
+  return { bytes: Buffer.byteLength(buffer, 'utf8'), backpressure: !wrote }
+}