zames_pro 2.73.11 → 2.75.0

package/scripts/qwen-models-smoke.mts

@@ -0,0 +1,117 @@
+// Qwen model-switching self-smoke: launch a REAL isolated QwenBrowser, list
+// the model catalogue, then SWITCH to several models and ask a question with
+// each — the operator explicitly asked that model switching be exercised.
+//
+// Isolation mirrors qwen-smoke.mts: a throwaway HOME + a read-only COPY of the
+// real qwen-profile (the live profile is never opened).
+//
+// Usage: npx tsx scripts/qwen-models-smoke.mts [--headed] [--all]
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+const HEADED = process.argv.includes('--headed')
+const ALL = process.argv.includes('--all')
+const REAL_HOME = os.homedir()
+const PROFILE_SRC = path.join(REAL_HOME, '.zames', 'qwen-profile')
+
+if (!process.env.ZAMES_QWEN_MODELS_HOME) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'zames-qwen-models-'))
+  process.env.HOME = tmp
+  process.env.ZAMES_QWEN_MODELS_HOME = tmp
+  fs.mkdirSync(path.join(tmp, '.zames'), { recursive: true })
+  fs.mkdirSync(path.join(tmp, '.cache'), { recursive: true })
+  const realCfg = path.join(REAL_HOME, '.zames', 'config.json')
+  if (fs.existsSync(realCfg)) {
+    fs.copyFileSync(realCfg, path.join(tmp, '.zames', 'config.json'))
+  }
+  const realPw = path.join(REAL_HOME, '.cache', 'ms-playwright')
+  if (fs.existsSync(realPw)) {
+    fs.symlinkSync(realPw, path.join(tmp, '.cache', 'ms-playwright'))
+  }
+  if (fs.existsSync(PROFILE_SRC)) {
+    fs.cpSync(PROFILE_SRC, path.join(tmp, '.zames', 'qwen-profile'), {
+      recursive: true,
+      filter: (src) => !/^Singleton/.test(path.basename(src)),
+    })
+  }
+}
+
+const { QwenBrowser } = await import('../src/qwen-browser.ts')
+const { loadConfig } = await import('../src/config.ts')
+const cfg = loadConfig()
+
+const results: Array<{ name: string; ok: boolean; note?: string }> = []
+const record = (name: string, ok: boolean, note?: string): void => {
+  results.push({ name, ok, note })
+  console.log((ok ? 'PASS ' : 'FAIL ') + name + (note ? '  — ' + note : ''))
+}
+
+const browser = new QwenBrowser({
+  headless: !HEADED,
+  debug: false,
+  channel: cfg.browserChannel,
+  auth: cfg.browser.auth,
+  locale: 'ru',
+  minSendIntervalMs: 0,
+  answerTimeoutMs: 180000,
+  webSearch: false,
+  deepThinking: false,
+})
+browser.onNotice = (t: string) => console.log('  [notice] ' + t)
+
+async function main(): Promise<void> {
+  await browser.launch()
+  const timedOut = await Promise.race([
+    browser.waitForLogin().then(() => false),
+    new Promise<boolean>((r) => setTimeout(() => r(true), 60000)),
+  ])
+  if (timedOut) {
+    record('login', false, 'timed out')
+    await browser.close().catch(() => {})
+    process.exit(2)
+  }
+  record('login', true)
+
+  const models = await browser.listModels()
+  record(
+    'listModels',
+    models.length > 0,
+    'n=' + models.length + ' ' + models.map((m) => m.id).join(','),
+  )
+
+  // Switch through a few models and ask with each. Prefer distinct vendors so
+  // the dropdown selection really changes the backend.
+  const wanted = ALL ? models : models.slice(0, 3)
+  for (const m of wanted) {
+    try {
+      await browser.newChat()
+      browser.model = m.id
+      const ans = await browser.ask('Reply with exactly: OK', { agent: true })
+      const ok = /OK/i.test(ans)
+      record('model:' + m.id, ok, ok ? '' : 'got: ' + ans.slice(0, 60))
+    } catch (e) {
+      record('model:' + m.id, false, (e as Error).message)
+    }
+  }
+
+  await browser.close().catch(() => {})
+  const failed = results.filter((r) => !r.ok)
+  console.log(
+    '\nqwen-models-smoke: ' +
+      (results.length - failed.length) +
+      '/' +
+      results.length +
+      ' passed',
+  )
+  if (!process.env.ZAMES_QWEN_MODELS_KEEP) {
+    fs.rmSync(process.env.ZAMES_QWEN_MODELS_HOME as string, {
+      recursive: true,
+      force: true,
+    })
+  }
+  process.exit(failed.length ? 1 : 0)
+}
+
+void main()

package/scripts/render-demo.mts

@@ -21,7 +21,7 @@ const out = path.join(root, 'docs', 'demo.png')
 
 const C = {
   bg: '#23272e',
-  user: '#b4b8d0',
+  user: '#8fd4f0',
   prompt: '#c8b06a',
   dir: '#7fc4f0',
   assistant: '#cfc9b0',

package/scripts/tui-comp-shot.mts

@@ -0,0 +1,63 @@
+// Screenshot a standalone TUI component under a pty, optionally driving keys.
+// Usage: npx tsx scripts/tui-comp-shot.mts --component=select --keys=j,j --cols=80 --rows=24
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+
+const ESC = String.fromCharCode(27)
+const NL = String.fromCharCode(10)
+function arg(name: string, def = ''): string {
+  const hit = process.argv.find((a) => a.startsWith('--' + name + '='))
+  return hit ? hit.slice(name.length + 3) : def
+}
+const component = arg('component', 'select')
+const cols = Number(arg('cols', '80'))
+const rows = Number(arg('rows', '24'))
+const keys = arg('keys', '')
+  .split(',')
+  .filter((s) => s.length > 0)
+  .map((s) =>
+    s === 'UP'
+      ? ESC + '[A'
+      : s === 'DOWN'
+        ? ESC + '[B'
+        : s === 'TAB'
+          ? String.fromCharCode(9)
+          : s === 'ENTER'
+            ? String.fromCharCode(13)
+            : s === 'ESC'
+              ? ESC
+              : s,
+  )
+
+const term = new Term(rows, cols)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-components.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: String(cols),
+      LINES: String(rows),
+      PROBE_COMPONENT: component,
+    },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 250)
+  } else {
+    setTimeout(() => {
+      process.stdout.write(term.render() + NL)
+      child.kill('SIGTERM')
+    }, 400)
+  }
+}
+setTimeout(tick, 4500)
+child.on('close', () => process.exit(0))

package/scripts/tui-components.tsx

@@ -0,0 +1,62 @@
+// Mount EACH standalone TUI component (SelectList, ConfirmDialog, LoginForm,
+// TextPrompt) under a pty so every menu can be screenshotted and driven.
+// Pick the component with PROBE_COMPONENT.
+
+import React from 'react'
+import { render } from 'ink'
+import { SelectList } from '../src/tui/SelectList.js'
+import { ConfirmDialog } from '../src/tui/ConfirmDialog.js'
+import { LoginForm } from '../src/tui/LoginForm.js'
+import { TextPrompt } from '../src/tui/TextPrompt.js'
+import { translate } from '../src/i18n.js'
+
+const which = process.env.PROBE_COMPONENT || 'select'
+const t = translate('ru')
+
+function node(): React.ReactElement {
+  switch (which) {
+    case 'select':
+      return React.createElement(SelectList, {
+        title: 'Модель Qwen',
+        initial: 'qwen3.7-plus',
+        items: [
+          { value: 'qwen3.7-plus', label: 'qwen3.7-plus', detail: '← текущая' },
+          { value: 'qwen3.8-max', label: 'qwen3.8-max' },
+          {
+            value: 'qwen3.8-omni-flash',
+            label: 'qwen3.8-omni-flash',
+            description: 'быстрая',
+          },
+          { value: 'qwen3.7-max', label: 'qwen3.7-max' },
+          { value: 'qwen3.6-plus', label: 'qwen3.6-plus' },
+        ],
+        onSelect: () => {},
+      })
+    case 'confirm':
+      return React.createElement(ConfirmDialog, {
+        title: 'Подтверждение',
+        message: 'Выполнить Bash: rm -rf build ?',
+        yesLabel: 'Да',
+        noLabel: 'Нет',
+        onAnswer: () => {},
+      })
+    case 'login':
+      return React.createElement(LoginForm, { t, onResult: () => {} })
+    case 'text':
+      return React.createElement(TextPrompt, {
+        t,
+        label: 'Одноразовый код',
+        secret: false,
+        onResult: () => {},
+      })
+    default:
+      return React.createElement(SelectList, {
+        title: 'x',
+        items: [],
+        onSelect: () => {},
+      })
+  }
+}
+
+render(node(), { exitOnCtrlC: false, patchConsole: false })
+setInterval(() => {}, 1 << 30)

package/scripts/tui-config-driver.mts

@@ -0,0 +1,82 @@
+// Drive scripts/tui-config-probe.tsx under a pty: send keys one at a time,
+// screenshot the VT100 grid at the end, and print the probe's set/reset log.
+// Used by test/tui-pty-render.test.ts to pin the config-menu regressions
+// (the stale value after a toggle, and the overflowing block at a small
+// terminal).
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+
+const ESC = String.fromCharCode(27)
+const NL = String.fromCharCode(10)
+
+function arg(name: string, def = ''): string {
+  const hit = process.argv.find((a) => a.startsWith('--' + name + '='))
+  return hit ? hit.slice(name.length + 3) : def
+}
+const cols = Number(arg('cols', '90'))
+const rows = Number(arg('rows', '30'))
+const keys = arg('keys', '')
+  .split(',')
+  .filter((s) => s.length > 0)
+  .map((s) =>
+    s === 'RIGHT'
+      ? ESC + '[C'
+      : s === 'LEFT'
+        ? ESC + '[D'
+        : s === 'DOWN'
+          ? ESC + '[B'
+          : s === 'UP'
+            ? ESC + '[A'
+            : s === 'ENTER'
+              ? String.fromCharCode(13)
+              : s,
+  )
+
+const LOG = '/tmp/config-probe.log'
+try {
+  fs.unlinkSync(LOG)
+} catch {
+  /* ignore */
+}
+
+const term = new Term(rows, cols)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-config-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: String(cols),
+      LINES: String(rows),
+      PROBE_CONFIG_LOG: LOG,
+    },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 220)
+  } else {
+    setTimeout(() => {
+      process.stdout.write('===SCREEN===' + NL)
+      process.stdout.write(term.render() + NL)
+      process.stdout.write('===LOG===' + NL)
+      try {
+        process.stdout.write(fs.readFileSync(LOG, 'utf-8'))
+      } catch {
+        /* ignore */
+      }
+      child.kill('SIGTERM')
+    }, 500)
+  }
+}
+setTimeout(tick, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-config-probe.tsx

@@ -0,0 +1,74 @@
+// Mount the REAL Ink config menu with the REAL schema and callbacks so a pty
+// run can screenshot it and drive it (toggle a boolean, cycle an enum, open an
+// edit prompt) — the menu is otherwise only reachable from a live agent.
+
+import React from 'react'
+import fs from 'node:fs'
+import { render } from 'ink'
+import { ConfigMenuApp } from '../src/tui/ConfigMenu.js'
+import {
+  CONFIG_SCHEMA,
+  DEFAULTS,
+  validateConfigValue,
+  type ConfigField,
+} from '../src/config.js'
+import { translate } from '../src/i18n.js'
+
+const LOG = process.env.PROBE_CONFIG_LOG || '/tmp/config-probe.log'
+// A tiny in-memory config so get/set/reset are real (validate + default).
+function getByPath(obj: Record<string, unknown>, path: string): unknown {
+  return path
+    .split('.')
+    .reduce<unknown>(
+      (o, k) => (o == null ? undefined : (o as Record<string, unknown>)[k]),
+      obj,
+    )
+}
+function setByPath(path: string, value: unknown): void {
+  const parts = path.split('.')
+  let o: Record<string, unknown> = cfg
+  for (let i = 0; i < parts.length - 1; i++) {
+    o[parts[i]] = o[parts[i]] ?? {}
+    o = o[parts[i]] as Record<string, unknown>
+  }
+  o[parts[parts.length - 1]] = value
+}
+const cfg: Record<string, unknown> = {}
+// Seed a few NESTED values so toggling is observable (the menu reads through
+// getByPath, which walks the path — a flat key would never be found).
+setByPath('ui.locale', 'ru')
+setByPath('ui.tui', true)
+setByPath('ui.alternateScreen', true)
+setByPath('ui.mouseScroll', false)
+setByPath('maxIterations', 0)
+setByPath('headless', true)
+setByPath('provider', 'deepseek')
+
+const log = (line: string): void => {
+  fs.appendFileSync(LOG, line + String.fromCharCode(10))
+}
+
+render(
+  React.createElement(ConfigMenuApp, {
+    fields: CONFIG_SCHEMA,
+    t: translate('ru'),
+    get: (p: string) => getByPath(cfg, p),
+    getDefault: (p: string) =>
+      getByPath(DEFAULTS as unknown as Record<string, unknown>, p),
+    set: (field: ConfigField, raw: string) => {
+      const v = validateConfigValue(field, raw)
+      setByPath(field.path, v)
+      log('SET ' + field.path + '=' + JSON.stringify(v))
+    },
+    reset: (field: ConfigField) => {
+      setByPath(
+        field.path,
+        getByPath(DEFAULTS as unknown as Record<string, unknown>, field.path),
+      )
+      log('RESET ' + field.path)
+    },
+    onExit: () => log('EXIT'),
+  }),
+  { exitOnCtrlC: false, patchConsole: false },
+)
+setInterval(() => {}, 1 << 30)

package/scripts/tui-edit-driver.mts

@@ -0,0 +1,100 @@
+// Drive scripts/tui-edit-probe.tsx under a pty with a scripted key sequence,
+// then print the LAST buffer state the probe logged.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ESC = String.fromCharCode(27)
+const LOG = '/tmp/edit-probe.log'
+
+function arg(name: string, def = ''): string {
+  const hit = process.argv.find((a) => a.startsWith('--' + name + '='))
+  return hit ? hit.slice(name.length + 3) : def
+}
+const seed = arg('seed', '')
+const keys = arg('keys', '')
+  .split(',')
+  .filter((s) => s.length > 0)
+  .map((s) =>
+    s === 'CTDL'
+      ? ESC + '[3;5~'
+      : s === 'CTDLU'
+        ? ESC + '[3;5u'
+        : s === 'CTB127U'
+          ? ESC + '[127;5u'
+          : s === 'DELU'
+            ? ESC + '[3u'
+            : s === 'BSU'
+              ? ESC + '[127u'
+              : s === 'CTRLBS'
+                ? ESC + String.fromCharCode(127)
+                : s === 'CTB08'
+                  ? String.fromCharCode(8)
+                  : s === 'DEL'
+                    ? ESC + '[3~'
+                    : s === 'CTRLUNDO'
+                      ? String.fromCharCode(31)
+                      : s === 'CTRLU'
+                        ? String.fromCharCode(21)
+                        : s === 'CTRLK'
+                          ? String.fromCharCode(11)
+                          : s === 'CTRLR'
+                            ? String.fromCharCode(18)
+                            : s === 'ESCAPE'
+                              ? ESC
+                              : s === 'CTRLW'
+                                ? String.fromCharCode(23)
+                                : s === 'LEFT'
+                                  ? ESC + '[D'
+                                  : s === 'RIGHT'
+                                    ? ESC + '[C'
+                                    : s === 'UP'
+                                      ? ESC + '[A'
+                                      : s === 'DOWN'
+                                        ? ESC + '[B'
+                                        : s === 'ENTER'
+                                          ? String.fromCharCode(13)
+                                          : s,
+  )
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-edit-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: '80',
+      LINES: '24',
+      PROBE_EDIT_LOG: LOG,
+      PROBE_EDIT_SEED: seed,
+    },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 200)
+  } else {
+    setTimeout(() => child.kill('SIGTERM'), 300)
+  }
+}
+setTimeout(tick, 5000)
+child.on('close', () => {
+  let lines: string[] = []
+  try {
+    lines = fs.readFileSync(LOG, 'utf-8').trim().split(String.fromCharCode(10))
+  } catch {
+    /* ignore */
+  }
+  console.log(
+    'SEED=' + JSON.stringify(seed) + ' KEYS=' + JSON.stringify(arg('keys', '')),
+  )
+  console.log('FINAL=' + (lines[lines.length - 1] || '(none)'))
+  process.exit(0)
+})

package/scripts/tui-edit-probe.tsx

@@ -0,0 +1,38 @@
+// Mount the REAL TuiEditor and log the editor BUFFER after every change, so a
+// pty driver can send keys and assert what the buffer became (word deletion,
+// newlines, history) instead of guessing from bytes. The log is one JSON line
+// per change: {buf, cursor}.
+
+import fs from 'node:fs'
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+
+const LOG = process.env.PROBE_EDIT_LOG || '/tmp/edit-probe.log'
+const SEED = process.env.PROBE_EDIT_SEED || ''
+fs.writeFileSync(LOG, '')
+
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: process.env.PROBE_INLINE !== '1',
+})
+ed.onSubmit = () => {}
+ed.onAttach = () => null
+ed.onClipboard = () => Promise.resolve(null)
+
+ed.store.subscribe(() => {
+  const s = ed.store.getSnapshot().edit
+  fs.appendFileSync(
+    LOG,
+    JSON.stringify({ buf: s.buf, cursor: s.cursor }) + String.fromCharCode(10),
+  )
+})
+
+ed.start()
+if (SEED) {
+  // Type the seed through the store so the buffer starts non-empty.
+  ed.store.update((snap) => ({
+    edit: { ...snap.edit, buf: SEED, cursor: Array.from(SEED).length },
+  }))
+}
+setInterval(() => {}, 1 << 30)

package/scripts/tui-editor-probe.tsx

@@ -0,0 +1,24 @@
+// Mount the REAL TuiEditor (the adapter index.ts uses), so the pty resize test
+// exercises TuiEditor.installResizeHandler (unmount+remount), NOT just Ink's
+// built-in erase. The raw FullScreenApp probe bypasses that handler.
+
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+
+const ed = new TuiEditor({
+  prompt: '\u2794 zames_pro \u203a ',
+  commands: [
+    { name: '/help', description: 'show help' },
+    { name: '/new', description: 'new chat' },
+  ],
+  locale: 'en',
+  alternateScreen: true,
+})
+ed.setHeader?.({
+  title: 'zames_pro',
+  version: '2.74.0',
+  workdir: '/workspaces/zames/zames_pro',
+})
+ed.start()
+ed.printAbove('log line one')
+ed.printAbove('log line two')
+setInterval(() => {}, 1 << 30)

package/scripts/tui-input-driver.mts

@@ -0,0 +1,54 @@
+// Screenshot the REAL FullScreenApp input box for a given buffer/cursor, and
+// print the VT100 grid WITH a cursor marker (the real terminal cursor cell).
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+
+const NL = String.fromCharCode(10)
+function arg(name: string, def = ''): string {
+  const hit = process.argv.find((a) => a.startsWith('--' + name + '='))
+  return hit ? hit.slice(name.length + 3) : def
+}
+const cols = Number(arg('cols', '80'))
+const rows = Number(arg('rows', '24'))
+const buf = arg('buf', '')
+  .replace(/\\n/g, NL)
+  .replace(/\\t/g, String.fromCharCode(9))
+const cursor = arg('cursor', '')
+
+const term = new Term(rows, cols)
+let stderr = ''
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-input-shot.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: String(cols),
+      LINES: String(rows),
+      PROBE_BUF: buf,
+      ...(cursor ? { PROBE_CURSOR: cursor } : {}),
+    },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => (stderr += d.toString('utf-8')))
+setTimeout(() => {
+  const cr = term.r
+  const cc = term.c
+  // Mark by GRID CELL, not by string index: a wide char occupies two grid
+  // cells, so slicing the rendered string would place the marker wrong.
+  const grid = term.grid
+  if (grid[cr] && grid[cr][cc] !== undefined)
+    grid[cr][cc] = String.fromCharCode(9673)
+  const lines = grid.map((row) => row.join('').replace(/\s+$/, ''))
+  process.stdout.write(
+    lines.map((l, n) => String(n).padStart(2) + '| ' + l).join(NL) + NL,
+  )
+  process.stdout.write('CURSOR row=' + cr + ' col=' + cc + NL)
+  const lay = stderr.split(NL).find((l) => l.startsWith('LAYOUT'))
+  if (lay) process.stdout.write(lay + NL)
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-input-shot.tsx

@@ -0,0 +1,59 @@
+// Mount the REAL FullScreenApp with a buffer set from env, so the input box
+// rendering (wrapping, cursor, CJK width, paste markers) can be screenshotted.
+import React from 'react'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { FullScreenApp } from '../src/tui/FullScreenApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+import { layoutInput, inputInnerCols } from '../src/input/layout.js'
+
+const buf = process.env.PROBE_BUF || ''
+const cursor = process.env.PROBE_CURSOR
+  ? Number(process.env.PROBE_CURSOR)
+  : buf.length
+const store = new TuiStore()
+store.set({
+  title: 'zames',
+  version: '2.74',
+  workdir: '/workspaces/zames/zames_pro',
+  prompt: '\u2794 zames \u203a ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf, cursor },
+})
+store.pushLog('system', 'log line one')
+const inputProps = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+// Print the expected layout to stderr so it can be compared with the screen.
+const cols = Number(process.env.COLUMNS || 80)
+const lay = layoutInput(
+  '\u2794 zames \u203a ',
+  buf,
+  cursor,
+  inputInnerCols(cols),
+)
+process.stderr.write(
+  'LAYOUT rows=' +
+    lay.rows.length +
+    ' cursorRow=' +
+    lay.cursorRow +
+    ' cursorCol=' +
+    lay.cursorCol +
+    String.fromCharCode(10),
+)
+render(React.createElement(FullScreenApp, { store, inputProps }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+  alternateScreen: true,
+})
+setInterval(() => {}, 1 << 30)