@qxuken/kui 0.1.0-alpha.36 → 0.1.0-alpha.38

package/CHANGELOG.md

@@ -21,6 +21,358 @@ 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.38 (2026-10-05)
+
+**What breaks.**
+
+- C: `KuiSpec` gains `scroll_mods` at its end (64-bit size 704), so
+  `KUI_ABI_VERSION` is 25; recompile. A zeroed spec is what it was.
+- Rust: `event::Scroll` gains a `mods` field and `EventSpec` a
+  `scroll_mods` one (under Added), so a struct literal of either needs
+  them.
+
+The Node wire stays v21: `scrollMods` is one more string row.
+
+### Added
+
+- **An `onScroll` node can be for a modified wheel** (backlog F122,
+  from kawoosh). `scrollMods` — `"ctrl super"`, any of `shift`, `ctrl`,
+  `alt`, `super`; Rust `NodeSpec::scroll_mods(KeyMods)`, C
+  `KuiSpec.scroll_mods` in `KUI_KMOD_*` bits, Lua `scroll_mods` — and
+  the node hears only a scroll gesture that began with one of them
+  held, and hears it first: ahead of every scroll container and every
+  `onScroll` that names none, wherever under the pointer the gesture
+  began, the innermost such node winning. A Ctrl-wheel zoom declared
+  on the window's root is heard over a list, and the list does not
+  scroll; a canvas inside can name the same key and take it for
+  itself. A wheel with none of them held passes the node by — and
+  scrolls it, if it is a scroll container too: a list can name a key
+  for its own zoom and scroll for every other wheel (backlog RG119,
+  from this release's pre-tag pass; as merged, such a list stood still
+  for a plain wheel). Its
+  `scroll` events carry `mods` (`Scroll::mods`), the modifiers held
+  when the gesture began: a gesture stays what it began as to the end
+  of its glide, whatever is let go or pressed meanwhile.
+
+**What you can delete.** An `onScroll` handler that read the modifiers
+to tell a zoom from a scroll, and the scroll it then had to do itself
+for the plain wheel — and the knowledge that it only ever worked over
+that handler's own node, every scroll container inside it taking the
+same wheel first.
+
+### Fixed
+
+- **`scripts/npm-approve.nu` no longer fails a release it has just
+  made.** Approving alpha.37 went through, and the script then waited
+  a minute for `npm view` to list the version, gave up with "approved,
+  but npmjs does not list it yet; run this again", and on the second
+  run — no stage left, the cached packument still without the
+  version — said nothing was staged and asked whether the release
+  workflow had run. `latest` was set by hand. What is live is now read
+  off the dist-tags, which a version takes the moment it is approved,
+  and `latest` follows the approval at once. A release script, so
+  nothing an app sees.
+
+**What you can delete.** Nothing.
+
+### Native verification
+
+The by-hand round alpha.6 introduced (backlog R4), on 2026-10-05 — the
+two commits after the alpha.37 tag: `scrollMods` (F122) and the
+approval script — with a regression pass over them first: the diff
+read whole, each claim probed with a test before anything changed.
+RG119 came of it and is in this release. Before any of it the last
+`check` on main was read on both hosts, green at `3d4fff6` — the step
+alpha.37's first tag went without. This round ran on the Mac alone;
+Windows and Linux did not run it for this tag.
+
+**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.0**, on the release commit's tree,
+the workspace's own artifacts pruned and rebuilt. `cargo fmt --all
+--check` and `cargo clippy --workspace --all-targets -- -D warnings`
+are clean. `scripts/test.nu`, the workspace's tests with the
+conformance feature: **1808 tests over 136 suites, 0 failed** (4
+ignored). The C round, `cbuild --run`, passes its five checks; the
+corpus passes its **57 scenes** in four adapters, `scroll-gestures`
+now holding a Ctrl-wheel over a contained list at its limit; the ABI
+is **25**. Node's `node --test test.mjs` under
+`KUI_CONFORMANCE_REQUIRED=1`: **210 of 210**. `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 over: **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 and
+35 s — 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.** The AX audit: **106/106**, the audited
+window raised to the front by its pid first, and no warning on the
+fixture's stderr. `scrollMods` itself was not driven in a window in
+this round: it was tried in kawoosh's before the merge, and RG119's
+case is pinned in the core's tests alone.
+
+**The bench guard** against the alpha.37 tag, on the release commit's
+tree: **green**, none of the 8 guarded rows more than 10% slower —
+every one between −4.1% and +0.6% (the worst guarded run-to-run spread
+4.3%), and no row of the run more than 5% slower. `README.md`'s table
+is kept as it was.
+
+## 0.1.0-alpha.37 (2026-10-05)
+
+**What breaks.**
+
+- Rust: `HitShape::Path` gains a `stroke` field and `Content` a
+  `PathFlat` variant (under Fixed), so a pattern over either needs
+  them; `HitShapes::path` takes the stroke's width after the rule.
+- A `path` with a stroke over a fill is hit out to the stroke's edge,
+  where the half of the stroke outside the outline fell through; and a
+  stroked path with no `bg` but a `hover_bg`, `pressed_bg` or
+  `focus_bg` is hit inside, where it was hit along its stroke only
+  (under Fixed).
+- Lua: `path { ops = }` whose numbers are not the flat form draws
+  nothing with a `path-malformed` warning, where it was an error that
+  failed the view (under Fixed).
+- A `path` that animated and then held still for 120 frames draws from
+  the atlas again — a `GlyphMask` quad where it stayed a `Texture`
+  (under Fixed). Nothing an app sees; a host that counts quads by kind
+  does.
+- C: `kui_polyline`, `kui_path` and `kui_path_d` take a `dash` before
+  `spec` — five floats, or NULL for the solid stroke they drew (under
+  Added). `KUI_ABI_VERSION` is 24; pass NULL and recompile. The same
+  step appends `gradient` to `KuiSpec` (64-bit size 696).
+- Rust: `schema::Kind`, `Apply` and `Parsed` gain a `Gradient` variant
+  and `InteractSpec` a `gradient` field (under Added).
+- Rust: `Stroke` gains a `dash` field, so a struct literal needs it
+  (`Stroke::new` does not); `path::MaskPaint` gains `Dashed`.
+- A cell grid's glyph for a character its family lacks is drawn from a
+  monospaced face where one has it, in the middle of its cell, and no
+  wider than it (F120, under Fixed), where it was the platform's first
+  fallback at its own width from the cell's left edge.
+- Rust: `Tree` gains an `any_gradient` field.
+
+The Node wire moves to v21 for the dash's five floats on a line and a
+path, which an encoder and addon of one release never see apart.
+
+### Added
+
+- **`gradient` on a box, in every binding**
+  ([ADR 0042](docs/adr/0042-a-gradient-is-an-image-the-core-paints.md),
+  which supersedes ADR 0005's "no gradients"): `gradient={{ to:
+  'bottom', stops: ['#1e2030', '#14161e'] }}`, `{ angle: 0.125, stops }`
+  in turns clockwise from east, `{ radial: true, at: [0.5, 0], stops }`;
+  the same table in Lua; `NodeSpec::gradient(Gradient::to(Side::Bottom,
+  [...]))` with `Gradient::angle` and `Gradient::radial_at`; and a
+  `const KuiGradient *` on `KuiSpec`. A stop is a colour — a `$token`
+  too — or a colour and a position.
+  - **Over `bg`, under the border and the children.** `bg` stays a
+    colour and keeps its tweens, tokens and state backgrounds; a
+    transparent stop shows it through.
+  - **An image the core paints.** Each distinct gradient is rasterized
+    once into the glyph atlas — a 256-texel strip along an axis, a
+    128-texel square otherwise, each with a gutter of the gradient
+    carried a texel past its edges, since a stretched quad samples
+    there — and drawn as one `Image` quad, so no
+    renderer changes and a host that draws an image draws a gradient.
+    The key is the gradient and not the box: a resize, another scale
+    and a thousand boxes sharing one rasterize nothing.
+  - **On the box's unit square.** A side or a corner is CSS's; any
+    other `angle` runs corner to corner at an eighth of a turn at any
+    aspect, where CSS's pixel-measured `45deg` does not. Stops mix in
+    straight sRGB with the alpha premultiplied.
+  - **What it does not do.** It does not tween and the state
+    backgrounds do not replace it; a hard stop is as soft as the raster
+    stretched (a 256th of the box along a strip); there is no conic
+    one, and none on a `path`, a `line`, a border or a text. Those, and
+    anything animated, stay a `fragment`'s.
+  - Measured (the ADR's *Measured*): a linear gradient is within half
+    an 8-bit level of the mix computed per pixel at every pixel of the
+    box, a radial within 1.2; a gradient box costs about 52 ns over a
+    flat one, half of it what any `hoverBg` pays; a raster is 4 µs for
+    a strip and 25 to 42 for a square.
+  - The corpus gains a `gradients` scene; `examples/rust/apps/loaders.rs`
+    gains a rainbow — one gradient two tracks long slid under a clip,
+    one strip in the atlas for good.
+
+- **`dash` on a `line` and on a `path`'s stroke, in every binding**
+  (backlog V2, the amendment in
+  [ADR 0010](docs/adr/0010-a-segment-primitive.md)): `<line dash={[6, 4]}
+  dashOffset/>`, `line { dash = {6, 4}, dash_offset = }`,
+  `Stroke::new(w, c).dash(6.0, 4.0).dash_offset(n)` (`Dash::of` for a
+  pattern read from data), and a `const float *dash` on `kui_polyline`,
+  `kui_path` and `kui_path_d`. One length is marks and gaps alike, two
+  are a mark and a gap, four a dash-dot.
+  - **The lengths are the ones seen.** Every mark is a short stroke
+    with the stroke's own round caps, so `6, 4` is 6 px of ink and 4 px
+    of nothing at any width and a mark no longer than the stroke is
+    wide is a dot. SVG's `stroke-dasharray` measures the centre line,
+    which with round caps makes `4 4` at a width of 4 a solid line;
+    this pattern is SVG's `mark − width, gap + width`.
+  - **The pattern keeps its phase** along the whole stroke — round the
+    corners of a polyline and across the pieces of a curve, which is
+    what ADR 0010 would not ship without — and restarts at each subpath
+    of a `path`, as SVG's does. `dashOffset` starts that far into it;
+    growing it moves the marks towards the first point, a marquee's
+    marching ants. Neither tweens.
+  - **No renderer changes.** A dashed line is one `Segment` quad per
+    mark per piece the mark lies on, cut in the core, so a host that
+    draws a stroke draws a dashed one; a dashed path stroke is cut by
+    the rasterizer into the mask it already was. A path whose offset
+    changes every frame is a shape that changes every frame, and
+    leaves the atlas for a texture of its own while it marches.
+  - A pattern with no gap, a mark and gap under a physical pixel
+    together, or more than 16384 marks draws solid. A dashed stroke is
+    hit along its whole length, gaps included.
+  - The corpus's `lines` and `paths` scenes carry one each, so the
+    segment count pins the cut in four bindings;
+    `examples/rust/widgets/line.rs` hangs its planned cards off dashed
+    links that march under the pointer.
+
+- **The fallback fonts are the app's to name** (backlog F121, from
+  kawoosh). `Core::set_fallback_fonts(&[FontId])` — C
+  `kui_font_set_fallback`, Node `ctx.setFallbackFonts(ids)` — lists the
+  fonts asked, in order, for a character the text's own family has no
+  glyph for, before the platform's list, whose first choice on macOS is
+  the system's proportional face. For every text in the session — an
+  editor already open and a cell grid too — and kept across
+  `reload_system_fonts`; an empty list is the platform's alone.
+  `Core::fallback_fonts` reads the families back.
+
+### Fixed
+
+- **A cell grid's fallback glyph stays in its cell** (backlog F120, from
+  kawoosh: Russian text in a terminal whose family has no Cyrillic, `Ю`
+  drawn across the letter after it). A character the grid's family has
+  no glyph for is asked of a monospaced face before the platform's
+  fallback list — on macOS that list opens with the system's
+  proportional face; a glyph still wider than its cells, two under
+  `wide`, is shaped at the size it fits at; and the room a narrower one
+  leaves is shared either side. The family's own glyphs and the private
+  use area's icons draw as they did.
+
+- **What the `path` reviews left** (backlog RG112, the second review in
+  [ADR 0040](docs/adr/0040-a-path-is-a-mask-in-the-atlas.md)):
+  - A window closed while it showed an animating or a big path left the
+    path's texture with the renderer for the life of the process; the
+    core now hands it to the session as it goes, and the next frame any
+    window draws drops it. A frame built and never read keeps its
+    `dropped_textures` and `dropped_fragments` for the next one.
+  - A path that stopped moving stops costing a texture and a draw of
+    its own: after 120 still frames its mask is the atlas's again. A
+    row of icons keyed by position, whose neighbours came and went
+    twice within eight frames, read as animating and stayed so for
+    good.
+  - A stroke over a fill is hit as far as it is painted
+    (`HitShape::Path`'s `stroke`).
+  - Ops that are not the flat form raise `path-malformed` under the
+    node's key in every binding (`Core::path_flat_node`,
+    `Content::PathFlat`); C and Node drew nothing in silence.
+  - JSX types `width` on `line` and `path` as a number or a `$length`,
+    as the encoder reads it; `Core::image_pixels` answers for the
+    handle a path's `Texture` quad names.
+
+- **What this release's own pre-tag pass found** (backlog RG114–RG117;
+  RG118 holds what it read and left), none of it in a release before
+  this one:
+  - An editor open when `set_fallback_fonts` was called kept the faces
+    its lines were shaped in until they were edited (RG114).
+  - The root's `gradient` was dropped while the devtools panel was
+    docked (RG115).
+  - A dashed `line` whose points coincide drew nothing and was still
+    hit; it is the dot its solid one is (RG116).
+  - A gradient's `radial` that is not a boolean is an error, where it
+    read as linear; its row says that fewer than two stops fail the
+    view in JSX and Lua and draw nothing in Rust and C; `kui.h` says
+    what a zeroed `KuiGradient` is (RG117).
+
+**What you can delete.** A family chosen only because it covers a
+script the preferred one lacks, which can give way to the preferred
+one with the fallback list named; the key an app gave a still icon only so a
+neighbour's coming and going would not move it to a texture; the
+invisible wider path laid under a thick-stroked one to catch the press
+on its edge; the WGSL a card's two-colour fade was written in, and the
+`fragment` that held its children; the loop that walked a connector's points and declared a
+`line` per dash, and the arithmetic that kept its phase round a corner.
+
+### Native verification
+
+The by-hand round alpha.6 introduced (backlog R4), on 2026-10-05 — the
+nine commits after the alpha.36 tag: `dash`, the `gradient` row, F120,
+F121 and RG112 — with a regression pass over them first: three
+read-only reviews (the dash, the gradient, the fonts with this
+release's docs), each claim probed with a test before anything
+changed. RG114–RG117 came of it and are in this release; RG118 holds
+what was read and left. This round ran on the Mac alone; Windows and
+Linux did not run it for this tag.
+
+**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.0**, on the release commit's tree,
+the workspace's own artifacts pruned and rebuilt. `cargo fmt --all
+--check` and `cargo clippy --workspace --all-targets -- -D warnings`
+are clean. `scripts/test.nu`, the workspace's tests with the
+conformance feature: **1802 tests over 135 suites, 0 failed** (4
+ignored). The C round, `cbuild --run`, passes its five checks; the
+corpus passes its **57 scenes** in four adapters, `gradients` the new
+one; the ABI is **24**. Node's `node --test test.mjs` under
+`KUI_CONFORMANCE_REQUIRED=1`: **209 of 209**. `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`, three times over: **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 28 to
+32 s — 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.** In each of the three runs one window of the
+first eight took the whole round to draw its frames — `cells`, then
+`audio`, then `accessibility`, each a second and a half when run
+alone — which reads as a window covered by the seven launched over it
+and not drawn until they had gone; not compared against alpha.36's
+build. The AX audit: **106/106**, 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.36 tag, on the release commit's
+tree: **green**, none of the 8 guarded rows more than 10% slower —
+every one between −0.9% and +2.8% (the worst guarded run-to-run spread
+2.1%). It was not so at first, twice over, and both are fixed in this
+tree:
+
+- `frame_10k_segments` read **+7.7%** (863 → 929 µs, ±1.0%) on solid
+  lines, and that was the dash (backlog C52): bisected to V2's commit
+  by building the bench at each one. The `Stroke`, twenty bytes wider
+  with its `Dash`, was copied at each call from `Ui::line` down to the
+  line store, and the dash's cut ran its whole test on every line. The
+  stroke is lent and a solid pattern is told by its zeroes; the row
+  reads +2.5% in the guard and 875 → 880 µs with the two binaries
+  alternated.
+- `frame_10k_rects` read +9.3% and every row built on the bench's grid
+  5 to 9% slower, and that was the bench: bisected to the commit that
+  gave its grid the gradient rows' arms in one `match` per cell, with
+  no line of the core between it and the commit before. The gradient
+  cell is a function of its own now, the plain rows read as
+  alpha.36's, and the gradient rows were taken again — 52 ns a node
+  over a flat box where the first reading said 55
+  ([ADR 0042](docs/adr/0042-a-gradient-is-an-image-the-core-paints.md),
+  *Measured*; [docs/performance.md](docs/performance.md) carries the
+  four rows from that run, the rest of its table kept as it was).
+
+**This tag was cut twice.** The first, at `c7e9793`, published
+nothing: both hosts' `check` failed on F121's own test, which asserted
+that the platform's list draws `字` differently from the app's — and
+on an image with DejaVu alone, both pipelines', the fixture is the one
+face that has it, list or no list. Forgejo's `check` had been red on
+it since F121 was merged, which this round did not read before
+tagging; cargo stops at the first failing suite, so the suites after
+`fonts` had not run there either. The test now tells which machine it
+is on and asserts the platform's half only where there is one, and
+`cargo test -p kui-core` passes its 105 suites in `rust:1-bookworm`
+with `fonts-dejavu-core` alone (the whole workspace would not fit that
+container). With no crate and no package carrying the version, the tag
+was moved to the commit that has the fix and C52's; the mechanical
+round, the windowed round and the guard above are of that commit.
+
 ## 0.1.0-alpha.36 (2026-10-05)
 
 **What breaks.**

package/docs/adr/0005-the-paint-vocabulary.md

@@ -127,6 +127,11 @@ silent surprise.
 
 ### Gradients: out of scope for v0
 
+> **Superseded by [ADR 0042](0042-a-gradient-is-an-image-the-core-paints.md)
+> (2026-10-05):** a box takes a `gradient`, linear or radial, rasterized
+> once into the atlas and drawn as an image quad. What follows is why it
+> was not in v0.
+
 Two colors and a direction sound like one more `PROPS` row and are not. A
 gradient needs a stop list (so: a `Keyframes`-shaped parse, in five
 bindings), a type (linear, radial, conic), a geometry (angle or two points,

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

@@ -408,3 +408,49 @@ binding: two nodes on a clipping canvas are panned half past its top edge,
 one clipped and one not. A press over the toolbar where the clipped node's
 cut half would be reaches the toolbar, and the same press on the other
 node reaches that node.
+
+## Amendment: a dash is cut in the core
+
+*2026-10-05, backlog V2.* Decision 9 left dashes out, and the options
+said why: a `dash` that restarted at every join of a curve would read as
+a bug. A view asked, so it is built, and not the way the option sketched.
+
+**The sketch was a phase per quad.** `params.w` would carry how far
+along the stroke each segment starts, and the backend would cut the
+capsule by the pattern. That is one quad per piece whatever the pattern,
+and it is a change to every renderer: the wgpu shader, and each host
+that draws the list itself, which would draw a dashed stroke solid until
+it caught up — with nothing to tell it so.
+
+**What is built is a cut in the core.** A dashed stroke's run is walked
+along its arc length (`line::Cut::marks`) and each mark is emitted as
+what it is, a short round-capped stroke: one `Segment` quad per mark per
+piece the mark lies on, two meeting at the corner for a mark that turns
+one. No backend changed, the corpus pins the cut by its segment count,
+and the phase is kept by construction, since the walk does not know
+where the pieces end. It costs quads in proportion to the marks rather
+than the pieces — a 1000 px line at a 10 px period is 100 — and a
+stroke that would be more than 16384 marks, or whose mark and gap come
+to under a physical pixel, draws solid.
+
+**The lengths are the ones seen.** Caps are round (decision 2), so a
+mark `on` long is a capsule with a centre line of `on − width`, and the
+gap's centre line takes the difference; a mark no longer than the stroke
+is wide is a dot. SVG's `stroke-dasharray` measures the centre line,
+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.
+
+**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
+mask is keyed by them. The pattern restarts at each subpath, as SVG's
+does. An offset that changes every frame is read as the path's shape
+changing, so a marching outline takes a texture of its own instead of
+an atlas slot a frame.
+
+**What it does not do.** Neither `dash` nor `dashOffset` tweens; a
+translucent dashed polyline double-blends where two halves of one mark
+meet at a corner, as a solid one does at every join; and the hit region
+is the whole stroke, gaps included — the target is the stroke, not the
+ink.

package/docs/adr/0038-a-scroll-gesture-latches-its-target.md

@@ -186,3 +186,11 @@ date: 2026-09-28
   the C door, and by the corpus's `scroll-gestures` scene in four
   adapters. The scene holds a contained list at its limit and a y-only
   handler met by a sideways notch.
+- *Amended (F122, RG119):* a handler that names modifiers
+  (`scroll_mods`) is asked before this walk, of the modifiers the
+  gesture began with, the innermost such handler taking it whatever
+  room or `contain` the regions inside it have. To a gesture it does
+  not hear it is what it would be with no `on_scroll`: the container
+  it may also be, asked like any other, and otherwise passed. The
+  latch keeps the modifiers with the targets. Pinned by
+  `tests/scroll_mods.rs`.

package/docs/adr/0040-a-path-is-a-mask-in-the-atlas.md

@@ -127,7 +127,9 @@ date: 2026-10-04
    wedge; the stroke's colour tweens as a line's does. `fillRule` is
    `nonzero` (SVG's default; a self-intersecting outline fills its
    overlaps) or `evenodd` (the `polygon`'s rule, kept there unchanged).
-   Joins and caps are round, as a `line`'s are; `dash` stays V2's.
+   Joins and caps are round, as a `line`'s are; `dash` stays V2's
+   (built 2026-10-05: the stroke's mask is cut by the pattern, see
+   [ADR 0010's amendment](0010-a-segment-primitive.md#amendment-a-dash-is-cut-in-the-core)).
 4. **Rasterized on the CPU, through zeno, at the node's physical scale.**
    The ops are transformed to physical px and rasterized into an 8-bit
    coverage mask the size of the outline's bounding box plus a pixel on
@@ -181,7 +183,8 @@ date: 2026-10-04
    that is different each frame; a shape that must move cheaply every
    frame at any size stays a `polygon`, whose SDF costs the quad and
    nothing else. A path still for two frames after animating stays
-   texture-backed; the rule is one-way, as the image's is.
+   texture-backed; the rule is one-way, as the image's is. *(Amended:
+   it returns after 120 still frames — see the second review below.)*
 9. **Hit by its outline, nonzero or even-odd as it fills.** Emission
    flattens the ops once — the same flattening the rasterizer gets — into
    `Interaction::shape_points`, and `HitShape::Polygon` gains the fill
@@ -399,6 +402,45 @@ allocation, not the core, was the difference, and the bench now builds
 its geometry once, as the polygon bench's points are. An app keeps its
 geometry too.
 
+### Second review (2026-10-05, before the alpha.36 tag and after it)
+
+The pre-tag regression pass read the built element again (backlog
+RG107–RG112). What it changed in the decisions above:
+
+- **Decision 8 is not one-way.** An animating key whose shape has held
+  for 120 frames (`path::SETTLED_AFTER`, a second at 120 Hz) is a shape
+  again: its mask goes back to the atlas and its texture is dropped.
+  The latch was for what moves; held for good it also caught a key from
+  the tree position whose siblings came and went twice within the
+  window, and a spinner that had stopped — each a texture, a bind group
+  and a draw of its own for the life of the node. A pause shorter than
+  that stays out, so a spinner that stutters does not churn the page,
+  and moving again takes two changes, as the first time. The image's
+  rule is unchanged: an image's backing is declared by its updates, a
+  path's is inferred.
+- **Decision 9, with a stroke over a fill.** A path that may paint a
+  fill — a `bg`, or one a hover, a press or the focus brings — and has
+  a stroke is hit by the fill *or* within half the stroke's width of
+  the stroke's pieces (`HitShape::Path`'s `stroke`), so the outer half
+  of a thick stroke is hit where it is painted. A stroke with no fill
+  at all is still `HitShape::Segments`, with its minimum grab.
+- **A texture of its own is the session's to drop when its window
+  goes.** A core's `PathTextures` hands what it still holds to the
+  session as it is dropped, so the next list any window builds carries
+  the drop, as a removed image's does; and a frame whose list nobody
+  read (`Core::output`) hands its drops to the next, since an animating
+  path sweeps a texture every frame and a frame built twice before a
+  render lost one each time.
+- **The flat form is checked in the core.** `Core::path_flat_node`
+  (and `Content::PathFlat` for a binding that lowers props) reads the
+  floats and raises `path-malformed` under the node's key when they are
+  not the form — what C and Node drew nothing for in silence and Lua
+  failed the view for. A number that is not finite, in either form or
+  in the turn, is `path-malformed` too (RG107).
+- **The limit is the device's.** `kui-wgpu` opens its device with
+  wgpu's default limits, so 8192 is what every device it draws on
+  holds; the gate counts the mask's own margin (RG111).
+
 ## Action items — all done 2026-10-05
 
 - [x] `crates/kui-core`: `path.rs` (ops, store, `Path` builder,