tuile 0.15.0 → 0.17.0

data/ideas/focus-accent.md

@@ -1,116 +0,0 @@
-# The focus accent — should `Button` / `Checkbox` / `Tabs` / `MenuBar` / `List` move onto `default_bg_color`?
-
-**Status:** measured and parked, 2026-09-01. Spun off from `D_bg_surface`,
-which introduced `Component#default_bg_color` and migrated the *well* widgets
-(`AbstractStringField`, `Select`, `ComboBox`) onto it while explicitly leaving
-this family alone. That note records the decision; this one records the
-*measurement*, so whoever revisits it doesn't re-run the experiment.
-
-## The question
-
-Five widgets highlight themselves on focus by stomping a background onto their
-painted content at repaint time:
-
-```ruby
-label = label.with_bg(screen.theme.active_bg_color) if active?   # Button, Checkbox
-segment.with_bg(screen.theme.active_bg_color)                    # Tabs, MenuBar
-is_cursor ? base.with_bg(screen.theme.active_bg_color) : base    # List
-```
-
-`default_bg_color` can express the per-component half of that —
-`{ active: screen.theme.active_bg_color }`, or the allocation-free
-`active? ? … : nil`, with no `:normal` key so an unfocused widget falls through
-to the ambient. So: should it?
-
-## Measured, not argued (Checkbox, 2026-09-01)
-
-The migration was written and run. It is:
-
-```diff
-       label = (StyledString.plain(value ? "[x] " : "[ ] ") + caption).ellipsize(rect.width)
--      label = label.with_bg(screen.theme.active_bg_color) if active?
-       draw_text(rect.left, rect.top, label)
-     end
-+
-+    # @return [Color, nil]
-+    def default_bg_color = active? ? screen.theme.active_bg_color : nil
-```
-
-**Net +2 lines.** Nothing is deleted, because these widgets have no *well* —
-there is no reach-around-the-chain to remove, which is exactly what the
-`AbstractStringField` migration did delete (`#background`). So it is not a
-simplification.
-
-**The whole suite passed: 2787 examples, 0 failures.** Both behavior changes
-below are unpinned by any spec — see *The missing guard*.
-
-Probed directly, migrated vs. original, on a focused `Checkbox` at 20×1:
-
-| case | original | migrated |
-|---|---|---|
-| caption span carries `bg: BLUE` | `59, 59` — accent covers it | `59, :blue` — **the span survives** |
-| `bg_color = 52` | `59, 59` — accent stomps the tint | `52, 52` — tint wins, no focus shade |
-
-## What the measurement says
-
-**A surface and an accent are different things, and the hook is only right for
-one.** A *surface* is what your cells sit on; it is legitimately the app's to
-override, which is the whole point of `bg_color` winning over
-`default_bg_color`. An *accent* is a signal painted **over** whatever is there,
-and it must be unconditional — the moment it can be selectively suppressed
-(by a caption span, by an app tint) it stops being a reliable indicator.
-
-Row 1 is therefore a regression: `with_bg` is override-all, `under_bg` (what
-`draw_text` applies) is fill-unset, so a caption carrying its own background
-punches a hole in the highlight.
-
-Row 2 is worse than it looks: `Checkbox` paints no caret, so a flat `bg_color`
-removes its only focus affordance. Recoverable with `{ normal:, active: }`, but
-the *default* got worse. This is the same objection that made `Select` the
-awkward case in `D_bg_surface` — there it was accepted because a `Select` really
-does paint a well, and the flat surface is a real thing to want.
-
-**And for three of the five it isn't even expressible.** `Tabs`, `MenuBar` and
-`List` accent a *segment or row*, not the component. A per-component hook has
-nothing to say about "the third tab" or "the cursor row". Only `Button` and
-`Checkbox` are candidates at all, which makes a partial migration a
-consistency *loss*, not a gain.
-
-## Options, when this is picked up
-
-- **(A) Leave it, pin it.** The status quo plus the specs below. Cheapest, and
-  the measurement above says the status quo is right.
-- **(B) Migrate `Button` + `Checkbox` only.** Costs +4 lines, splits the family
-  three ways, and takes both regressions. Hard to justify on this evidence.
-- **(C) Name the accent as its own concept.** The honest generalisation: a
-  paint-time `over_bg` / accent layer that is *not* part of the `bg_color`
-  chain and is applied after it, with an explicit `with_bg` (override-all)
-  contract. That would cover all five *and* the segment/row cases, because the
-  layer is applied to a `StyledString` rather than declared per component. It
-  is a second colour channel, though — weigh against `D_theme_ref`'s "not a
-  third colour channel" reasoning before adding one.
-- **(D) Make focus indication a framework concern.** `Screen` knows the focus
-  chain; it could accent the focused component's extent centrally. Almost
-  certainly wrong — it would need per-widget opt-out (a focused `TextArea` must
-  not have its whole rect stomped) and reintroduces a framework-owned paint
-  pass the top-down layout rule keeps out.
-
-## The missing guard (do this regardless of the outcome)
-
-Neither behavior in the table is asserted anywhere, which is how a future
-migration would land silently. `checkbox_spec` and `button_spec` want:
-
-- the focus accent covers a caption span that carries its own background
-  (pins `with_bg`, not `under_bg`);
-- `bg_color` set on the widget does **not** suppress the focus accent
-  (pins the accent as unconditional).
-
-Eight lines each, and they convert `D_bg_surface`'s "deliberately not migrated"
-from recorded to enforced.
-
-## Related
-
-`D_bg_surface` (the chain, the state map, the surface/accent line),
-`D_bg_inherit` (`under_bg` vs `with_bg`), `D_boolean_fields` (why the extent
-arithmetic must not vary with `bg_color`), `D_theme_ref` (why there is not a
-third colour channel).

data/ideas/form-layout.md

@@ -1,151 +0,0 @@
-# `FormLayout`: where the caption, the message and the required marker go
-
-**Status:** filed 2026-09-03 as `ideas/caption-and-error-ownership.md`, which
-asked whether a field or the container around it owns the caption and the error
-state. **That question is settled, and the field half has shipped** — read
-`D_caption_ownership` (a field carries no caption; the container does) and
-`D_has_validation` (the field stores the verdict in
-`HasValidation#error_message` and paints it as a red *well*; whoever owns the
-cells paints the *message*, subscribing to `on_error_message_change`) before
-this note. Nothing here re-argues either. Note in particular that an invalid
-field shows **no ink at all**: it gets a slight red *well*, never the red
-foreground on the glyphs that the first draft recommended.
-
-What is left — and all this note now holds — is the *container* half: the
-`FormLayout` that has the cells. Unbuilt, and still what infra item 2 of
-`ideas/new-components.md` is blocked on. Graduates into a `D_form_layout`, the
-component's rdoc, a book ch7 section, a README Components row and a CHANGELOG
-line.
-
-## What the layout has to place
-
-Three pieces of chrome, none of which the field carries or can carry:
-
-- **the caption** — `FormLayout#add(field, caption: "Username")`; the string
-  lives in the layout's per-child map, never on the field.
-- **the message** — read off `child.error_message`, painted in
-  `Theme#error_color`.
-- **the required marker** — a red dot beside the caption; chrome like the
-  caption, so it rides the container too (below).
-
-## Recommended shape: one row per field, inline on both sides
-
-```
-   Username ∙ [________________] Required
-   Password ∙ [________________] Required
-```
-
-(the `∙` is the required marker, red; whether it sits before or after the
-caption text, and whether it widens the caption column, goes with the caption
-geometry below.)
-
-- **Inline right for the message.** One row, no growth, nothing bottom-up —
-  which is the whole reason to prefer it. The message is bounded by the row, so
-  the layout truncates with an ellipsis (`InfoWindow#lines=` is the model).
-- **A form-level status row showing the first error is the *app's*** to build
-  from the same data, not the layout's — `D_status_bar` from the other side: the
-  framework reserves no row it was not asked for.
-
-## Wiring the message
-
-The layout paints the message in cells the *field* does not invalidate, so it
-has to be told: subscribe to `on_error_message_change` at `add`, unsubscribe at
-`remove`. That notice exists for exactly this consumer, and `D_has_validation`
-records why it is plain listener inversion rather than the push notice
-`D_bad_input` withheld (this fact is discrete, that one is continuous).
-
-**Open, and a real conflict:** `on_error_message_change` is a single
-`attr_accessor` slot, and its rdoc says the container painting the message
-claims it — *"an app painting its own takes it instead."* A `FormLayout` that
-claims it silently at `add` therefore disables an app that already set it,
-which is the one-callback-slot failure `D_no_key_interceptor` names (all four
-composed fields hit it). Decide with the component: either the layout refuses
-to overwrite a non-nil slot, or it chains the previous callable, or the notice
-grows a subscriber list. Do not just assign it.
-
-## Facts it rests on, so they don't get re-derived
-
-- **A per-child attribute map is a solved shape.** `Box` keeps constraints in an
-  identity-keyed per-child map that is explicitly *not* a second copy of
-  ordering (`D_box_layouts`); a `FormLayout` holding `{field => caption}` copies
-  it. `Component::Slot` is the tree-native answer for a swappable region
-  (`D_slots`).
-- **It owes an `on_child_visibility_changed` override**, like `Box` — it is the
-  rule for any container with layout arithmetic (`D_visibility`). A conditional
-  form field is *the* consumer that brought `visible=` in, so a `FormLayout`
-  that skipped this would leave the hole in exactly the place it was built for:
-  the caption row and the message cells of a hidden field must go with it.
-- **Measuring captions does not reopen bottom-up sizing.** Aligning a caption
-  column needs the *container's own* strings measured — caller-side arithmetic,
-  the same move `Select` makes when it measures its labels and assigns the rect
-  (`D_select`; `D_box_layouts`' "`align:` is legal only because the cross extent
-  is caller-supplied"). It looks like the banned channel and isn't.
-- **The layout is the authority for caption↔field lookup**, since it holds the
-  only copy of the association — so it owes a locator
-  (`form.field_for(caption: "Name")`), which is what Karibu-Testing does against
-  Vaadin 25 form items. `Component#id` + `Tuile::Testing.get`
-  (`D_component_lookup`) is a *different* handle, not a replacement:
-  an id is a tag the app assigns.
-- **Top-down layout is the heaviest prior**, and it is what makes both halves
-  inline: a field is handed one row and cannot grow a second for a caption or a
-  message.
-
-## Still open
-
-- **Caption geometry** — caption column left (aligned, measured caller-side)
-  versus a row above. Inline-left is the natural pair to the inline-right
-  message; the row-above shape wants the message on a third row and reopens the
-  growth question.
-- **Required indicator — decided in shape, open in glyph.**
-  `FormLayout#add(field, caption:, required: true)` paints a **red dot beside
-  the caption**, as Vaadin does. `D_has_value` parked the indicator; this is
-  where it lands, and the field still does not know it is required.
-
-  Three things checked against Vaadin 25.2 rather than remembered, since they
-  shape the TUI version:
-
-  - Vaadin marks a required field *"with an indicator next to the label"* — so
-    the marker rides the **caption**, which in Tuile means it rides the
-    container, exactly as `D_caption_ownership` puts the caption there. The
-    precedent lines up; nothing to re-argue.
-  - Both the glyph and its color are style properties
-    (`--vaadin-input-field-required-indicator` /
-    `-color`, `::part(required-indicator)`), i.e. Vaadin treats *which* mark as
-    a theme choice, not a semantic. Tuile's equivalent question is whether the
-    dot's red is a reused `Theme#error_color` or a token of its own — a required
-    field is not (yet) *invalid*, and every `Theme` member is validated
-    `is_a?(Color)` with a hand-rolled `Theme.new` having to pass all of them, so
-    a new token is a breaking change to weigh, not a freebie.
-  - The docs also recommend *"an instruction text at the top of the form
-    explaining the required indicator"* — worth knowing that even Vaadin does
-    not consider the marker self-explanatory. In Tuile that legend is the app's
-    row, not the layout's (`D_status_bar`).
-
-  **The glyph is the one real Tuile problem, and it is the ambiguous-width bet
-  (`D_ambiguous_width`).** Measured with the gem: `•` U+2022 and `●` U+25CF and
-  `·` U+00B7 are all East-Asian **Ambiguous** — 1 column under Tuile's policy, 2
-  under ambiguous-as-wide, so each would enlarge the inventory that keeps the
-  bet cheap to reverse. `∙` U+2219 BULLET OPERATOR and `◦` U+25E6 measure **1
-  under both policies** and are the dots that cost nothing. So: default to `∙`
-  (or ASCII `*` with the dot as an opt-in knob, per the rule that a new
-  component defaults to ASCII when the pretty glyph is Ambiguous), and if the
-  marker becomes a knob it validates at assignment that it took one cluster one
-  column wide (`D_scrollbar_ink`).
-- **Helper text**, the other half of the seam `ideas/new-components.md` infra
-  item 2 names, is undesigned — and the inline-right cells are already spoken
-  for by the message.
-
-## Related
-
-`D_caption_ownership` and `D_has_validation` (**the two entries this note's
-first half graduated into** — read them first), `D_bad_input` (the field's own
-report, which reddens the same well), `ideas/binder.md` (the writer of
-`error_message`; the four-layer vocabulary), `D_on_blur` (the commit point a
-field can canonicalize from; the bad-input push notice that is still unbuilt),
-`D_date_field` (a field whose
-input outruns its value), `ideas/new-components.md` (infra item 2; Tier 2 Form
-Layout, Custom Field), `D_box_layouts` (the per-child attribute map;
-caller-supplied cross extent), `D_slots`, `D_select` (caller-side measurement),
-`D_status_bar` (no framework-reserved row), `D_no_key_interceptor` (one callback
-slot cannot be shared), `D_has_value` (the parked required indicator),
-AGENTS.md "Input values" (caption is chrome, text is value).

data/ideas/hover/probe.rb

@@ -1,241 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Terminal mouse-mode probe — fills one row of `ideas/hover.md`'s matrix.
-# Research tooling for that idea; it dies with the note at graduation.
-#
-# Deliberately depends on nothing but stdlib: this measures the *terminal*, so
-# Tuile's own parsing (and its fixed 5-byte escape gulp) must stay out of the
-# way. Bytes are read greedily and parsed incrementally, so the log shows what
-# actually arrived rather than what a fixed-width reader would have made of it.
-#
-# Run it in its OWN terminal / tmux window — never in one where another TUI
-# owns stdin, and never in the terminal a coding agent is drawing on: mode 1003
-# would pour motion reports into *its* stdin.
-#
-#   ruby ideas/hover/probe.rb [logfile]
-#
-# Rows recorded so far live in `ideas/hover.md` under "Measured". Still wanted:
-# Alacritty bare, Alacritty over ssh, tmux local. The logs themselves are not
-# committed — a re-run regenerates them, and the findings are what graduate.
-#
-# The parser is covered by ideas/hover/probe_spec.rb — run that before trusting
-# an interactive session, since a decode slip wastes the whole run (it already
-# caught an X10 coordinate off-by-one: the button code is byte-32, but the
-# coordinates are 1-based *and* offset, so they decode as byte-33).
-
-require "io/console"
-
-LOG = if __FILE__ == $PROGRAM_NAME
-        File.open(ARGV[0] || "mouse_probe.log", "w").tap { _1.sync = true }
-      else
-        $stderr # loaded for testing: never open a log, never touch the terminal
-      end
-
-def say(msg) = ($stdout.print("#{msg}\r\n"); $stdout.flush)
-def log(msg) = LOG.puts(msg)
-def esc(seq) = ($stdout.print(seq); $stdout.flush)
-
-def both(msg)
-  say msg
-  log msg
-end
-
-# --- incremental parser -----------------------------------------------------
-# Returns [events, leftover]. Each event is [kind, detail].
-def parse(buf)
-  events = []
-  until buf.empty?
-    if buf.start_with?("\e[M")
-      break if buf.bytesize < 6
-
-      # Button code is offset by 32; coordinates are 1-based *and* offset by 32,
-      # so they come back with -33. Mixing these up is the classic X10 slip.
-      cb, cx, cy = buf[3].ord - 32, buf[4].ord - 33, buf[5].ord - 33
-      events << [:x10, decode_cb(cb) + " at #{cx},#{cy}"]
-      buf = buf[6..]
-    elsif (m = buf.match(/\A\e\[<(\d+);(\d+);(\d+)([Mm])/))
-      cb = m[1].to_i
-      kind = m[4] == "M" ? "press" : "release"
-      events << [:sgr, "#{decode_cb(cb)} [#{kind}] at #{m[2].to_i - 1},#{m[3].to_i - 1}"]
-      buf = buf[m[0].bytesize..]
-    elsif buf.start_with?("\e[I")
-      events << [:focus, "FocusIn"]
-      buf = buf[3..]
-    elsif buf.start_with?("\e[O")
-      events << [:focus, "FocusOut"]
-      buf = buf[3..]
-    elsif (m = buf.match(/\A\e\[\?(\d+);(\d+)\$y/))
-      events << [:decrpm, "mode #{m[1]} => #{decrpm_meaning(m[2].to_i)}"]
-      buf = buf[m[0].bytesize..]
-    elsif buf.start_with?("\e[<") || buf.start_with?("\e[?")
-      break # incomplete, wait for more bytes
-    else
-      events << [:other, buf[0].inspect]
-      buf = buf[1..]
-    end
-  end
-  [events, buf]
-end
-
-def decode_cb(code)
-  base = code & 0b11
-  mods = []
-  mods << "shift" if code & 4 != 0
-  mods << "meta"  if code & 8 != 0
-  mods << "ctrl"  if code & 16 != 0
-  motion = code & 32 != 0
-  wheel  = code & 64 != 0
-  name =
-    if wheel
-      %w[wheel_up wheel_down wheel_left wheel_right][base] || "wheel?#{base}"
-    else
-      %w[left middle right release][base]
-    end
-  "code=#{code} #{motion ? 'MOTION ' : ''}#{name}#{mods.empty? ? '' : " +#{mods.join('+')}"}"
-end
-
-def decrpm_meaning(ps)
-  { 0 => "NOT RECOGNIZED", 1 => "set", 2 => "reset (supported)",
-    3 => "permanently set", 4 => "permanently reset" }[ps] || "unknown(#{ps})"
-end
-
-# --- drain ------------------------------------------------------------------
-# Reads for `seconds`, returning every parsed event. `stop_on` ends it early.
-def drain(seconds, stop_on: nil)
-  deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
-  buf = +""
-  out = []
-  loop do
-    left = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    break if left <= 0
-    next unless IO.select([$stdin], nil, nil, [left, 0.2].min)
-
-    chunk = $stdin.read_nonblock(4096)
-    # Timestamp the *read*, and record the chunk size: inter-arrival gaps and
-    # multi-event chunks are how we tell whether ssh/tmux coalesced anything.
-    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    buf << chunk
-    events, buf = parse(buf)
-    log format("  [read %+7.3fs %3dB -> %d ev]", now - deadline + seconds, chunk.bytesize, events.size) if events.any?
-    events.each do |kind, detail|
-      out << [kind, detail]
-      log "    #{kind}: #{detail}"
-    end
-    break if stop_on && buf.empty? && out.any? { |(_, d)| d.include?(stop_on) }
-  end
-  out
-end
-
-def wait_for_enter
-  say "    [press ENTER to start]"
-  loop do
-    IO.select([$stdin], nil, nil, 60) or break
-    break if $stdin.read_nonblock(4096).include?("\r") || false
-  rescue IO::WaitReadable, EOFError
-    break
-  end
-end
-
-ALL_OFF = "\e[?1000l\e[?1002l\e[?1003l\e[?1004l\e[?1006l"
-
-return unless __FILE__ == $PROGRAM_NAME
-
-begin
-  $stdin.raw do
-    log "=== mouse probe #{Time.now.iso8601 rescue Time.now} ==="
-    log "TERM=#{ENV['TERM']} COLORTERM=#{ENV['COLORTERM']} TMUX=#{ENV['TMUX']}"
-    log "size=#{IO.console.winsize.reverse.join('x')}"
-    log ""
-
-    # -- Phase 0: DECRQM support ---------------------------------------------
-    both "PHASE 0  DECRQM mode-support probe (no mouse needed)"
-    [9, 1000, 1002, 1003, 1004, 1005, 1006, 1015, 1016].each do |mode|
-      esc "\e[?#{mode}$p"
-      got = drain(0.3)
-      both "  #{mode}: #{got.empty? ? 'NO REPLY' : got.map(&:last).join(', ')}"
-    end
-    log ""
-
-    # -- Phase 1: 1000 + X10 -------------------------------------------------
-    both ""
-    both "PHASE 1  mode 1000, X10 encoding — click a few times (5s)"
-    wait_for_enter
-    esc "\e[?1000h"
-    got = drain(5)
-    esc "\e[?1000l"
-    both "  => #{got.size} events; releases seen: #{got.count { |(_, d)| d.include?('release') }}"
-    log ""
-
-    # -- Phase 2: 1000 + SGR 1006 -------------------------------------------
-    both ""
-    both "PHASE 2  mode 1000 + SGR 1006 — click a few times, incl. right-click (5s)"
-    wait_for_enter
-    esc "\e[?1006h\e[?1000h"
-    got = drain(5)
-    esc "\e[?1000l"
-    sgr = got.count { |(k, _)| k == :sgr }
-    both "  => #{got.size} events, #{sgr} in SGR form (0 means 1006 was ignored)"
-    log ""
-
-    # -- Phase 3: 1002 -------------------------------------------------------
-    both ""
-    both "PHASE 3  mode 1002 — FIRST move with no button (expect nothing),"
-    both "         THEN drag with the left button held (expect motion) (8s)"
-    wait_for_enter
-    esc "\e[?1002h"
-    got = drain(8)
-    esc "\e[?1002l"
-    motion = got.count { |(_, d)| d.include?("MOTION") }
-    both "  => #{got.size} events, #{motion} motion"
-    log ""
-
-    # -- Phase 4: 1003 rate --------------------------------------------------
-    both ""
-    both "PHASE 4  mode 1003 — move the mouse around normally, NON-STOP (10s)"
-    wait_for_enter
-    esc "\e[?1003h"
-    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    got = drain(10)
-    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
-    esc "\e[?1003l"
-    motion = got.count { |(_, d)| d.include?("MOTION") }
-    both format("  => %d events (%d motion) in %.1fs = %.1f/s  <-- THE NUMBER",
-                got.size, motion, elapsed, got.size / elapsed)
-    log ""
-
-    # -- Phase 5: pointer leaves the window ---------------------------------
-    both ""
-    both "PHASE 5  mode 1003 + 1004 — move the pointer OUT of this window,"
-    both "         click another app, then come back (10s)"
-    wait_for_enter
-    esc "\e[?1003h\e[?1004h"
-    got = drain(10)
-    esc "\e[?1003l\e[?1004l"
-    focus = got.select { |(k, _)| k == :focus }
-    both "  => #{got.size} events; focus events: #{focus.empty? ? 'NONE' : focus.map(&:last).join(', ')}"
-    both "     (NONE means nothing tells us the pointer left — hover would strand)"
-    log ""
-
-    # -- Phase 6: wide coordinates ------------------------------------------
-    cols = IO.console.winsize[1]
-    both ""
-    if cols > 223
-      both "PHASE 6  mode 1003 + 1006 — click PAST column 223 (width=#{cols}) (8s)"
-      wait_for_enter
-      esc "\e[?1006h\e[?1003h"
-      got = drain(8)
-      esc "\e[?1003l\e[?1006l"
-      both "  => #{got.size} events; max x seen: #{got.map { |(_, d)| d[/at (\d+),/, 1].to_i }.max}"
-    else
-      both "PHASE 6  SKIPPED — terminal is #{cols} cols, need >223 to test the X10 cap"
-      log "PHASE 6 skipped: width #{cols}"
-    end
-
-    both ""
-    both "done — log written to #{LOG.path}"
-  end
-ensure
-  esc ALL_OFF
-  LOG.close
-end

data/ideas/hover/probe_spec.rb

@@ -1,82 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Covers probe.rb's byte decoder. Deliberately NOT under spec/ — this is
-# research tooling for ideas/hover.md, not gem code, so it must stay out of
-# `rake spec` and out of CI. Plain assertions, no rspec:
-#
-#   ruby ideas/hover/probe_spec.rb
-#
-# Run it before an interactive probe session: a decode slip wastes the whole
-# run, and one already happened (X10 coordinates are byte-33, not byte-32 —
-# the offset differs from the button code's because coordinates are 1-based).
-
-require_relative "probe"
-
-FAILURES = []
-
-def check(input, want)
-  events, leftover = parse(input.dup)
-  got = events.map { |kind, detail| "#{kind}: #{detail}" }
-  if got == want && leftover.empty?
-    puts "  ok    #{input.inspect}"
-  else
-    FAILURES << input
-    puts "  FAIL  #{input.inspect}\n        got  #{got.inspect} leftover=#{leftover.inspect}\n        want #{want.inspect}"
-  end
-end
-
-# A fragment must be held for the next read, never half-consumed: real reads
-# do not align to event boundaries (measured: 4 reads in one 10s sample came
-# back at 11.5 bytes/event, i.e. one event split across two reads).
-def check_held(fragment)
-  events, leftover = parse(fragment.dup)
-  if events.empty? && leftover == fragment
-    puts "  ok    held #{fragment.inspect}"
-  else
-    FAILURES << fragment
-    puts "  FAIL  #{fragment.inspect} -> #{events.inspect} leftover=#{leftover.inspect}"
-  end
-end
-
-puts "X10 encoding (button code is byte-32; coordinates are byte-33):"
-check "\e[M !\"", ["x10: code=0 left at 0,1"]
-check "\e[M#!!", ["x10: code=3 release at 0,0"]
-check "\e[M\"!!", ["x10: code=2 right at 0,0"]
-check "\e[M!!!", ["x10: code=1 middle at 0,0"]
-check "\e[M`!!", ["x10: code=64 wheel_up at 0,0"]
-check "\e[Ma!!", ["x10: code=65 wheel_down at 0,0"]
-check "\e[M0!!", ["x10: code=16 left +ctrl at 0,0"]
-puts "X10 motion codes — the set that arrives under 1002/1003:"
-check "\e[M@!!", ["x10: code=32 MOTION left at 0,0"]      # drag; all of 1002's traffic
-check "\e[MC!!", ["x10: code=35 MOTION release at 0,0"]   # hover; 1003 only
-puts "X10 burst — two reports back to back must split cleanly (a fixed 6-byte"
-puts "read is safe here, which is why a PTY spec may burst X10 but not SGR):"
-check "\e[M !\"\e[M#!\"", ["x10: code=0 left at 0,1", "x10: code=3 release at 0,1"]
-
-puts "SGR 1006 — press/release told apart by the final byte, and the release"
-puts "carries its button (X10's release code 3 is anonymous):"
-check "\e[<0;1;1M", ["sgr: code=0 left [press] at 0,0"]
-check "\e[<0;1;1m", ["sgr: code=0 left [release] at 0,0"]
-check "\e[<2;300;40m", ["sgr: code=2 right [release] at 299,39"]
-check "\e[<35;11;6M", ["sgr: code=35 MOTION release [press] at 10,5"]
-check "\e[<64;5;5M", ["sgr: code=64 wheel_up [press] at 4,4"]
-puts "SGR past the X10 cap — the whole reason to request 1006:"
-check "\e[<0;500;9M", ["sgr: code=0 left [press] at 499,8"]
-
-puts "focus tracking (mode 1004) and DECRQM replies:"
-check "\e[I", ["focus: FocusIn"]
-check "\e[O", ["focus: FocusOut"]
-check "\e[?1003;2$y", ["decrpm: mode 1003 => reset (supported)"]
-check "\e[?1005;0$y", ["decrpm: mode 1005 => NOT RECOGNIZED"]
-
-puts "partial input is held, not consumed:"
-["\e[M", "\e[M!", "\e[<0;1", "\e[?100"].each { check_held(_1) }
-
-puts
-if FAILURES.empty?
-  puts "ALL PARSER TESTS PASS"
-else
-  puts "#{FAILURES.size} FAILED"
-end
-exit(FAILURES.empty? ? 0 : 1)