@qxuken/kui 0.1.0-alpha.40 → 0.1.0-alpha.42

package/CHANGELOG.md

@@ -21,6 +21,421 @@ listed under both (backlog F61, from the alpha.12 field reports: the list
 is what the release knows it broke, and a fix it did not think of as one
 was the first bare bump to break an app in five releases).
 
+## 0.1.0-alpha.42 (2026-10-07)
+
+**What breaks.**
+
+- A press after a dead key it does not combine with carries what the
+  platform typed in its `text`: German's `^ space` is a Space whose
+  `text` is `^`, and `^ z` a `z` whose `text` is `^z`, where they said `" "`
+  and `z` — in a key sink's payload and in what an editor inserts (under
+  Fixed, RG127). A keymap that binds Space by its `text` rather than its
+  `code` sees the accent there.
+- Node: a whole number past 2^53 in a message comes back a `number`,
+  where it came back a `BigInt` (RG138).
+- C: `kui_take_menu_action` with a NULL or too-small `out` leaves the
+  action queued, where it dropped it; `kui_take_warnings` keeps what does
+  not fit `cap` for the next call, where it dropped it; `kui_draw_data`'s
+  `fragments` and `textures` are NULL on a frame that draws none, where
+  they were a non-NULL pointer to nothing (RG133, RG134, RG131).
+- A text style whose size or line height is under a pixel — 0, negative,
+  NaN — shapes at a pixel, where Node and Lua aborted or hung and Rust
+  panicked (RG136); a cell grid's rows are a pixel apart at an infinite
+  one, where they went to the layout's limit (RG144).
+- Rust: `schema::Door`, `schema::CustomProp` and `schema::ElementDef` gain
+  `odin` (under Added, the Odin binding), so a struct literal of one needs
+  the field.
+
+C stays at ABI 25 (kui.h gains no function and no field; four doors now
+keep what it always promised) and the Node wire at v21 (no frame version).
+
+### Added
+
+- **An Odin binding, experimental** (`packages/odin`). `kui/c` mirrors
+  kui.h declaration by declaration, pinned to the C compiler's layout by
+  848 generated `#assert`s. `kui` is the typed layer, generated from
+  kui.h and the prop schema:
+  - `Spec` and `Text_Style`, one field per schema row;
+  - an enum or bit set per family of constants;
+  - a door per C function: out-params as results, arrays as slices,
+    messages as plain Odin values with `#[derive(Message)]`'s `kind`
+    rule.
+
+  The elements are written by hand: containers close at the end of their
+  `if` through `@(deferred_in)`. A C function the hand-written files do
+  not call gets a generated door, so the binding covers kui.h whole: 219
+  generated, 51 by hand, 2 skipped with their reason.
+  `examples/odin/tools/surface.odin` is `surface.c` through it, and calls
+  every door, and `examples/odin/tools/conformance.odin` rebuilds the
+  scene corpus through `Spec` and the doors, matching the reference report
+  byte for byte, as the Rust, Lua, C and Node adapters do.
+  `polyline` and `polygon` take points (`[][2]f32`), the count kui.h
+  means; a dash or a pivot is a fixed array in a `Maybe` (`[5]f32`,
+  `[2]f32`), so a short one cannot be written; and pixels are checked
+  against the size beside them.
+
+  It covers extensions both ways. An Odin host loads a plugin with
+  `ctx_add_extension` and `slot`. An Odin plugin is a shared library whose
+  seven `kui_ext_*` exports are one line each over `extension.odin`.
+  Built with `KUI_PLUGIN` on macOS and Linux, it links no kui and loads
+  into any host (on Windows it imports `kui_ffi.dll`, as a C plugin does):
+  `nu scripts/odin.nu slots` drives the Odin panel in the C and Rust
+  hosts and the C panel in the Odin host.
+
+  Run it with `nu scripts/odin.nu gen | test | slots | run counter`. It is
+  not published. CI's `check` installs a pinned Odin release (`ODIN_VERSION`)
+  and runs `gen --check`, `check`, `test` and `slots`, so a header or schema
+  change that was not regenerated goes red there. All four also run green
+  by hand on Windows x64 and Linux x64. On Windows the binding links
+  `kui_ffi.dll.lib`, odin.nu puts `kui_ffi.dll` beside the programs, and
+  `gen --check` reads a CRLF checkout as current.
+- `scripts/pack-ffi.nu`: libkui_ffi for every platform kui ships, dynamic
+  and static, with `kui.h`, rustc's `native-static-libs` as `link.txt`, a
+  tarball each and `SHA256SUMS`. It is for a C or Odin host that links a
+  library instead of building the workspace. The machine's own platform
+  is built natively. Linux x64 and arm64 (glibc 2.28) and Windows x64 are
+  built in a pinned Docker image, with cargo-zigbuild at the release
+  workflow's pins and with cargo-xwin. Windows also asks for
+  `--accept-msvc-license`, for the CRT and SDK xwin downloads. macOS is
+  built on a Mac only. A Windows pack carries windows-targets' import
+  libraries (`windows.0.53.0.lib`, `windows.0.52.0.lib`), which its
+  `link.txt` names and no SDK has, so a static link finds them. Every
+  leg has been run, and a C host linked against each x64 pack alone,
+  dynamically and statically, and run; the arm64 pack was read, with no
+  arm64 machine to run it on. `kui.h` ships with LF line ends from any
+  checkout.
+- `examples/rust/tools/schema-dump.rs`: the prop schema (props,
+  composites, elements, events, the verb table, the name lists) as JSON,
+  for a binding generated outside Rust.
+- The verb table (`schema::DOORS`) and `docs/props.md` have an Odin
+  column beside C's, each spelling held by the Odin generator both ways;
+  Node's `protocol()` carries it (`Door.odin`).
+
+### Fixed
+
+- **A dead key types its accent before a key it does not combine with**
+  (backlog RG127, from the Windows and Linux round after alpha.41). With
+  German, `^ space` typed a space where it types `^`, `´ space` a space
+  where it types `´`, and `^ z` a `z` where it types `^z` — on Windows
+  always, and under X11 with `imeOff` on; on US-International, where `'`
+  and `"` are dead, a quote could not be typed at all. winit composed it
+  right: the runner read a press's text off the logical key, which is
+  the key the accent fell back to, and Space's insert was a space
+  whatever the press carried. A press's text is now what the platform
+  composed, the layout's character where it composed nothing, and Space
+  inserts its own. `^ e` was right and is unchanged; with the input
+  method on, X11 composes through XIM as before.
+- The docs of F103 (alpha.41) said an animating Windows window behind
+  other windows skips its frames. It does not: DWM composes a covered
+  window, and it draws at the display's rate, 241 frames a second here,
+  as an uncovered one does; minimized, it asks for none (RG45). F103's
+  wait holds there only for an acquire that times out. `retry.rs` says so
+  now (backlog RG128).
+- **Text is read aloud on Windows and Linux** (backlog RG129, from the
+  regression and smoke round after RG127). Every static text — a line of
+  text, a list row's content, a drawn title — reached UI Automation with
+  an empty Name and AT-SPI with an empty name: AccessKit names a label by
+  its value, and kui set only its label. macOS read it all along.
+- **A disclosure or a select opens from Narrator** (RG130). UI
+  Automation gives a node with `expanded` its ExpandCollapse pattern in
+  place of Invoke, and its Expand and Collapse reached nothing. They are
+  the node's click.
+- **A text size or line height of 0 no longer ends the process** (RG136).
+  `lineHeight: 0`, `size: 0`, or a size under 0.4 (whose line height
+  rounds to 0) aborted a Node or Lua process — cosmic-text asserts a line
+  height is not 0 — and a negative one spun its layout; on an `edit`, a
+  `cells` and in `measureText` too. Every buffer is shaped at a pixel at
+  least. C's door had always read them as unset.
+- C: what kui.h says a door hands out lives as long as it says (RG131–
+  RG134). A second `kui_draw_data` in a frame freed the arrays the first
+  handed out; `kui_access_runs` freed the strings `kui_access_tree`
+  handed out; reading a menu row or asking for a copy freed a taken menu
+  action's text; and `kui_take_warnings` dropped what did not fit `cap`,
+  where kui.h says the rest wait.
+- A custom editor whose `caret` or `selection_anchor` falls inside a
+  character has an access tree (RG135): the run was sliced there and
+  panicked, which under C emptied the tree every frame; the position is
+  the character's start.
+- Node: `measureText` inside a `<devtoolsTab>` function child no longer
+  breaks the frame being encoded (RG137); a message, a `<select>` option
+  or a `menuBar` row holding a string cut through an emoji draws its lone
+  surrogate as U+FFFD rather than failing the frame, and `dir: null` is
+  absent like every other null prop (RG138, RG140).
+
+### Native verification
+
+The by-hand round alpha.6 introduced (backlog R4), on 2026-10-07, over
+the rounds after the alpha.41 tag — the Odin binding and `pack-ffi.nu`,
+RG127 and RG128 from the Windows and Linux round after alpha.41, and the
+regression and smoke round after RG127 (RG129–RG138) — with alpha.42's
+pre-tag pass over them on the Mac: the mechanical round, then four
+read-only reviews of the diff since alpha.41 (the Odin binding; the C
+doors and `pack-ffi.nu`; the runner's keys, the access bridge, the text
+floor and Node; the docs), each claim probed. They filed RG140–RG144,
+built before the tag (a `<select>` option or menu bar row cut through an
+emoji failing the Node frame, `kui_draw_data` while a frame built losing
+the finished frame's fragment draws, the Odin drains freeing the strings
+they returned, Odin's popups, unchecked slices and acronym kinds, a cell
+grid's infinite line height), and RG145, open.
+
+**macOS**, the pre-tag pass. fmt and clippy are clean; `cargo test
+--workspace --features kui-core/conformance`: **1856 tests over 139
+suites**. The C round passes, and so do the **57 scenes**, the Odin
+binding's `gen --check`, `check`, `test` and `slots`, Node's tests under
+`KUI_CONFORMANCE_REQUIRED=1` (**215 of 215**), `npm run gen` with no
+diff, the headless round and the book. The windowed round with Node's:
+**124 windows**. The AX audit: **106/106**. RG127's dead keys, which the
+Windows and Linux round could not reach on a Mac: twelve sequences typed
+into the `edit` example through `CGEventPostToPid` and read back through
+AX, each as AppKit composes it (`⌥e e` is `é`, `⌥e space` `´`, `⌥e z`
+`´z`). The bench guard against the alpha.41 tag: **green**, the guarded
+rows −1.2 to −0.3%, RG126's warm cell grid −0.4%.
+
+**Windows 11 x64 (MSVC) and Linux x64 (WSL Ubuntu 24.04), rustc
+1.99.0**, on the tree with the pre-tag fixes and `pack-ffi.nu`'s. fmt
+and `cargo clippy --workspace --all-targets --features
+kui-core/conformance -- -D warnings` are clean on both. `cargo test
+--workspace --features kui-core/conformance`: **1857 tests over 140
+suites** on Windows (5 ignored), **1853 over 139** on Linux (4
+ignored), **0 failed**. `cargo audit --deny warnings` is clean over
+`Cargo.lock`'s 444 crates. `pack-ffi.nu` ran every leg but macOS's: native
+on both, and linux-x64, linux-arm64 and win32-x64 (cargo-xwin) in its
+container. A C host linked against each x64 pack alone, dynamically and
+statically, ran; the arm64 pack was read, not run. It found three things,
+fixed before the tag (RG145): a CRLF `kui.h` from a CRLF checkout, the
+closing table lost off a terminal, and a `docker` that could not be
+spawned stopping the script. Earlier the same day, before the pre-tag
+fixes, the Odin binding's four steps passed on both, and the regression
+and smoke round after RG127 ran the windowed smoke and walked the
+accessibility tree through UI Automation and AT-SPI.
+
+## 0.1.0-alpha.41 (2026-10-07)
+
+**What breaks.**
+
+- A leaf that declares `tooltip` — `line`, `polygon`, `path`, `cells`,
+  `image`, `edit`, in any binding, or a Rust leaf whose spec says
+  `NodeSpec::tooltip` — draws its hint while hovered, where it drew
+  nothing; so does a C `kui_fragment*` node with `KuiSpec.tooltip`.
+- A `dash` gap the round-capped marks overlap closes: `dash = {2, 2}` at
+  a width of 8 draws a solid line where it drew 8 px dots every 4 px.
+- With a fallback list set, `Mono` text asks the app's fallback faces
+  before the machine's other monospaced ones, so a character may draw in
+  another face, and a single-weight monospaced face draws its bold
+  synthesized instead of in the platform's proportional face.
+- A cell grid whose family has no `M` draws its own glyphs where its face
+  puts them, no longer centred as a fallback's.
+- On a line past 4 KB, a tab after more than ~512 bytes with none moves
+  onto the line's tab stops, up to a tab's width, and the rest of the
+  line with it.
+- Rust: `schema::PropsOut` gains `ime_off` (under Added, F125), so a
+  struct literal of it needs the field or `..Default::default()`; so do
+  `conformance::Expect` and `conformance::Output`, behind the
+  `conformance` feature.
+- npm: `@qxuken/kui` bundles no darwin-x64 prebuild. On an Intel Mac (or
+  an x64 Node under Rosetta),
+  build the addon (`cargo build -p kui-node --release`) and point
+  `KUI_NODE_LIB` at it; the Rust crates are unchanged there.
+
+C stays at ABI 25 (`kui_set_ime_off` / `kui_ime_off_get` are new
+functions) and the Node wire at v21 (a root prop, no frame version).
+
+A leaf's hint is drawn now, and the four paint changes after it are each
+what the code always meant to draw: a hint the docs told you to put on a
+box around the leaf, a dotted line that was a lumpy solid one at a quad a
+dot, a fallback list that `Mono` text never asked, a grid's own glyphs
+treated as a stranger's, and a tab measured from where its chunk began
+instead of where the line did. Each moves pixels an app may have written
+to, so each is listed.
+
+### Added
+
+- **A window can take the keyboard as keys, with the input method off**
+  (backlog F125, from kawoosh's wish list). `ui.ime_off(true)` / a root
+  `imeOff` / `ime_off = true` / `kui_set_ime_off(ctx, true)` turns the
+  platform's input method off in the window: no composition and no
+  candidate window, and on a Mac no dead key waiting for the next and no
+  press-and-hold — which is an input method too, so a held `j` repeats
+  and a held `e` opens no accent picker, whatever the user's
+  `ApplePressAndHoldEnabled` says. A `key` event's `text` is still the
+  layout's character. What a modal editor's normal mode wants; its
+  insert mode stops declaring it and gets accents, dead keys and the IME
+  back. Frame state in `optionAsAlt`'s shape, default off; the runner
+  applies it on change through winit's `set_ime_allowed`, so winit's
+  `keyDown:` stops calling `interpretKeyEvents:`, where macOS composes. A
+  key pressed while it was off keeps it off until it comes up, so the
+  `i` that switches to insert mode, held, keeps typing `iiii` rather
+  than opening the picker over its own repeats; the next fresh press in
+  insert mode gets the picker. A composition open when it turns off is
+  dropped, and ends in the view as an empty `preedit` — as one does now
+  when the user switches input source mid-composition, which used to
+  leave the preedit drawn. On Windows and Linux the window's IME is
+  disabled the same way, and only that: a dead key there is the
+  layout's, which winit composes whatever the IME says, and it still
+  composes. `Ctx.imeOff()` / `kui_ime_off_get` read the ask
+  back; `modal_editor` declares it in normal mode. *What you can
+  delete:* the README line telling a Mac user of a modal editor to run
+  `defaults write -g ApplePressAndHoldEnabled -bool false`, and any
+  per-mode IME switching an app did by hand.
+
+### Changed
+
+- **Intel Macs lose their Node prebuild.** The package ships the addon
+  for linux-x64, linux-arm64, darwin-arm64 and win32-x64; the release
+  workflow's darwin-x64 leg and `release-local.nu`'s are gone. On an
+  Intel Mac `require('@qxuken/kui')` fails with the loader's not-found
+  error, which now says the prebuild was dropped and how to build one.
+  `kui-native`, `kui-ffi` and the rest still build and run there; only
+  the bundled `.node` is gone.
+
+### Fixed
+
+- **A leaf draws its tooltip** (backlog RG113). The hint floats as its
+  node's last child, and a leaf has none, so a hovered wedge, path, line,
+  grid, image or editor with a `tooltip` showed nothing — it was tracked
+  and spoken, not drawn. It now floats beside the leaf, anchored to it
+  (`FloatAnchor::Node`), and lands below the leaf's box as a box's hint
+  lands below the box: outside every clip, outside layout, flipped above
+  near the window's bottom, and only while the pointer is on the stroke
+  or inside the outline. In all four bindings — `NodeSpec::tooltip`, the
+  JSX and Lua prop, `KuiSpec.tooltip` on C's leaf doors. A float anchored
+  to a node now honours `fit` as a parent-anchored one does. On a leaf
+  the drawn string is its description, so a leaf that declares a
+  `description` after its `tooltip` draws that.
+- **An animating window whose surface skips its frames waits between
+  tries** (backlog F103). A skipped frame returns at once, with no
+  drawable to wait for and no vsync behind it, so where the platform
+  never says a window is covered — Windows behind other windows, Wayland,
+  an acquire that times out — an animation asked for its next frame on
+  the loop's very next turn: 82,000 views a second at a core, measured on
+  a Mac with every frame forced to skip and no display link. It waits a
+  retry (16 ms) after a skip now — 60 a second at 2% — and runs at the
+  display's rate again from the first frame that lands. A window macOS
+  calls covered still asks for nothing at all. On Windows the timer that
+  keeps an animation going through a title-bar drag paces the same tries
+  at its own interval, 10 to 16 ms.
+- **A tab on a long line stops where the line's stops are** (backlog
+  RG76). On a line past 4 KB, a tab that followed more than half a chunk
+  without one measured from its chunk's start. Such a chunk now ends
+  after that tab, and the line gives the tab the advance that reaches its
+  next stop — exact once the text since the previous tab has been on
+  screen, and as near as the rest of the line's estimate before that.
+  Wrapped rows carry the same advance.
+- **`measure_text` leaves a drawn text's rows alone** (backlog RG76).
+  Measuring, between frames, a text a node drew at another width
+  re-wrapped the run they share, so that node's `caret_rect` and
+  `text_hit` answered from the measured rows until the next frame wrapped
+  it back. The measure lays out a copy at its own width, kept for the
+  next measure there.
+- **`Mono` text asks the app's fallback fonts straight after its own
+  face** (backlog RG118). cosmic-text's generic monospace family walks
+  every installed monospaced face that has the character before the
+  lists `set_fallback_fonts` joins — on a Mac, Hebrew in `Mono` came out
+  in Courier New *Italic* with Arial named. While a list is set, `Mono`
+  is shaped as the face it is pinned to, by name, so the order is that
+  face, the app's names, then the platform's. With no list nothing
+  changes.
+- **A grid tells its family's glyphs by the family's name** (backlog
+  RG118). It read the family's face off the face `M` shaped with, and a
+  symbols-only or CJK-only family has no `M`, so its own glyphs were
+  taken for a fallback's — centred, and asked of a monospaced face first.
+- **A new fallback list or a font rescan draws every window of the
+  session** (backlog RG118). `set_fallback_fonts` and
+  `reload_system_fonts` asked for a frame of the window they were called
+  through alone; another window shaped again whenever something else drew
+  it. Each window that has drawn now owes a frame (`animating()`) while
+  the session's fonts are newer than the text it shaped.
+- **Dash dots that overlap make one mark** (backlog RG118). A gap no
+  wider than the stroke is closed by the round caps either side of it,
+  and `{2, 2}` at a width of 8 was 8 px dots every 4 px — a solid line
+  drawn lumpy, at a quad a dot. Such a gap now closes and the marks
+  either side are one mark; a pattern with no gap left draws solid. A
+  pattern whose gaps show draws exactly as before.
+- **A long line's placed tab answers the caret and the click where it
+  is drawn** (backlog RG122, from the pre-tag pass). A line ending in such
+  a tab has its end caret, and a selection's end, at the line's width —
+  it fell short of the width in a monospaced face and past it in a
+  proportional one, and wrapped rows used the chunk's own narrower tab —
+  and a click answers the tab before the middle of the drawn tab and the
+  byte after it from there, where both halves answered the byte after.
+- **A pinned `Mono` keeps to its face at every weight, and follows the
+  fonts the app loads and removes** (backlog RG123, from the pre-tag
+  pass). A single-weight monospaced face was passed over for bold and set
+  in the platform's proportional face; it now draws in itself, with bold
+  synthesized. A pinned family whose only face the app removed left
+  `Mono` naming nothing, and one loaded after the list was set was never
+  pinned; both now move the pin, and every window shapes again.
+- **A C fragment draws its tooltip** (backlog RG124, from the pre-tag
+  pass). The four `kui_fragment*` doors tracked and spoke
+  `KuiSpec.tooltip` and floated nothing, where JSX and Lua drew it.
+- The docs of a `gradient` stop whose `$token` misses say what it does:
+  `unknown-token` is raised and the stop is left out, so a gradient left
+  with fewer than two stops draws nothing over its `bg` — no error, and
+  no fade nobody wrote. ADR 0042's amendment says why it stays (backlog
+  RG118).
+
+**What you can delete.** A box wrapped around a `line`, `polygon` or
+`path` only to carry its `tooltip`; a pattern stretched by hand so a
+thick stroke's dots would not touch; a second `set_fallback_fonts` (or a
+redraw) sent through every other window of the session.
+
+### Native verification
+
+The by-hand round alpha.6 introduced (backlog R4), on 2026-10-07, over
+the rounds after the alpha.40 tag — `imeOff` (F125), F103's skipped
+half, RG76, RG113 and RG118, and the darwin-x64 prebuild dropped — with
+a regression pass over them first: the mechanical round, then three
+read-only reviews in worktrees (text and fonts; core paint, layout and
+bindings; the runner, the release machinery and the docs), each claim
+probed with a test before anything changed. They filed five: RG122–RG125,
+built before the tag (a long line's placed tab answering the caret and
+the click where its run had it, a pinned `Mono` asked at weights its face
+lacks and not re-pinned when the app's fonts move, a C fragment's
+tooltip never drawn, and `imeOff`'s docs promising no dead keys on
+Windows and Linux, where winit composes them whatever the IME says), and
+RG126, open: `cells_200x50_warm`, unguarded, 3 to 5% slower, bisected to
+the grid's family-by-name check and not yet explained. F103 itself was
+measured in a window first: on macOS a hidden animating window already
+built nothing, and with every frame forced to skip and no display link
+the probe went from 82,000 frames a second at a core to 60 at 2%. This
+round ran on the Mac alone; Windows and Linux did not run it for this
+tag, so F125's `set_ime_allowed` there and F103 under Windows' drag
+timer are by reading.
+
+**macOS 27.0.1 on an M3 Pro MacBook Pro, rustc 1.99.0 (the toolchain
+CI runs), Node 26.10.0, nu 0.116.1**, on the release commit's tree.
+`cargo fmt --all --check` and `cargo clippy --workspace --all-targets
+--features kui-core/conformance -- -D warnings` are clean, and so is
+`cargo audit --deny warnings`. `cargo test --workspace --features
+kui-core/conformance`: **1844 tests over 138 suites, 0 failed** (4
+ignored). The C round, `cbuild --run`, passes its five checks; the
+corpus passes its **57 scenes** in four adapters, the `path` scene now
+resting on a tooltip wedge; the ABI is **25**. Node's `node --test
+test.mjs` under `KUI_CONFORMANCE_REQUIRED=1`: **212 of 212**. `npm run
+gen` leaves no diff, the examples typecheck and their lockfile installs,
+the headless round passes all **35 drives**, the book builds and
+`scripts/book-examples.nu --check` passes.
+
+**The windowed round**, `smoke -- --node`, twice — before the fixes and
+on the release tree: **51 Rust examples and the eleven Node examples,
+each on both bases, 120 frames each, every one exiting 0** — 124
+windows, eight at a time, in 34.2 and 52.3 s, the second beside another
+session's builds — and `counter`, `host`, `c_panel` and `lua_panel` by
+hand under `KUI_SMOKE_FRAMES=120`, each exiting 0 with nothing on
+stderr: **128 windows over five hosts.** `target/debug/examples` was
+pruned first (12,280 files), the alpha.36 trap. The AX audit:
+**106/106** on both trees, the audited window raised to the front by its
+pid first, and no warning on the fixture's stderr.
+
+**The bench guard** against the alpha.40 tag: **green**, none of the 8
+guarded rows more than 10% slower — every one between −1.0% and +0.6%
+(the worst guarded run-to-run spread 2.8%), `frame_10k_segments` +0.3%
+with RG118's dash — beside other processes using ~500% CPU, so the
+medians are not the README's and its table is kept as it was. Of the
+unguarded rows the frame bench's moved by at most +1.7%; the `cells`
+bench's `warm` row read +6.0% (±1.4%) against the tag, +3.8% against
+alpha.40 with F125 merged, and is RG126.
+
 ## 0.1.0-alpha.40 (2026-10-07)
 
 **What breaks.**

package/README.md

@@ -24,9 +24,10 @@ absent. Ranges do not pin a prerelease — `^0.1.0-alpha.8` and `~0.1.0-alpha.8`
 both admit every later alpha of the same `0.1.0` — so an app that wants the
 version it tested writes that version exactly and commits its lockfile.
 
-The tarball bundles the native addon for linux-x64, linux-arm64, darwin-arm64,
-darwin-x64 and win32-x64 under `prebuilds/`; `native.cjs` picks the one matching
-`process.platform`-`process.arch`. On any other platform build it from the
+The tarball bundles the native addon for linux-x64, linux-arm64, darwin-arm64
+and win32-x64 under `prebuilds/`; `native.cjs` picks the one matching
+`process.platform`-`process.arch`. On any other platform — an Intel Mac
+among them, since 0.1.0-alpha.41 — build it from the
 repo (`cargo build -p kui-node --release`) and set `KUI_NODE_LIB` to the
 resulting library.
 

package/docs/adr/0010-a-segment-primitive.md

@@ -456,6 +456,16 @@ and with a round cap its `4 4` at a width of 4 is a solid line, which
 is the first thing anyone writes. The first mark's cap sits where the
 solid stroke's would.
 
+**A gap the dots overlap closes** (2026-10-07, backlog RG118). A dot is
+as wide as the stroke whatever its mark says, in the same period, so
+where a mark and its gap together come to no more than the width the
+dots meet: as first built, `{2, 2}` at a width of 8 was 8 px dots every
+4 px, a lumpy solid line at a quad a dot. Clamping the dot to its mark
+cannot be drawn, and growing the period to keep the gap moves every
+dotted line whose dots do not touch. So the gap closes and the marks
+either side of it are one (`Dash::cut`); a pattern with no gap left is
+solid. A gap that is seen is untouched.
+
 **The same pattern on a `path`.** A path's stroke is a mask
 ([ADR 0040](0040-a-path-is-a-mask-in-the-atlas.md), whose decision 3
 left `dash` to V2), so the centre lengths go to the rasterizer and the

package/docs/adr/0042-a-gradient-is-an-image-the-core-paints.md

@@ -318,9 +318,21 @@ options*, and decisions 1–4 and 6–11 stand as written.
   nobody spells, an unknown field, fewer than two stops in the list or
   a number that is not one is an error from `gradient::parse_with`,
   with the field named. What still draws nothing in silence is a
-  gradient that *parsed* and has nothing to paint — every stop a token
-  that missed (each raised as `unknown-token`), or one built in Rust or
-  C with one stop or a NaN. No warning code was added.
+  gradient that *parsed* and has nothing to paint — fewer than two
+  stops left once those whose token missed are taken out (each raised
+  as `unknown-token`), or one built in Rust or C with one stop or a
+  NaN. No warning code was added.
+
+  *Weighed again (2026-10-07, backlog RG118).* The count is of the
+  list, so `[$peach, $peech]` parses and draws nothing. A missed stop
+  could instead keep its place painted transparent, so the gradient
+  still draws; it stays left out. A missed token leaves any other slot
+  as if it were not declared (a `bg`, a keyframe's stop, an
+  entrance), and a stand-in here would paint a colour nobody wrote — a
+  fade to nothing that reads as intended, where a box with no gradient
+  over its `bg` reads as the mistake it is beside the `unknown-token`
+  that names it. Tokens have no fallback of their own to paint instead.
+  The docs of the row say so.
 - **The atlas holds straight alpha** (open question 1). An `Image`
   quad's shader multiplies the texel's rgb by the tint and its alpha by
   the coverage separately, so the texels are straight. The raster mixes

package/encoder.js

@@ -395,14 +395,15 @@ export function createEncoder(P) {
   // protocol kind (no names or shapes hardcoded here); only composites (the
   // pad family, border, overflow bits, float) and the constructor-ordering
   // specials (dir, size) have hand-written stanzas, mirroring binary.rs.
-  // `key` rides along as P_KEY; `isRoot` admits `title`, `alwaysOnTop`, `secureInput`, `optionAsAlt` and `windows` (and drops `key`);
+  // `key` rides along as P_KEY; `isRoot` admits `title`, `alwaysOnTop`, `secureInput`, `optionAsAlt`, `imeOff` and `windows` (and drops `key`);
   // `admit`, when given, is the only names written (a closed composite's
   // rows — the rest were already reported by checkProps).
   function props(p, key, isRoot, admit) {
     const np = fi++;
     let n = 0;
     // dir and size first: the decoder constructs spec/style from them.
-    if (p.dir !== undefined && p.dir !== 'column') {
+    // `!= null`: a null dir is absent, as every other null prop is.
+    if (p.dir != null && p.dir !== 'column') {
       // `table` is a column whose rows' cells line up (ADR 0033).
       const dir = p.dir === 'row' ? 1 : p.dir === 'table' ? 2 : undefined;
       if (dir === undefined) throw new Error(`bad dir ${JSON.stringify(p.dir)} (row | column | table)`);
@@ -527,6 +528,13 @@ export function createEncoder(P) {
             n++;
           }
           break;
+        case 'imeOff':
+          // And again (backlog F125).
+          if (isRoot && v) {
+            f[fi++] = PR.imeOff.id;
+            n++;
+          }
+          break;
         case 'optionAsAlt': {
           // Root only; a side by its number, `OptionAsAlt::index` (backlog
           // F113). "none" is the default and writes nothing, as `false`

package/howto.md

@@ -61,7 +61,9 @@ a nine-point curve over ~50 px spans is ~60 quads.
 marks with 4 px gaps, `dash={4}` the same length for both, and four
 lengths are a dash-dot. The lengths are what you see — every mark has the
 stroke's round caps — so a mark no longer than the stroke is wide is a
-dot: `width={3} dash={[3, 5]}` is a dotted line. The pattern runs along
+dot: `width={3} dash={[3, 5]}` is a dotted line. A dot is as wide as the
+stroke, so a gap the dots overlap closes: `width={8} dash={[2, 2]}` is a
+solid line. The pattern runs along
 the whole stroke, round corners and along a `curve`. For marching ants,
 grow `dashOffset` from a tick; the marks move towards the first point.
 A dashed line costs a quad per mark, and is still hit in its gaps.
@@ -305,7 +307,9 @@ text's own family has no glyph for goes to the first of them that has
 it, and only then to the platform's list — whose first choice on macOS
 is the system's interface face, so Cyrillic in a Latin-only monospaced
 family comes out proportional. The list is the session's, for every
-family and every kind of text; `[]` is the platform's alone. Set it
+family and every kind of text; `[]` is the platform's alone. `mono`
+text asks it straight after its own face, ahead of the machine's other
+monospaced faces, which it walks first when there is no list. Set it
 when the choice changes, not every frame with a new list: a new list
 shapes every text again (the same one twice costs nothing). A cell grid
 goes one step further by itself: with no fallback of yours that has the
@@ -1134,20 +1138,40 @@ macOS's press-and-hold: holding a letter offers its accents (`e` → `é è
 ê`) instead of repeating it, and a letter with no accents does nothing
 at all — on by default, and off only on a machine whose owner turned it
 off, which is why it works on one Mac and not the next. Every other
-platform repeats. It is the **user's setting, not the app's**: the read
-that decides is HIToolbox's, of the user's global preference by name,
-and no per-process default reaches it — not the argument domain, not a
-registered default, not the app's own domain (F69 built a door that
-pinned one; RG15 found it inert and RG16 removed it — the backlog
-archive has the measurements). What works is
+platform repeats. The setting is the user's — the read that decides is
+HIToolbox's, of the user's global preference by name, and no
+per-process default reaches it (F69 built a door that pinned one; RG15
+found it inert and RG16 removed it — the backlog archive has the
+measurements) — but press-and-hold is an *input method*, and a window
+can take the keyboard with its input method off. Declare `imeOff` on the
+root while your keys are commands (Rust `ui.ime_off(true)`, Lua
+`ime_off = true` on the root table, C `kui_set_ime_off(ctx, true)`):
+
+```rust
+// Normal mode is a keymap; insert mode types text.
+ui.ime_off(self.mode == Mode::Normal);
+```
+
+A held `j` then repeats, a held `e` opens nothing, and an IME left on
+no longer eats the keymap — nor, on a Mac, a dead key; each key still
+carries the layout's character as its `text`. On Windows and Linux a
+dead key is the layout's and still composes: winit composes it whatever
+the IME says. Stop declaring it and insert mode has
+accents, dead keys and the IME back. A key held across the switch — the
+`i` that enters insert mode — keeps repeating until it comes up, so the
+picker comes from the next fresh press. It is frame state: declare it on
+every frame the mode wants it.
+
+The user can still turn press-and-hold off for every app:
 
 ```
 defaults write -g ApplePressAndHoldEnabled -bool false
 ```
 
-and a relaunch — what the owner of a modal editor, where `j` held is a
-motion, has usually done already. An app whose keys are commands can say
-so in its README; kui has nothing to offer it beyond that.
+and a relaunch.
+
+[`imeOff`](props.md#composite-props-hand-written-per-binding) ·
+[`examples/rust/apps/modal_editor.rs`](../examples/rust/apps/modal_editor.rs)
 
 ### How do I tell the keypad from the main keys, or hear a lone Shift?
 
@@ -1420,8 +1444,10 @@ them sharing an edge show a hairline of the background through it.
 `gradient` on the box: `gradient={{ to: 'bottom', stops: ['#1e2030',
 '#14161e'] }}` runs to a side or a corner, `{ angle: 0.125, stops }` along
 a direction in turns clockwise from east, and `{ radial: true, at: [0.5,
-0], stops }` out from a centre. A stop is a colour or `[colour, position]`.
-It paints over `bg` and under the border and the children, so a scrim is
+0], stops }` out from a centre. A stop is a colour or `[colour, position]`,
+the colour a `$token` too; a token that misses is raised as
+`unknown-token` and its stop left out, so a two-stop gradient with a
+typo draws nothing over its `bg`. It paints over `bg` and under the border and the children, so a scrim is
 a gradient with a transparent stop over whatever is beneath. The geometry
 is the box's unit square stretched to the box — a corner is CSS's corner,
 and an `angle` runs corner to corner at an eighth of a turn whatever the

package/index.d.ts

@@ -1890,6 +1890,8 @@ export type DoorCell = { is: string } | { as: string } | { no: string };
 export interface Door {
   rust: string;
   c: DoorCell;
+  /** The Odin binding's (packages/odin), pinned by its generator. */
+  odin: DoorCell;
   node: DoorCell;
   lua: DoorCell;
   doc: string;
@@ -2401,6 +2403,14 @@ export declare class Ctx {
    * so a test can assert on it.
    */
   optionAsAlt(): 'none' | 'left' | 'right' | 'both'
+  /**
+   * Whether the last frame asked for the platform's input method off
+   * in its window (a root `<box imeOff>`) — no composition, and on a
+   * Mac no dead keys and no press-and-hold; false when it did not.
+   * `runWindowed` applies it to the window on change; a bare `Ctx`
+   * hands the ask back so a test can assert on it.
+   */
+  imeOff(): boolean
   /**
    * A headless context is one window, the main: this answers whether
    * `window` names it (`"main"`, `0`, or left out) and addresses
@@ -2471,8 +2481,10 @@ export declare class Ctx {
    * — whose first choice on macOS is the system's proportional
    * face. Ids from `addFont` / `addSystemFont` / `loadFontFile`;
    * one that names no font is left out, and `[]` is the
-   * platform's list alone. A new list shapes every text again;
-   * the same list twice is nothing.
+   * platform's list alone. `mono` text asks them straight after
+   * its own face, ahead of the machine's other monospaced faces.
+   * A new list shapes every text again; the same list twice is
+   * nothing.
    */
   setFallbackFonts(ids: Array<string>): void
   removeFont(id: string): void
@@ -3653,8 +3665,10 @@ export declare class KuiWindow {
    * — whose first choice on macOS is the system's proportional
    * face. Ids from `addFont` / `addSystemFont` / `loadFontFile`;
    * one that names no font is left out, and `[]` is the
-   * platform's list alone. A new list shapes every text again;
-   * the same list twice is nothing.
+   * platform's list alone. `mono` text asks them straight after
+   * its own face, ahead of the machine's other monospaced faces.
+   * A new list shapes every text again; the same list twice is
+   * nothing.
    */
   setFallbackFonts(ids: Array<string>): void
   removeFont(id: string): void