@raidiant/notifai 0.2.0 → 0.3.0

package/src/main.ts

@@ -9,6 +9,7 @@ import {
   authStatusCommand,
   capabilitiesCommand,
   closeCommand,
+  configExplainCommand,
   configSetCommand,
   configShowCommand,
   devicesCommand,
@@ -29,6 +30,7 @@ import { defaultCredentialStore } from './credentials.js'
 import { HARNESSES } from './install-hooks.js'
 import type { Platform } from '@raidiant/notifai-protocol'
 import { nativeSkills, type SkillScope } from './native-skills.js'
+import { GROUP, SEND_GROUP, helpConfiguration, rootHelpFooter } from './ui/help.js'
 
 const deps: CommandDeps = {
   io: realIo(),
@@ -92,10 +94,51 @@ function version(): string {
 const program = new Command('notifai')
   .description('Send native device notifications from agents and local programs')
   .version(version())
+  .configureHelp(helpConfiguration)
+  // Lazy on purpose. `addHelpText` also takes a string, but that builds the
+  // footer on every invocation — including the hook that runs in front of
+  // every prompt the user types, which never renders help at all.
+  .addHelpText('after', () => rootHelpFooter())
+  // Commander's default is to print the full help and exit 0 for an unknown
+  // `help` topic, so `notifai help nonsense` looked like it had worked. A
+  // reader who mistyped a command deserves to be told, and a script deserves
+  // a nonzero code.
+  .showSuggestionAfterError(true)
+  // Commander drops the implicit `help [command]` as soon as the program
+  // itself has an action handler — which the interactive default below gives
+  // it. Without this, adding that default would silently break
+  // `notifai help send` for everyone who reaches for it before `--help`.
+  .helpCommand(true)
+  // Where the implicit help command lands; every other command names its own.
+  .commandsGroup(GROUP.help)
+
+/**
+ * Bare `notifai`.
+ *
+ * At a human terminal this opens the interactive app; anywhere else it prints
+ * help exactly as before. The check is the same one every other prompt in this
+ * CLI is gated on — stdin and stdout both TTYs, not CI, `NOTIFAI_NO_INPUT`
+ * unset — because an agent that reaches a prompt does not fail, it hangs
+ * for ever waiting on a stdin nobody is typing into.
+ *
+ * The import is dynamic so that the prompt library, the banner and the whole
+ * interactive tree cost nothing to the paths that never draw them — `send`,
+ * `ask`, and the hook that runs in front of every prompt the user types.
+ */
+program.action(async () => {
+  if (deps.io.interactive !== true) {
+    program.outputHelp()
+    return
+  }
+  const { interactiveCommand } = await import('./interactive.js')
+  process.exit(await interactiveCommand(deps, version()))
+})
 
 // Setup leads: `init` is the single entry command for first-run friendliness.
 program
   .command('init')
+  .helpGroup(GROUP.start)
+  .summary('Set this project up, step by step')
   .description(
     'Set up Notifai here, idempotently: sign-in, project id, hooks, device readiness, live receipt proof. ' +
       'Interactive at a human terminal; never prompts otherwise (agents: pass flags)',
@@ -112,6 +155,8 @@ program
 
 program
   .command('doctor')
+  .helpGroup(GROUP.daily)
+  .summary('Check every part of the setup')
   .description('Audit config, credential, server, contract, device, hook, and saved receipt proof; exits nonzero when any line is FAIL (no live send)')
   .option('--json', 'machine-readable output')
   .action(async (opts: { json?: boolean }) => {
@@ -120,6 +165,8 @@ program
 
 program
   .command('login')
+  .helpGroup(GROUP.start)
+  .summary('Sign in and pair this machine')
   .description('Pair this machine with your Notifai account via browser approval')
   .option('--name <name>', 'machine name shown in the dashboard (default: hostname)')
   .option('--base-url <url>', 'Notifai server URL')
@@ -130,12 +177,18 @@ program
 
 program
   .command('logout')
+  .helpGroup(GROUP.advanced)
+  .summary('Remove the stored machine credential')
   .description('Remove the stored machine credential')
   .action(() => {
     process.exit(logoutCommand(deps))
   })
 
-const auth = program.command('auth').description('Authentication helpers')
+const auth = program
+  .command('auth')
+  .description('Authentication helpers')
+  .summary('Machine identity and account plan')
+  .helpGroup(GROUP.advanced)
 auth
   .command('status')
   .description('Show the stored machine identity')
@@ -153,6 +206,8 @@ auth
 
 program
   .command('devices')
+  .helpGroup(GROUP.daily)
+  .summary('List your devices and whether they can receive')
   .description('List registered devices and their delivery readiness')
   .option('--json', 'machine-readable output')
   .action(async (opts: { json?: boolean }) => {
@@ -161,6 +216,8 @@ program
 
 program
   .command('capabilities')
+  .helpGroup(GROUP.advanced)
+  .summary('Show what a platform can render')
   .description('Show a platform capability contract')
   .option('--platform <platform>', 'platform to describe (default: ios)')
   .option('--json', 'machine-readable output')
@@ -170,26 +227,31 @@ program
 
 const send = program
   .command('send')
+  .helpGroup(GROUP.agent)
+  .summary('Send a notification')
   .description('Send a notification')
+  .optionsGroup(SEND_GROUP.content)
   .requiredOption('--title <title>', 'notification title')
   .requiredOption('--body <body>', 'notification body')
-  .option('--subtitle <subtitle>')
+  .option('--subtitle <subtitle>', 'a line between the title and the body')
   .option('--detail <markdown>', 'long-form markdown shown only in the app, never on the banner')
   .option('--detail-file <path>', 'read --detail from a file (use - for stdin)')
-  .option('--event <event>', 'agent event name, e.g. tests_passed')
+  .option('--image <path|url|media_id>', 'upload or attach an image')
+  .optionsGroup(SEND_GROUP.routing)
   .option('--kind <kind>', 'what this is: update (default) | done | question (requires --reply)')
   .option('--project <id>', 'project identifier, e.g. my-app (lazily registered)')
-  .option('--session <id>', 'session identity (env: NOTIFAI_SESSION); presentation varies by surface')
   .option('--device <id>', 'target a device id (repeatable)', (v: string, all: string[]) => [...all, v], [])
   .option('--all', 'target all routable devices (overrides configured devices)')
-  .option('--ttl <seconds>', 'delivery window in seconds', (v: string) => Number(v))
-  .option('--collapse-key <key>', 'replace earlier notifications with the same key')
-  .option('--platform <platform>', 'limit optional fields to ios or macos (default: both)')
+  .option('--session <id>', 'session identity (env: NOTIFAI_SESSION); presentation varies by surface')
+  .option('--event <event>', 'agent event name, e.g. tests_passed')
+  .optionsGroup(SEND_GROUP.presentation)
   .option('--sound <sound>', 'default | done | attention | alert | none')
-  .option('--thread-id <id>', 'group related notifications')
   .option('--level <level>', 'interruption level: passive | active | time_sensitive')
-  .option('--data <key=value>', 'custom data (repeatable)', (v: string, all: string[]) => [...all, v], [])
-  .option('--image <path|url|media_id>', 'upload or attach an image')
+  .option('--collapse-key <key>', 'replace earlier notifications with the same key')
+  .option('--thread-id <id>', 'group related notifications')
+  .option('--ttl <seconds>', 'delivery window in seconds', (v: string) => Number(v))
+  .option('--platform <platform>', 'limit optional fields to ios or macos (default: both)')
+  .optionsGroup(SEND_GROUP.reply)
   .option('--reply', 'enable the inline reply action and block for the answer')
   .option('--reply-timeout <seconds>', 'how long to wait for a reply (default: 900)', (v: string) => Number(v))
   .option('--reply-window <seconds>', 'how long the server accepts a reply (default: 3600)', (v: string) => Number(v))
@@ -202,8 +264,10 @@ const send = program
   // Kept registered, and always a usage error with --reply, so the caller gets
   // a message pointing at `ask` instead of "unknown option".
   .option('--no-block', 'rejected with --reply; use `notifai ask` to ask and end the turn')
+  .optionsGroup(SEND_GROUP.advanced)
   .option('--wait <seconds>', 'how long to wait for provider outcomes', (v: string) => Number(v))
   .option('--no-wait', 'return immediately after acceptance')
+  .option('--data <key=value>', 'custom data (repeatable)', (v: string, all: string[]) => [...all, v], [])
   .option('--idempotency-key <key>', 'safe-retry key (default: random)')
   .option('--base-url <url>', 'Notifai server URL')
   .option('--json', 'print the full submission receipt as JSON')
@@ -247,6 +311,8 @@ send.addHelpText(
 
 program
   .command('replies [request_id]')
+  .helpGroup(GROUP.agent)
+  .summary('Retrieve replies to a question')
   .description('Retrieve replies for a notification request')
   .option('--pending', 'use the pushed question pending for this project session')
   .option('--wait <seconds>', 'how long to wait for a reply', (v: string) => Number(v))
@@ -258,6 +324,8 @@ program
 
 program
   .command('status <request_id>')
+  .helpGroup(GROUP.agent)
+  .summary('Show the evidence trail for a request')
   .description('Show the evidence trail for a notification request')
   .option('--json', 'machine-readable output')
   .action(async (requestId: string, opts: { json?: boolean }) => {
@@ -266,6 +334,8 @@ program
 
 program
   .command('ask [question]')
+  .helpGroup(GROUP.agent)
+  .summary('Register a question, then end the turn')
   .description('Register a question for the turn-end hook to route under your presence settings')
   .option(
     '--choice <label>',
@@ -320,13 +390,18 @@ program
 
 program
   .command('close <request_id>')
+  .helpGroup(GROUP.agent)
+  .summary('Retire a question so late answers are rejected')
   .description('Retire a question so late answers are rejected rather than lost')
   .action(async (requestId: string) => {
     process.exit(await closeCommand(deps, requestId))
   })
 
+// Hidden, not removed. It is an entry point the hook installer writes into a
+// harness config file, never something a person types — and listing it beside
+// `send` invited exactly one reading, which is that you were supposed to.
 program
-  .command('hook <event>')
+  .command('hook <event>', { hidden: true })
   .description('Internal: run a harness hook (reads hook JSON on stdin)')
   // Inert, and the point of it is that it is inert: the installed command line
   // carries a marker that says "Notifai wrote this" independently of which
@@ -340,7 +415,11 @@ program
     )
   })
 
-const hooks = program.command('hooks').description('Install harness hooks for registered-question routing')
+const hooks = program
+  .command('hooks')
+  .description('Install harness hooks for registered-question routing')
+  .summary('Wire a harness to route questions to your devices')
+  .helpGroup(GROUP.advanced)
 hooks
   .command('install')
   .description('Wire this harness to route registered questions to your devices')
@@ -361,15 +440,27 @@ hooks
     process.exit(hooksUninstallCommand(deps, opts))
   })
 
-const config = program.command('config').description('Show or change configuration')
+const config = program
+  .command('config')
+  .description('Show or change settings')
+  .summary('Show or change settings')
+  .helpGroup(GROUP.daily)
 config
   .command('show')
-  .description('Show the resolved configuration')
-  .option('--explain', 'show where each value comes from')
+  .description('Show every setting, what it does, and where its value came from')
+  .option('--explain', 'include advanced settings and the file each value came from')
+  .option('--plain', 'the flat key = value form, even at a terminal')
   .option('--json', 'machine-readable output')
-  .action((opts: { json?: boolean; explain?: boolean }) => {
+  .action((opts: { json?: boolean; explain?: boolean; plain?: boolean }) => {
     process.exit(configShowCommand(deps, opts))
   })
+config
+  .command('explain <key>')
+  .description('Explain one setting in full: what it does, what it accepts, what it is now')
+  .option('--json', 'machine-readable output')
+  .action((key: string, opts: { json?: boolean }) => {
+    process.exit(configExplainCommand(deps, key, opts))
+  })
 config
   .command('set <key> <value>')
   .description(

package/src/ui/banner.ts

@@ -0,0 +1,95 @@
+/**
+ * The wordmark shown when a human opens the interactive app.
+ *
+ * Three tiers, chosen by what the terminal can actually render rather than by
+ * what looks best in a screenshot: box-drawing blocks when the terminal is wide
+ * and Unicode-capable, a pure-ASCII form that survives anywhere, and a plain
+ * word when neither fits. A banner that wraps is worse than no banner, so the
+ * width check is not optional.
+ *
+ * The art is embedded rather than rendered at run time. It is one fixed word
+ * that will never change, and shipping a font engine to redraw a constant on
+ * every launch would cost every install — including the agents that never see
+ * it — for no benefit.
+ */
+import { gradientBlock, style, terminalWidth, unicode } from './theme.js'
+
+/** ANSI Shadow. 50 columns, 6 rows. */
+const BLOCK = [
+  '███╗   ██╗ ██████╗ ████████╗██╗███████╗ █████╗ ██╗',
+  '████╗  ██║██╔═══██╗╚══██╔══╝██║██╔════╝██╔══██╗██║',
+  '██╔██╗ ██║██║   ██║   ██║   ██║█████╗  ███████║██║',
+  '██║╚██╗██║██║   ██║   ██║   ██║██╔══╝  ██╔══██║██║',
+  '██║ ╚████║╚██████╔╝   ██║   ██║██║     ██║  ██║██║',
+  '╚═╝  ╚═══╝ ╚═════╝    ╚═╝   ╚═╝╚═╝     ╚═╝  ╚═╝╚═╝',
+]
+
+/** Pure ASCII. 34 columns, 4 rows — safe on any terminal, any code page. */
+const ASCII = [
+  '  _  _  ___ _____ ___ ___ _   ___ ',
+  ' | \\| |/ _ \\_   _|_ _| __/_\\ |_ _|',
+  ' | .` | (_) || |  | || _/ _ \\ | | ',
+  ' |_|\\_|\\___/ |_| |___|_/_/ \\_\\___|',
+]
+
+export type BannerSize = 'block' | 'ascii' | 'word'
+
+export function bannerSize(columns = terminalWidth()): BannerSize {
+  if (unicode && columns >= 54) return 'block'
+  if (columns >= 38) return 'ascii'
+  return 'word'
+}
+
+/** The wordmark as rendered lines, gradient included. */
+export function bannerLines(columns = terminalWidth()): string[] {
+  switch (bannerSize(columns)) {
+    case 'block':
+      return gradientBlock(BLOCK)
+    case 'ascii':
+      return gradientBlock(ASCII)
+    case 'word':
+      return gradientBlock(['N O T I F A I'])
+  }
+}
+
+/**
+ * Reveal the wordmark one row at a time.
+ *
+ * Deliberately brief and deliberately skippable: this runs before someone can
+ * do anything, so it may not become a wait. It is skipped entirely when output
+ * is not a TTY, when `NOTIFAI_NO_ANIMATION` is set, and under `CI`.
+ */
+export async function printBanner(
+  options: { animate?: boolean; env?: NodeJS.ProcessEnv; write?: (line: string) => void } = {},
+): Promise<void> {
+  const env = options.env ?? process.env
+  const write = options.write ?? ((line: string) => process.stdout.write(`${line}\n`))
+  const lines = bannerLines()
+  const animate =
+    options.animate !== false &&
+    process.stdout.isTTY === true &&
+    (env['NOTIFAI_NO_ANIMATION'] ?? '') === '' &&
+    (env['CI'] ?? '') === ''
+
+  write('')
+  for (const line of lines) {
+    // Two columns, matching the tagline and the status card beneath it. Flush
+    // left, the wordmark reads as a separate thing sitting above the app.
+    write(`  ${line}`)
+    if (animate) await new Promise((resolve) => setTimeout(resolve, 26))
+  }
+  write('')
+}
+
+/**
+ * One line of orientation under the wordmark — and it must stay one line.
+ * Wrapped onto two it stops reading as a subtitle and starts reading as the
+ * first paragraph of something, so a narrow terminal gets the version alone.
+ */
+export function tagline(version: string, columns = terminalWidth()): string {
+  const full = 'Native notifications for agents and local programs'
+  // Two leading columns of indent, two trailing for the version.
+  return columns >= full.length + 12
+    ? `${style.dim(full)}  ${style.dim(`v${version}`)}`
+    : style.dim(`v${version}`)
+}

package/src/ui/config-view.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest'
+import os from 'node:os'
+import path from 'node:path'
+import { CONFIG_KEYS, loadConfig } from '../config.js'
+import { renderConfigExplain, renderConfigList, renderConfigPlain } from './config-view.js'
+import { width } from './theme.js'
+
+const config = loadConfig({
+  cwd: os.tmpdir(),
+  env: { XDG_CONFIG_HOME: path.join(os.tmpdir(), 'notifai-config-view-tests') },
+})
+
+describe('renderConfigPlain', () => {
+  it('is the flat form scripts already parse', () => {
+    // This is the agent-facing shape and the reason the pretty renderer is
+    // gated on a human terminal. Restyling it would be a breaking change for
+    // an audience that cannot see the styling.
+    const lines = renderConfigPlain(config, false)
+    expect(lines).toHaveLength(CONFIG_KEYS.length)
+    expect(lines[0]).toBe(`base_url = ${JSON.stringify(config.base_url.value)}`)
+    for (const line of lines) expect(line).toMatch(/^[a-z_]+ = /)
+  })
+
+  it('appends the raw source tag under --explain', () => {
+    const lines = renderConfigPlain(config, true)
+    expect(lines[0]).toBe(
+      `base_url = ${JSON.stringify(config.base_url.value)}  [${config.base_url.source}]`,
+    )
+  })
+
+  it('carries no colour, so a pipe gets no escape bytes', () => {
+    for (const line of renderConfigPlain(config, true)) {
+      expect(line).toBe(line.replace(/\[[0-9;]*m/g, ''))
+    }
+  })
+})
+
+describe('renderConfigList', () => {
+  it('names every non-advanced key and explains it', () => {
+    const text = renderConfigList(config).join('\n')
+    for (const key of CONFIG_KEYS) {
+      const advanced = key === 'base_url' || key === 'collapse_key'
+      if (advanced) continue
+      expect(text, key).toContain(key)
+    }
+    expect(text).toContain('Questions & presence')
+    expect(text).toContain('notifai config explain')
+  })
+
+  it('reveals advanced keys only when asked', () => {
+    expect(renderConfigList(config).join('\n')).not.toContain('base_url')
+    expect(renderConfigList(config, { showAdvanced: true }).join('\n')).toContain('base_url')
+  })
+
+  it('fits the terminal, so no row wraps into the next', () => {
+    const columns = process.stdout.columns
+    Object.defineProperty(process.stdout, 'columns', { value: 80, configurable: true })
+    try {
+      for (const line of renderConfigList(config, { showAdvanced: true })) {
+        expect(width(line), line).toBeLessThanOrEqual(80)
+      }
+    } finally {
+      Object.defineProperty(process.stdout, 'columns', { value: columns, configurable: true })
+    }
+  })
+})
+
+describe('renderConfigExplain', () => {
+  it('answers what it is, what it is now, and what it accepts', () => {
+    const text = renderConfigExplain('require_idle', config).join('\n')
+    expect(text).toContain('require_idle')
+    expect(text).toContain('Only when I have stepped away')
+    expect(text).toContain('Accepts')
+    expect(text).toContain('true or false')
+    // The copyable next step; the old output stopped at the value.
+    expect(text).toContain('notifai config set require_idle')
+  })
+
+  it('lists what each choice of an enum means', () => {
+    const text = renderConfigExplain('sound', config).join('\n')
+    for (const choice of ['default', 'done', 'attention', 'alert', 'none']) {
+      expect(text, choice).toContain(choice)
+    }
+    expect(text).toContain('the completion chime')
+  })
+})

package/src/ui/config-view.ts

@@ -0,0 +1,135 @@
+/**
+ * Rendering for the configuration surfaces a person reads.
+ *
+ * The agent-facing shapes are untouched and live elsewhere: `--json` is the
+ * contract, and the flat `key = value` form stays exactly as it was for
+ * anything that is not a terminal. What is new is only what a human sees.
+ */
+import { CONFIG_KEYS, type CliConfig, type ConfigKey } from '../config.js'
+import {
+  CONFIG_GROUPS,
+  acceptedValues,
+  configInfo,
+  configKeysByGroup,
+  describeSource,
+  formatValue,
+} from '../config-schema.js'
+import { glyph, pad, style, terminalWidth, width, wrap } from './theme.js'
+
+/**
+ * The full settings listing, grouped and explained.
+ *
+ * Each key gets its name (what you type), its value (what is in force), where
+ * that value came from, and one line on what it does. The name leads rather
+ * than the friendly label because the next thing a reader does with it is type
+ * it into `config set`.
+ */
+export function renderConfigList(
+  config: CliConfig,
+  options: { showAdvanced?: boolean } = {},
+): string[] {
+  const columns = terminalWidth()
+  const lines: string[] = []
+  const nameWidth = Math.max(...CONFIG_KEYS.map((key) => key.length))
+  const SUMMARY_INDENT = '      '
+
+  for (const group of CONFIG_GROUPS) {
+    const keys = configKeysByGroup(group.id).filter(
+      (info) => options.showAdvanced === true || info.advanced !== true,
+    )
+    if (keys.length === 0) continue
+
+    lines.push('')
+    lines.push(style.heading(group.title))
+    for (const line of wrap(group.blurb, columns - 2)) lines.push(style.dim(`  ${line}`))
+    lines.push('')
+
+    for (const info of keys) {
+      const entry = config[info.key]
+      const source = describeSource(entry.source)
+      const value = formatValue(info.key, entry.value)
+      const isSet = source.label !== 'default'
+      // The provenance mark is only drawn when there is provenance to show;
+      // an empty dim segment still emits escape codes, so a `trimEnd` on the
+      // finished string cannot remove it.
+      const provenance = isSet ? `  ${style.dim(`${glyph.bullet} ${source.label}`)}` : ''
+      lines.push(
+        `  ${style.code(pad(info.key, nameWidth))}  ` +
+          `${isSet ? style.value(value) : style.unset(value)}${provenance}`,
+      )
+      for (const line of wrap(info.summary, columns - SUMMARY_INDENT.length)) {
+        lines.push(style.dim(`${SUMMARY_INDENT}${line}`))
+      }
+    }
+  }
+
+  lines.push('')
+  lines.push(
+    style.dim(
+      `${glyph.arrow} ${style.code('notifai config explain <key>')} for what one of these means and how to change it.`,
+    ),
+  )
+  return lines
+}
+
+/**
+ * Everything about one key, for someone who has asked about it specifically.
+ *
+ * This is the payoff of the listing above staying terse: the reader arrives
+ * here already knowing which key they care about, so the full paragraph, the
+ * legal values, and the layer the current value came from can all be spent on
+ * that one key.
+ */
+export function renderConfigExplain(key: ConfigKey, config: CliConfig): string[] {
+  const info = configInfo(key)
+  const entry = config[key]
+  const source = describeSource(entry.source)
+  const columns = terminalWidth()
+  const lines: string[] = []
+
+  lines.push('')
+  lines.push(`${style.code(key)}  ${style.dim(glyph.bullet)}  ${style.heading(info.label)}`)
+  lines.push('')
+
+  for (const paragraph of info.detail.split('\n\n')) {
+    for (const line of wrap(paragraph, columns - 2)) lines.push(`  ${line}`)
+    lines.push('')
+  }
+
+  const valueLabel = formatValue(key, entry.value)
+  lines.push(
+    `  ${style.dim(pad('Now', 10))}${style.value(valueLabel)}  ${style.dim(`${glyph.bullet} ${source.label}`)}`,
+  )
+  if (source.path !== null) lines.push(`  ${style.dim(pad('', 10))}${style.dim(source.path)}`)
+  lines.push(`  ${style.dim(pad('Accepts', 10))}${acceptedValues(key)}`)
+
+  if (info.choices !== undefined && info.choiceHints !== undefined) {
+    lines.push('')
+    for (const choice of info.choices) {
+      const hint = info.choiceHints[choice]
+      lines.push(
+        `  ${style.dim(pad('', 10))}${style.code(pad(choice, 14))}${style.dim(hint ?? '')}`.trimEnd(),
+      )
+    }
+  }
+
+  lines.push('')
+  const example = info.example ?? (info.choices?.[0] ?? 'value')
+  lines.push(`  ${style.dim('Change it')} ${style.code(`notifai config set ${key} ${example}`)}`)
+  lines.push('')
+  return lines
+}
+
+/** The flat form, unchanged, for anything that is not a person at a terminal. */
+export function renderConfigPlain(config: CliConfig, explain: boolean): string[] {
+  return CONFIG_KEYS.map((key) => {
+    const entry = config[key]
+    const provenance = explain ? `  [${entry.source}]` : ''
+    return `${key} = ${JSON.stringify(entry.value)}${provenance}`
+  })
+}
+
+/** Longest visible line, for callers that need to size a rule or a box. */
+export function widestLine(lines: readonly string[]): number {
+  return Math.max(0, ...lines.map((line) => width(line)))
+}