@weasel-js/core 1.4.4 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,949 @@
 # Changelog
 
+## 1.5.1
+
+### Patch Changes
+
+- 5769e02: `<Canvas>` and `<SceneCanvas>` take a `flattenTolerance` prop, forwarded to
+  `WeaselRendererOptions.flattenTolerance`. A scene whose world unit is not a
+  pixel — feet, inches, millimeters — was pinned to the path-local
+  `DEFAULT_FLATTEN_TOLERANCE` of 0.5, which flattens a sub-unit curve to a few
+  vertices; only the headless `renderSceneToPixels` path could set it.
+  
+  `WeaselRenderer.setFlattenTolerance` is new, so a change to the prop reaches
+  the renderer the canvas already built rather than being read once at
+  construction.
+- f644eac: The sRGB ↔ OKLab/OKLCH conversions (`srgbU8ToOklab`, `oklabToOklch`, `lerpOklch` and the rest) now live in `@weasel-js/paint`. `@weasel-js/core` still exports every one of them, so no import changes.
+- 9becb93: `features/selection` gets a barrel, and core's main barrel reaches its overlay
+  layers and ambient context only through it. No export changes name or shape.
+  
+  The entry had been held back as needing a design pass, on the grounds that
+  selection is protocol-shaped. It is — but the protocol (`SelectionApi`,
+  `useSelection`, `ChromeState`, `MULTI_RESIZE_TARGET_ID`) lives in
+  `core/selection`, below this directory, because affordances and tools both read
+  it and the layering runs `core` → `affordances` → `tools` → `features`. So the
+  barrel covers what is built *on* the protocol and says so, rather than moving
+  the protocol up to join it. `docs/taxonomy.md` said the protocol lived under
+  `features/`; corrected.
+- b984947: A `<SceneCanvas>` scene slot with its own `toPose` now derives paths from the poses that `toPose` paints dependencies at. Before, `derivePath` was handed the scene's poses while the nodes it connects were painted through `toPose`, so a derived edge could miss its endpoints. The clip a derived container imposes follows the same rule. No API change.
+- 7e9a230: `resolveDerivedPath` now notices a dependency that moved on its own. On a memo hit it re-resolves the dependencies and compares their poses **by value** against the ones the cached path was drawn from, rather than serving the cached path until the scene pushes an invalidation. That covers the three misses the pushed triggers have had to be widened for — an ancestor's frame moving, a dependency going away, a dependency appearing — and covers a lookup the scene cannot know about at all, such as the `toPose` a scene slot paints through. By value, not by reference: a pose override mutates its buffer in place.
+  
+  The pull covers poses. A derivation is handed each dependency's whole node, so one reading `data` or `layer` still rides on the scene's pushed invalidation, which is unchanged.
+  
+  It costs a resolve and a compare per dependency per frame. Measured with `tests/perf/bench/derived-path.bench.ts` on one machine, taking the minimum of 200 iterations, a steady-state frame in which nothing moved went from 0.0037ms to 0.0112ms at 30 edges, 0.0212ms to 0.0590ms at 150, and 0.0863ms to 0.2757ms at 750 — about 3x the memo-hit frame, and under 2% of a 16.7ms frame at the largest of those. Two changes keep it there: `samePoseValue` walks an opaque pose without allocating, and a dependency now reaches a derivation as a class instance rather than an object literal with an own `get path()`, which alone was a third of the added cost.
+- 72fde09: `documentPose` now ignores pose overrides along a derived node's whole dependency chain, not just on the node itself. Before, a derived node's document pose moved while something it derives from was being dragged, which let the minimap's framing follow a drag in any scene with derived poses. `effectivePose` is unchanged. Behavior change, no API change.
+- e9051ac: New `effectiveRangeStyle(range, style, paint?)` reports what is actually rendering across a text range: the range's styling (from `styleAtRange` or `useTextEdit`'s `rangeStyle`) resolved against the node's own `TextStyle` and paint, the way the canvas resolves runs. A node-level flag reads as on across the whole range, a run's override wins over the node's value, and with a `null` range it reports the node alone. Additive: `styleAtRange` and `rangeStyle` still report the runs alone, unchanged.
+- 626bace: A gradient now names the space its stops blend through. `interpolate` on any of
+  the three gradient kinds takes `'rgb'` (the default, and what every other vector
+  format means by a gradient), `'oklab'`, or `'oklch'` — which travels around the
+  hue wheel, so red to blue stays saturated instead of passing through a muddy
+  purple. Alpha is linear in every space.
+  
+  The blend is paid for once, in the 256-texel ramp the shader samples, so a
+  perceptual gradient costs a batched frame nothing over an sRGB one. The space is
+  part of the ramp atlas key: the same stops under two spaces take two rows.
+  
+  `sampleGradientStops` and `sampleResolvedStops` take the space as a third
+  argument, `bindRamp` as an optional third, and `GradientEditor` grows an
+  sRGB / OKLab / OKLCh switch (`spaceSwitch={false}` hides it). `@weasel-js/svg`
+  writes `wzl:interpolate` on the gradient's own element and reads it back; a
+  renderer that ignores it still paints the gradient, in sRGB.
+- f4049be: Poll which keys are down. `useKeyState()` (or `createKeyState()` plus
+  `attach(target)` outside React) tracks physical keys by `KeyboardEvent.code`,
+  independently of which bindings claim them: `isDown(code)`, `isKeyDown(key)`,
+  `codes()`, `modifiers()`, and `take(code)`, which hands out each fresh press
+  once — autorepeat is not a press. Everything is released when the keyups can no
+  longer arrive: the window blurs, the document hides, focus leaves an element
+  target, or Meta is released (macOS sends no keyup for a key let go while Cmd is
+  held). Modifier keys are reconciled against the flags every key event carries,
+  so a modifier released in another window does not stick. `preventDefault`
+  names the codes whose browser default is blocked, so a game's Space and arrows
+  stop scrolling the page.
+  
+  This adds API and changes nothing existing.
+- 432b143: A `LayerGroup` member name now claims that layer and every layer under it in the `:` namespace, so `layers: ['scene']` covers the `scene:<layerId>` layers a scene with declared layers draws as — the same set `before`/`after: 'scene'` anchors against. The separator is required, so `'scene'` does not reach `scenery`. A member matching no layer being drawn is warned about rather than silently ignored; one group naming a layer both directly and through its namespace is treated as redundant, not as a conflict.
+  
+  Additive for a group whose members all name layers exactly. A group that named a namespace prefix and relied on it grouping nothing now groups those layers, and a member that matched nothing now logs a warning where it previously stayed quiet.
+- 4f9fd3b: labkit's loupe routes its peek key and its wheel through the gesture dispatcher, as the `loupe.peek` and `loupe.magnify` actions, instead of attaching `keydown`/`keyup`/`blur` on the window and a capture-phase `wheel` on the host. Taking the wheel from a lab's pan/zoom is now the dispatcher's ordinary rule — `loupe.magnify`'s `enabled` declines while the lens is down, so the event goes unhandled and falls through, and while the lens is up the dispatcher stops propagation before React's root listener runs. Aiming the lens stays a plain `pointermove` listener: the gesture grammar names no hover.
+  
+  `useGestureDispatcher` takes `channels`, switching off any of the four listener groups it attaches to its element — `pointer`, `wheel`, `contextMenu`, `ingest`. Every one defaults on, so nothing changes for a caller that omits it. A mount that wants one gesture should not also have to take the rest of the pipeline's side effects: `contextMenu` suppresses the native menu unconditionally, and `ingest` makes the element a file-drop target. The loupe mounts with three of the four off, which is what keeps right-click and drops working on a lab that turns a magnifier on.
+  
+  `<LoupeGestures>`, `createLoupeActions` and `LoupeInputApi` are new on `@weasel-js/labkit/loupe`; `useLoupe`'s returned state carries a new `input` member that `<LoupeGestures>` drives the lens through.
+- 91973a7: Export the marker path builders — `circlePath`, `squarePath` and
+  `rectMarkerPath` — from `@weasel-js/core`, and add `roundRectPath` beside them.
+  They are the shared math for selection chrome, anchor markers and rubber-band
+  rects; until now a consumer building overlay chrome had to reimplement the
+  circle sample loop.
+  
+  `markers.ts` also carried a `linePath(ax, ay, bx, by)` that built the identical
+  open two-vertex `PolygonPath` as the already-public `linePath(a, b)` from
+  `builder.ts`. Rather than rename one to clear the collision on the barrel, the
+  duplicate is deleted and its callers now use the point-taking public one — two
+  spellings of one function is the thing worth removing, not the name clash.
+- 86be3eb: A sixth paint kind: `mesh-gradient`, PDF's shading types 6 and 7. A mesh is a
+  set of curved quadrilateral patches, each carrying a color at every corner, so
+  its color field bends where the three gradients can only run straight. Twelve
+  control points make a Coons patch and sixteen a tensor patch, which is the only
+  difference between them.
+  
+  It is registered through `registerPaintKind` rather than built into the
+  renderer, so every slot it uses is one a consumer's own kind can use. The paint
+  is rasterized once into a 256-texel bake the shader samples — forward, the way
+  every renderer that draws these works, because a paint has to answer "what color
+  is this fragment" and inverting a bicubic per fragment does not. Corner colors
+  blend through `interpolate`, as a gradient's stops do.
+  
+  `@weasel-js/svg` writes it as `<wzl:meshGradient>` with every patch's points in
+  full — not SVG's abandoned `<meshgradient>`, whose implicit edge sharing gives a
+  reader a way to be quietly wrong — and reads it back. A renderer that skips the
+  def paints the fallback color beside the reference.
+  
+  `MeshEditor` in `@weasel-js/ui` edits the corner colors and the blend space, and
+  `PaintInput` renders it: before this, a mesh in that control fell through to the
+  color field, which wrote a solid back over it.
+- 51372f1: Dragging a container that holds a derived-pose child no longer shows that child jumping to its authored placeholder for the length of the drag. The move action now captures each dragged node and descendant at the pose it is painted at (`effectivePose`), and commits the authored pose translated by the drag, so undo restores the placeholder exactly. No API change.
+- 2a63f31: Alt+clicking a segment of the path being edited now inserts an anchor where you clicked, and the pen cursor shows while Alt is held over a segment. A straight segment stays straight; a curve is split without changing its shape. The closing edge of a closed path can be split too, the new anchor becomes the selected one, and the click has to land within 8 screen pixels of the path — so the reach no longer changes with zoom. Before this, the split only worked on curves: a straight edge came back as a curve, and the closing edge could not be split at all.
+  
+  Every anchor edit (drag, nudge, delete, cut, insert) can now be undone. Before, `SceneCanvas` recorded these edits as operations with no inverse, and undoing one threw an error.
+  
+  Additive: `Action.enabled` gets a second, optional argument — the world point of the click or press being routed. When it returns disabled for that point, the dispatcher tries the next binding, and the hover cursor is not shown there. The hover cursor now also comes from the action a click would run, when the action a drag would run has no cursor. `nearestSegmentT` gets an optional `closed` argument and returns an exact parameter instead of the nearest of 32 samples. `segmentAt` is new. The `SceneCanvas` adapter gains `setData`.
+- 66e0e10: The pen tool snaps to existing anchors. An anchor placed within
+  `anchorSnapRadius` screen pixels (default 8) of any existing path's anchor
+  lands exactly on it, which makes stitching paths end to end precise. Anchor
+  snapping takes precedence over `snapPoint`, which still applies away from
+  anchors; `anchorSnapRadius: 0` turns it off.
+  
+  This is additive: `usePenTool` gains the `anchorSnapRadius` option.
+- 8b79c20: The pen tool continues an existing open path. With nothing drawn, pressing an
+  open path's first or last anchor picks that path up; the clicks that follow
+  extend it from that end (a first-anchor pick-up prepends and keeps the path's
+  direction), and finishing — Enter, ⌘-click, double-click, or clicking the far
+  end to close it — writes the result back to the same node as one undoable
+  edit rather than making a new node. Dragging from the endpoint pulls that
+  anchor's own handle. The pick-up radius is `closeHitRadius`, in screen pixels.
+  
+  This is additive. The pen now reads existing paths through the `areaSelect`
+  and `editAnchors` deps, which `<SceneCanvas>` already publishes; a host
+  without them gets the old behavior. `PenScratch` gains a `continuing` field.
+- b6a5eed: Inserting a path anchor gets its own cursor. Alt over a segment in path-edit
+  mode drew the pen tool's own glyph, so the pointer said nothing about what the
+  click would do.
+  
+  The new `penPlus` glyph is the pen nib with a filled plus badge in the
+  lower-right. The nib runs along the anti-diagonal and left no room on the
+  diagonal for a badge, so it is shifted two units up and left — the same trade
+  the shape cursors make with a short-armed crosshair. Proofed at 11x over the
+  three grounds and on the pixel grid at 16 and 24 CSS px, 1x and 2x.
+- 98ad39c: The platformer demo's eleven bones are a parented chain in the scene tree, composed by `RIGID_POSE_COMPOSITION`, instead of eleven parentless nodes re-derived from world matrices every frame. `syncScene` writes local poses and resolves nothing; the joint hierarchy and the node hierarchy are now the same tree, which is what the scene-as-frame work was for.
+  
+  The rig is rigid — every joint's `scaleX`/`scaleY` is 1 at bind and no clip touches either — so nothing had to stay flattened on the grounds the design doc excludes. The one term `RectPose` could not carry is the facing mirror, which was a `scaleX: -1` above the whole rotated chain. Mirroring a rigid chain is equivalent to negating every local rotation and every local x offset, so it moves into the pose data and stays exact.
+  
+  A bone with children has to be a container, and a container with no `clipFromPose` clips its descendants to its own silhouette — a box a few units wide, here. The bone containers return `null`, which is how a frame says it groups without clipping.
+- 67f3867: Project a `'polyline'` overlay's vertices to screen coordinates, the way
+  `useDispatcherOverlayLayer` already handles marquee, lasso and insert previews.
+  A cut line and a connector were wrapped in a `viewToMat3(view)` group instead,
+  so their stroke thickened with the zoom while the chrome beside them held its
+  CSS-pixel weight. That came across unchanged when the layer took over painting
+  from the actions; it is now the same rule for every overlay.
+- f663199: A `{ px }` stroke width no longer re-tessellates its ribbon on every frame of a
+  zoom. The width is now resolved against the zoom snapped to a fine grid, so
+  consecutive frames share a cached ribbon and a zoom no longer evicts the path's
+  other cached stroke styles. The drawn width stays within 1/8 of a screen pixel
+  of the width asked for. No API change.
+- a80e8db: `@weasel-js/diagram/layout` and `@weasel-js/core/math` are new subpaths that a
+  Node process can import: measuring a box from its rows, ranking a graph,
+  relaxing one under forces, and finding where on a box's perimeter an edge
+  should leave, with no React in the module graph. A server rendering a diagram
+  needed all of that and could not have it — the diagram barrel reaches `live`
+  (a hook) and `connect` (an interaction), and core's reaches the canvas.
+  
+  `layout` exports `measureBody`/`sizeToBody`, `layered`/`ranksOf`/`backEdges`,
+  `force`, `tree`, `COMPASS` and the rest of `ports`, `outline` and `onOutline`.
+  A caller with its own nodes and edges implements `Graph` — an interface, not a
+  class — over what it already has, so `buildGraph`, which reads one out of a
+  scene, is not needed and is not there. The routers stay behind: they live with
+  the scene registry, and they are typed in `Vec2`, so a consumer routing in
+  three dimensions cannot call them regardless.
+  
+  The seven modules behind it now import `@weasel-js/core/math` rather than the
+  core barrel. Every symbol they took is in the subpath, so this narrows what
+  they ask for rather than moving anything.
+  
+  `scripts/check-react-free.mjs` (`npm run check:react-free`) walks each entry's
+  **built** closure, through sibling packages' `exports` maps, and fails on a
+  React specifier. Sources cannot answer this question: `core/math` re-exports
+  nineteen leaf modules that each import only numbers, and its first build still
+  pulled a megabyte of canvas — one leaf reached core's own barrel, and
+  `splitting: true` put the result in a chunk the entry imported.
+- a7519a1: Remove the `pointer` dep. **Breaking:** `DepSchema` no longer has a `pointer`
+  entry, `useStandardActions` no longer takes a `pointer` option, and the fixed
+  deps bag handed to an action that declares no `requires` no longer carries it.
+  
+  Nothing in the kit declared or read it, and `<SceneCanvas>` never supplied a
+  value, so an action reading `deps.pointer` was already getting `undefined`. An
+  action that wants the pointer reads it from its invocation context
+  (`ctx.world`), and code outside an action can still use `usePointerContext()`,
+  which is unchanged.
+- 187593e: Remove `useRotateTool` and the `'rotate'` built-in tool id. **Breaking:**
+  `'rotate'` is no longer a `BuiltinToolId`, so `defaultTools={['rotate', …]}`
+  and `tools={{ rotate: true }}` no longer typecheck, and the `standard` bundle
+  and the default tier no longer list it.
+  
+  Rotation itself is unchanged. It has run through `rotateAction`, bound by the
+  select tool on the rotation handle, since the affordance hit-test was
+  consolidated; the tool contributed no bindings and its overlay painted
+  nothing. Drop the id from any tool list, and delete a `useRotateTool` mount
+  outright. `selectTool={{ rotate: false }}` still turns rotation off.
+- 08a3aec: The renderer's `mat3.translate` and `mat3.scale` are renamed `mat3.translated`
+  and `mat3.scaled`. They compose onto the matrix you pass (`m · T`, `m · S`),
+  where `@weasel-js/geom`'s `translate` and `scale` build a fresh matrix, so the
+  shared names let code moved between the two compile and then misbehave.
+  
+  This is a breaking change for anyone calling `mat3.translate` or `mat3.scale`
+  from `@weasel-js/core`: rename the call; the behavior is unchanged.
+- d963d14: `EligibilityState.heldTriggers` is gone. Nothing populated it: a declared
+  `Eligibility.offhand` already reaches the hotkey tier by id, because the
+  `tool.offhand` action the declaration registers pushes the tool's id onto the
+  active-tool context's hotkey stack, and `engagedIds` is what `liveScope`
+  reads. Populating the set instead would have given the same tier a second
+  source of truth — raw key state tracked beside the gesture that already owns
+  the hold — with release order to reconcile between them.
+  
+  `offhand` is untouched. Construct `EligibilityState` without the field; a
+  consumer reading it has to read `engagedIds` instead.
+- edb825a: `Scene.nodesOnLayer(layer)` returns one layer's nodes in render order, cached
+  beside `renderOrderNodes()` until the next structural edit — so a pose tween,
+  which fires per frame, does not throw the walk away.
+  
+  `d3Bind(...).join()` uses it. The diff used to scan every node in the scene on
+  every call to find the leaves on its own layer; it now classifies enter and
+  update with `scene.get` and scans only the target layer for exits. The
+  semantics are unchanged: a leaf on the target layer whose key is absent from
+  the data still exits, and nodes on other layers and containers are still left
+  alone.
+- 229a16a: Add `scene.untracked(fn)`, which applies scene mutations without recording them, for writes that are not edits, such as a simulation stepping poses each frame. It notifies once, reverts on throw, and refuses `applyBatch` and `history.apply` / `applyOps`. Undo never restores an untracked write; undoing the next recorded change lands on the pose the untracked writes left.
+  
+  Add `History.seal()`, which ends the current coalescing run so the next entry is pushed fresh. This adds a member to the `History` interface, so a hand-written implementation of it must add `seal`.
+- f9feecc: The scene slot can skip what the view cannot see. Pass
+  `layers={{ scene: { drawOne: defaultDrawOne, cull: true } }}` to
+  `<SceneCanvas>` (or `cull: true` on a `<Canvas>` scene slot) and commands that
+  cannot reach the view are dropped before they reach the renderer, so an
+  off-screen node no longer costs tessellation, upload or a draw.
+  
+  The cull is conservative: paths are bounded by their control points plus the
+  farthest their stroke can reach, rotated content by the box around its
+  corners, and text, custom shaders and anything under an effect are always
+  kept. It is off by default because it makes the scene layer's output depend on
+  the view, which matters only if you cache or re-display that output under a
+  different camera.
+  
+  The same pass is exported as `cullDrawCommands(cmds, transform, rect)` for
+  custom layers. This adds API; nothing existing changes.
+- b981856: Accept `{ px }` screen-pixel sizes for `fontSize` and `letterSpacing`
+  
+  `TextStyle.fontSize`, `TextStyle.letterSpacing` and their `StyledRun`
+  counterparts now take `number | { px: number }`, the spelling `Stroke.width`
+  and `MarkerRef.size` already had. A `{ px }` size holds its on-screen size as
+  the view zooms, so a label no longer divides by the view scale at the call
+  site.
+  
+  The unit is one type and one resolver now: `ScreenLength` and
+  `resolveScreenLength` live in `@weasel-js/paint`, which both core and text
+  already depend on, and `resolveStrokeWidth` delegates to it.
+  
+  Resolution happens at the entry to layout, not at draw time. A screen-pixel
+  size changes the glyph advances and so the wrap points and the measured
+  bounds, so `resolveTextStyle`, `resolveRuns`, `textPoseLayoutInput`,
+  `layoutTextPose`, `measureTextBounds` and the three command builders
+  (`textCommand`, `textCommandFromRuns`, `textCommandFromPose`) each take the
+  view scale, defaulting to 1. `ResolvedTextStyle` and `ResolvedRun` keep plain
+  world numbers, so everything downstream is unchanged.
+  
+  `createTextLayer` passes the mean of `view.scale.x` and `view.scale.y`, so
+  non-scene text gets this with no consumer change. The `kit:text` node painter
+  deliberately does not: it memoizes on `(data, pose)` to keep the renderer's
+  layout cache hitting across frames, and keying that on the live camera would
+  miss on every zoom frame.
+  
+  SVG serialization writes a `{ px }` size as that many user units — SVG user
+  space has no camera — and the fit clamp on import leaves one alone, since a
+  screen-pinned size is not the file's to scale.
+- 0662a2d: Add a slew limiter: `slewToward(value, target, dt, { rise, fall })` moves a value toward a target by at most a per-second rate in each direction, and `createSlew` keeps that state between steps. A fast rise with a slow fall is an attack/release envelope; a direction with no rate jumps.
+- c0fa540: `usePointerStylus` no longer drops the first pointer move when it arrives within
+  `1000 / maxFps` ms of the page's time origin. The throttle measured that first
+  move against a last-commit time of zero rather than "never". A bug fix; nothing
+  else about the throttle changes.
+- 21ce23e: The text-edit overlay now honors `verticalAlign`. `TextEditScreenPose` gains an optional `verticalAlign`, and `useSceneTextEdit` fills it from the node (`data.verticalAlign`, or `getVerticalAlign`), so editing a center- or bottom-aligned text node keeps its text where the canvas drew it instead of jumping to the top of the box. The overlay re-measures its own height as you type, so added lines grow a bottom-aligned node upward. Additive: a pose without `verticalAlign` places exactly as before.
+- ff17dd7: `tileGrid` no longer lets two children land in one cell. A drop from outside the container is offered only the free cells, so it lands in the nearest free one, a multi-select drop fills distinct cells, and a full grid rejects the drop. A drag within the container still swaps with the child in the cell it lands on, and the swap now finds that child by where it sits rather than by id order, so it keeps working after an earlier swap. The new optional `centerOf` option says which point of a pose decides its cell; the default suits rect and point poses. Behavior change, additive API.
+- f2b8d57: Add `createTiledLayer` — a periodic lattice over any RenderLayer
+  
+  Content is authored once, in the cell `[0, period)`, and the wrapper draws
+  every copy the view can see. Panning keeps producing copies in either
+  direction, so a backdrop loops seamlessly with no wrap-around bookkeeping
+  anywhere in the source. `tiledProject(visStart, visEnd, period, bleed?)` is
+  the public helper underneath: the inclusive range of copy indices a visible
+  span touches.
+  
+  Each copy draws the source through a view shifted by `-k * period`, so a
+  source that culls against the view it is handed culls per copy and never
+  learns it is being tiled; the copy's commands are then translated by
+  `+k * period`.
+  
+  Three open questions from the backlog entry, settled:
+  
+  **2D wrap, and the period names the axes.** `period` is `number | { x?, y? }`:
+  a bare number wraps x only — the side-scrolling case — and `{ x, y }` wraps
+  both. There is no separate `axis` option, because two ways to say which axes
+  wrap is one way for them to disagree.
+  
+  **The period may be a function of the view and dims**, read per draw. A
+  constant is the common case, but "one screen wide" is a period too, and a
+  thunk is the shape every other view-dependent kit option takes.
+  
+  **The lattice is per layer, not per shape.** Content on two periods is two
+  tiled layers stacked. A per-shape period would move the lattice into the
+  source and leave the wrapper unable to cull.
+  
+  The plane is `space: 'world'`, which is what lets it be a `source` of
+  `createParallaxLayer`: the parallax plane hands it the derived inner view, the
+  lattice resolves against that, and the copies ride the plane. A
+  `space: 'screen'` source is drawn once, untiled — it ignores the view by
+  definition, so every copy would land on the last.
+  
+  `bleed` declares how far the content reaches outside its own cell, in world
+  units, so a shape that overhangs still scrolls in rather than popping in at
+  the edge of the view.
+  
+  `apps/site/demos/ParallaxDemo.tsx` is rebuilt on it; its local `tiledProject`
+  helper and the per-painter period threading are gone.
+- 29f6ed0: Bind a rig to scene nodes. `useRig({ scene, skeleton, bindings })` (or
+  `bindRig` outside React) maps joint names to the node or nodes that ride them;
+  `rig.pose(pose, root?)` resolves the skeleton and moves every bound node
+  through the scene's pose overrides, so a per-frame write records no history and
+  bumps no version. Each node keeps the offset from its joint that it has at the
+  bind pose, so nodes are authored in place over the rest skeleton. `apply` is
+  the one part that knows the pose shape: the default, `rigidRigApply(descriptor)`,
+  carries a node's center and rotation with its joint through any pose
+  descriptor, mirrored roots included; supply your own to size nodes from joint
+  scale or to treat some nodes differently. `rig.bake()` writes the current frame
+  into the document as one undo entry, `rig.release()` drops the overrides, and
+  `rig.world()` returns the last resolved joint transforms.
+  
+  This adds API and changes nothing existing.
+- fb6d8e5: A registered shader program supplying its own vertex shader now gets locations
+  for the uniforms it declares there. `WeaselRenderer.registerProgram` scanned
+  only the fragment source, so every vertex uniform was written through a `null`
+  location — which GL accepts in silence, leaving the uniform at its zero
+  default. A zeroed `u_model` collapses every vertex to a point, so the program
+  bound, drew, and painted nothing at all, with no error anywhere.
+  
+  This is what the `mesh-gradient` paint hit: it is the first thing in the kit to
+  reach the custom-program path with a vertex stage of its own.
+- ca7c737: Add `useViewAnimationOn(view, animator)`: `useViewAnimation` on an animator the
+  caller owns, without the idle fallback animator `useViewAnimation` has to build
+  because a hook cannot be called conditionally. `<SceneCanvas>` now uses it, so
+  each canvas constructs one camera animator instead of two. Additive;
+  `useViewAnimation` is unchanged.
+- Updated dependencies [f644eac]
+- Updated dependencies [626bace]
+- Updated dependencies [4f9fd3b]
+- Updated dependencies [ed05c54]
+- Updated dependencies [2a63f31]
+- Updated dependencies [b6a5eed]
+- Updated dependencies [a7519a1]
+- Updated dependencies [d963d14]
+- Updated dependencies [229a16a]
+- Updated dependencies [b981856]
+  - @weasel-js/paint@1.5.1
+  - @weasel-js/routing@1.5.1
+  - @weasel-js/cursor@1.5.1
+  - @weasel-js/history@1.5.1
+  - @weasel-js/text@1.5.1
+  - @weasel-js/font@1.5.1
+  - @weasel-js/geom@1.5.1
+  - @weasel-js/gestures@1.5.1
+
+## 1.5.0
+
+### Patch Changes
+
+- 9190fc9: Follow-ups a 3D lab turned up while driving core's dispatcher over a WebGL
+  viewport. Each one is a place the kit assumed its own 2D renderer.
+  
+  **`classifyTarget` and `affordanceAt` now take the world point their types
+  promise.** Both were handed the raw client point at every dispatcher call site,
+  so `<SceneCanvas>` and `<CanvasView>` each wrapped their thunk in the same
+  `clientToWorld` they also passed the dispatcher, and a consumer hit-tested in
+  one space while reading `ctx.world` in another. The conversion happens once now,
+  where the event arrives. Behavior-identical for both kit consumers; a consumer
+  passing no `clientToWorld` sees identity. **If you pass either option to
+  `useGestureDispatcher` yourself and convert coordinates inside it, remove your
+  conversion.**
+  
+  **`InvocationCtx.screen` carries a screen point, and is optional.** It was
+  filled from the same field as `ctx.world`, so it had never been screen-space.
+  It now comes from the event's client coordinates and is absent where the event
+  carries none — a keystroke, a UI-driven trigger, a synthetic probe. A
+  view-mutating drag still wants `drag.screenDelta`. A click's `ctx.world` is the
+  click's own position rather than the origin.
+  
+  **`scene.history` publishes the `History` a `Scene` already owned.** The kit's
+  `undo`/`redo` actions resolve a `history` dep and a consumer had nothing to give
+  them, so `<SceneCanvas>` cast the Scene itself through `unknown`. It is a façade
+  rather than the private engine: mutating members route through the scene's own
+  wrappers, so an action-driven undo bumps the version and notifies subscribers.
+  
+  **`resolveOverlays` is the overlay half of the in-flight gesture channel.**
+  `resolvePreviews` already answered for the ghosts a gesture displaces; this
+  answers for the chrome it draws that is no node at all — a marquee rect, a lasso
+  trail, an insert outline — in world geometry, with every degenerate case
+  dropped. `insertPreviewExtent` is exported alongside it.
+  
+  **Every overlay variant is now geometry, and the layer owns the paint.**
+  `OngoingOverlay`'s `'commands'` variant — arbitrary `DrawCommand[]`, which only
+  core's own 2D renderer could execute — **is gone**, along with the `opaque` flag
+  on the resolved form and the `action.commands` chrome id. Its two producers
+  publish the new `'polyline'` variant instead: a run of world points plus a
+  one-word `OverlayRole` (`'cut'` for `slice`, `'connector'` for
+  `@weasel-js/diagram`'s `connect`) that a painter maps to a stroke, falling back
+  to plain chrome for a role it does not know. `useDispatcherOverlayLayer` draws
+  both exactly as they were drawn before, and
+  `DispatcherOverlayStyle.roles` is where a consumer restyles one.
+  **`ConnectActionOptions.stroke` is removed** — an action no longer names a
+  paint; use `roles: { connector: … }` on the layer's style.
+  **If you produced a `'commands'` overlay**, publish a `'polyline'` for a line,
+  or paint it from a render layer of your own.
+  
+  **labkit stacks two surface buffers around the trial DOM.** The shared buffer
+  sat over the trials, which is right for a mark annotating an instrument and
+  wrong for an opaque renderer that buries its own pane. `useSurfaceCanvas('under')`
+  asks for the lower buffer; the default is unchanged. **`SurfaceCanvasContext`
+  now carries `{ over, under }` rather than one canvas** — a consumer providing it
+  directly must update the value.
+  
+  **labkit labs get their own chrome regions.** Every region was per-trial, so a
+  lab-level control had nowhere to go and `LabPalette` existed by casting a
+  two-field object through `as unknown as TrialChromeContext`. `<Lab labChrome>`
+  takes contributions shaped exactly like a trial's, against a real lab context.
+  
+  `docs/extending.md` now states the contract for mounting tools outside
+  `<SceneCanvas>`, including the half that was written down wrong: capability
+  eligibility resolves through `RuleCtx.allowedCapabilities` and `getRuleCtx`, not
+  the `activeTool` dep.
+- a2feeb0: The default actions now work in a scene where a container's pose is a frame.
+  Each one read a stored pose as though it were world, which is right only under
+  the identity composition every consumer ships today; under any other one a
+  selection inside a rotated container aligned to the wrong edge, orbited the
+  wrong pivot, and grew along the wrong axis.
+  
+  `resize`, `rotate`, `flip`, `align`, `distribute` and `clone` now compose the
+  poses they measure up to world, and rebase every pose they write — preview,
+  override and committed op alike — into the frame the node stores it in. An
+  action that reads world and writes world looks right for one gesture and drifts
+  on the next, so `scenePoseFrame` pairs the two directions and each action's
+  tests run against a rotated-container fixture where local and world differ.
+  
+  `align`, `distribute` and `flip` also read through `effectivePose` now, so they
+  see a gesture's in-flight override instead of the pose underneath it.
+  
+  `group` and `ungroup` re-express every member across the change of frame, so
+  neither moves anything on screen. The container takes the world envelope of its
+  members' ink (`unionAABB`, so a turned member contributes what it covers rather
+  than the box it was posed in). Its pose is derived from its members only under
+  an identity composition: anywhere else that derivation reads poses expressed in
+  the container's own frame to compute that frame, which is circular, so the
+  container keeps the authored envelope until that has its own answer.
+  
+  `useAlign` and `useDistribute` take the same seam — an optional `getParent` on
+  the adapter and an optional `composition` in the options. Both default to the
+  absolute-pose behavior they have today.
+- 3ecc1be: Dragging a path anchor now edits the anchor on a canvas with no mode registry.
+  The drag used to move the whole shape: anchors sit on the selected body, so
+  `move`'s ambient binding matched the same press as `editAnchors` and won on
+  registration order. `move` now declines a press that hit an anchor or control
+  handle, and the drag falls through to `editAnchors`. Canvases that pass
+  `getActiveMode` were unaffected, because path-edit mode already filters `move`
+  out.
+- dd48085: A window blur now cancels every pointer held on the canvas. A drag in flight
+  ends with reason `'cancel'` rather than waiting for a release that may never
+  arrive, and a press that had not yet become a drag is dropped without a click.
+- efaf707: A loupe can now be edited through. `createLoupe({ views: api, interactive: true })` makes the lens a view on the canvas: a press inside it selects the node it magnifies, and a drag moves that node by the pointer travel divided by the magnification. With `views` alone the lens paints the canvas's own stack but keeps its clicks as an eyedropper; with `source` alone it is the picture it was. A lens given `views` reads back from its canvas's `getSurfaceRect()`, so over a `paintInto` pane it samples that pane without a `region`.
+  
+  Views gained what that needed. `SceneCanvasApi.addView` declares a `<CanvasView>` from outside React, and its `paint: false` hands the drawing to a host such as a HUD window. `<CanvasView view>` accepts a thunk for a camera derived from the canvas's, and `interactive={false}` makes a view paint-only. A registered layer painted over a view — a HUD window over a panel — now takes presses there instead of the view beneath, and a view no longer hit-tests registered layers it does not paint.
+  
+  `hud.window({ interior: 'pass' })` gives the interior's input to what it shows while the frame stays chrome.
+- 7586835: `@weasel-js/geom` is now the single definition of the geometry both packages
+  were carrying, and `@weasel-js/core` imports it.
+  
+  Two of core's command-stream walks had the pen wrong after a `Z`: `boundsOfPath`
+  measured a following curve from the last point drawn rather than the subpath
+  start, and `extractPolylines` flattened one from there. Both are fixed by
+  `forEachSegment`, which now returns the pen where SVG says `Z` leaves it, and
+  which also reports the command index and stops when its visitor returns `false`
+  — the three things core's own walks needed. Ten walks, six Bernstein
+  evaluations, an even-odd ray cast and four rect-corner literals now go through
+  geom.
+  
+  `pathPoseDescriptor.remapBounds` scaled a zero-extent source axis by `0`, which
+  collapsed a flat path onto the destination origin and left a transform that
+  could not be inverted. It uses geom's `boxToBox`, which translates that axis, as
+  `scalePathToBounds` already did.
+  
+  Moved into geom so core no longer keeps a second copy: bezier flattening
+  (`flattenQuadratic` and both arc-length variants included) and `pathCrop`.
+  geom's boolean adapter picks up core's ring nesting, which pre-tests bounding
+  boxes and votes over three sample vertices where geom probed one — a hole
+  sharing a vertex with its container was misclassified.
+  
+  `rectToContour` now emits the four corners with the closing edge implicit,
+  matching what `pointInPolygon` documents and what every call site wants. The
+  repeated first vertex it used to emit is a zero-length closing segment for
+  anything that strokes the result.
+- 6385c68: A container's pose can now define a **frame**: a child's stored pose is
+  expressed in it, so rotating a container rotates its contents and moving one
+  carries them without touching their poses. Opt in with
+  `<SceneCanvas poseComposition={RIGID_POSE_COMPOSITION}>` or
+  `sceneToAdapter(scene, { poseComposition })`. Omit it and nothing changes —
+  poses stay absolute, exactly as before.
+  
+  Before this, nesting contributed a clip chain and nothing else. `getPose` was
+  documented as returning a local pose while every render walk, both pick
+  sources, all selection chrome and the clipboard treated it as world, which
+  agreed only because no consumer ever supplied a composition.
+  
+  `getPose` still returns the stored pose. `getWorldPose` on the scene adapter is
+  the composed reading, and is what picking, chrome, `getNodeAtPoint` and the
+  clipboard consume. `composeRigidPose` / `decomposeRigidPose` and the
+  `RECT_POSE_COMPOSITION` / `RIGID_POSE_COMPOSITION` strategies are exported.
+  
+  `PoseComposition` gains a required `closure` field naming the transforms it
+  represents exactly. This is a breaking change to that interface for anyone
+  constructing one by hand; nothing in the repo did. `RectPose` carries no scale
+  factor, so the strategy that ships is rigid — translate and rotate — and an
+  anisotropically scaled parent is outside what a pose can hold, since it turns a
+  rotated child into a parallelogram.
+  
+  `sceneToAdapter` throws when given both `poseComposition` and
+  `cascadeContainerPose`. The cascade translates every descendant when a
+  container moves, which is what absolute poses need and would move a framed
+  child twice.
+  
+  `useNodeOverlayFrame` read the authored pose, so an overlay ignored gesture
+  overrides and derived poses. It reads the effective pose now.
+  
+  The default actions — resize, rotate, group, clone, flip, align, distribute —
+  read the strategy as a `poseComposition` dep alongside `poseDescriptor`, and
+  `<SceneCanvas>` publishes it through the new `usePoseCompositionDepSource`.
+  A consumer wiring actions without `SceneCanvas` has to publish that dep itself;
+  without it the actions fall back to identity and write world poses into a
+  framed scene.
+  
+  Design: `docs/superpowers/specs/2026-09-10-group-as-frame-design.md`.
+- 2f1ddd0: `@weasel-js/kernel3d` is a new package: poses, an orbit camera, ray picking and screen-projected chrome geometry over core's scene graph and dispatcher. It hosts a renderer rather than owning one — a consumer brings its own and the kernel hands it poses — and it takes core as a peer, the same tier `svg`, `diagram` and `loupe` sit in.
+  
+  Core took no diff for it. `Scene` is generic over its pose and holds a `Pose3` with no adapter; a 3D host passes the dispatcher an identity `clientToWorld` so `ctx.world` stays two numbers and each dep rebuilds the ray from the camera it closes over; tools transfer untouched. The two things that do not transfer are stated rather than guessed: `ViewApi` has no orientation, so the kernel declares a `camera3d` dep of its own, and `PoseDescriptor.remapBounds`/`fromBounds` throw, because a screen rectangle does not name a 3D pose without a depth.
+  
+  `@weasel-js/geom` gains a `./3d` subpath — vectors, quaternions, 4x4 matrices, ray/AABB and ray/plane intersection, and `transformAabb`. Dependency-free like the rest of the package, and immutable tuples rather than classes, so a pose survives `structuredClone` with its methods intact because it never had any.
+  
+  Two corrections to code promoted out of the 3D lab. `projectAabbToScreen` now clips each of the box's twelve edges against the near plane instead of dropping the corners behind it; the old behaviour reported a box too small for anything straddling the near plane, and reported almost nothing for a solid the camera sits inside. And the seam that says how big a node is now asks for its world box rather than a local one to transform: a sphere's box is the same under every rotation, and no transform of a local box reproduces that.
+  
+  `sceneFromJSON`'s `options` argument is now optional. Every field in it already was, so the natural one-argument call did not compile.
+  
+  Also new: a test that a quaternion pose survives `toJSON` and `sceneFromJSON` with its rotation intact. The claim that `Scene` is dimension-neutral had only ever been run against `setPose` and undo.
+- ea285a2: `LayerRecord.locked` now does something. A locked layer still paints, but its
+  nodes are out of reach:
+  
+  - A click, marquee, lasso, double-click text edit, the `nodeAtPoint` dep (drop
+    targets, the eyedropper) and Select All all pass over them. A pick query that
+    only samples paint can take them back with `includeLocked: true`.
+  - The scene's selection never holds one: `setSelection` drops them, and locking
+    a layer drops its nodes from the selection. Undoing the lock puts them back.
+  - Every node mutation on them throws: `add` onto the layer or under a locked
+    container, `setPose`, `update`, `remove`/`removeMany` (including a cascade
+    that reaches one), `setLayer` from or onto the layer, `setDependsOn`, `move`
+    and `reorder`. Kit actions commit through those, so delete, nudge, move,
+    resize, rotate, group, ungroup, reorder, cut and the paint actions refuse too.
+  - A lock covers a container's whole subtree, whatever layers its descendants
+    are tagged to. There is no per-node lock.
+  
+  `scene.isLocked(id)` answers the question, and `scene.unlocked(fn)` runs a
+  programmatic edit with the guard lifted. Undo and redo never need it. The
+  layer operations — the lock toggle itself, visibility, rename, reorder and
+  `removeLayer` — are not gated.
+  
+  `scene.applyBatch`, `scene.batch` and `scene.history.apply`/`applyOps` are now
+  all-or-nothing: an op that throws partway reverts everything the call already
+  applied and records no undo entry. Before, the ops ahead of the throw stayed
+  applied with no entry to undo them.
+- c758b4d: The loupe reads the pixels it is aimed at. Two fixes:
+  
+  - **Its color comes off the frame after the aim.** `loupe.color` and `onColorChange` were read at aim time, which returns the frame before the aim. They now settle on the next frame to land. `pick()` still answers immediately, and now returns `null` if no frame has landed yet. On `@weasel-js/loupe`, a `LoupeSurface` that offers `subscribeFrame` gets this deferred sampling; a surface without it is sampled at aim time, as before.
+  - **It works over a pane of a shared canvas.** `CanvasExtensionApi.getSurfaceRect()` returns the rect of `surface` the canvas paints into: the pane's rect under `paintInto`, otherwise the whole canvas. Pass it as `createLoupe`'s new `region` option. The readback then offsets the aim by the pane's origin and stays inside the pane. Before, the loupe over a `paintInto` pane magnified whatever sat at the same offset from the shared canvas's corner.
+  
+  Anything that implements `CanvasExtensionApi` by hand now has to supply `getSurfaceRect`.
+- a41a83a: `<MinimapCanvas>` takes an `animator` prop and forwards it to its `<SceneViewCanvas>`, so the minimap repaints on the animator's ticks and paints its vertex-color overrides. Pass the main canvas's animator and the minimap shows the same animated colors instead of each node's stored ones.
+- 794b4ff: A number pref can name how its value is shown. `ToolPrefNumber.format` is
+  `'plain'` or `'compact'`, and labkit sets it with
+  `f.number(0).range(0, 2_000_000).format('compact')`. A compact readout keeps a
+  value's precision below a thousand and abbreviates above it at one decimal:
+  `950`, `40.0K`, `2.0M`.
+  
+  `SliderRow` takes the same choice as `notation`, and its readout reads typed text
+  through the new `parseNumber`: thousands commas and a `k`/`m`/`b`/`t` suffix are
+  accepted, so `2.5m` commits 2,500,000. An emptied readout now reverts instead of
+  committing zero. `formatCompact` and `parseNumber` are exported beside
+  `formatNumber`.
+  
+  **A slider readout is no longer narrower than its own values.** The box was a
+  fixed width, so a six-digit value lost a digit and read as a smaller number. It
+  now widens to fit the longer of its formatted `min` and `max`, and rows whose
+  values already fit keep their width. `--wzl-property-readout-w` still sets the
+  floor.
+  
+  `NumberRow` and `PrefsForm` ignore the format: one edits through a native number
+  input that cannot display `2.0M`, and the other's sliders show no value.
+- b65f4df: `RuleCtx` carries a zoom, not a `View`.
+  
+  `zoomAtLeast` is the only selector that ever read the viewport, and one number
+  is all it needs. A host whose viewport is a camera had no `View` to hand over,
+  so it could not build a rule context at all — and a dispatcher with no
+  `getRuleCtx` skips every eligibility rule silently rather than failing.
+  
+  `RuleCtx.view: View` is now `RuleCtx.zoom?: number`, `BuildRuleCtxArgs` the
+  same, and `zoomAtLeast` declines when no zoom is reported. `viewZoom(view)` is
+  exported from `@weasel-js/core` for the 2D callers that now pass it; the legacy
+  `ChromeCtx` shape still carries a `View` and `resolveVisibility` converts.
+- 90f0bd8: Every 2D affine inversion now uses `@weasel-js/geom`'s `invert` and its singularity rule, which judges the determinant against the matrix's own scale.
+  
+  - SVG import now keeps a transform under a uniformly tiny parent scale, such as `scale(0.0000001)`. It used to call that parent singular and bake the child's rotation into the wrong space. A parent that really is singular now drops the child's transform with a warning, and so does a large parent whose determinant is only rounding. `@weasel-js/svg` now depends on `@weasel-js/geom`.
+  - A gradient or pattern measured in `units: 'local'` or `'world'` now draws nothing when that space has no inverse, for example under a group that scales an axis to zero. It used to draw as if untransformed. `mat3.invert` returns `null` for such a matrix instead of the identity, and `PaintBindContext.spaceInverse` now returns `Mat3 | null`, so a registered paint kind should return `null` from `bind` when it gets `null`. Both are type-level breaking changes.
+  - In the custom-shader vertex prelude, `v_world` now reads the world origin when the view has no inverse, instead of a scaled mapping that looked plausible and was wrong.
+  - `useNodeOverlayFrame`'s `toLocal` now keeps the last mapping that had an inverse while a live view flattens an axis. It used to hand the overlay point back unchanged.
+- b5b8b69: A layer one view hides is now gone from that view for input too, not only for
+  paint.
+  
+  - `<SceneCanvas>` documents `layerVisibility` / `layerOrder` as its own props.
+    They already reached the painter; now a click, a marquee, a lasso, Cmd+A and
+    hover in that canvas pass over a scene layer it hides (keyed
+    `scene:<layerId>`). Another view of the same scene still paints and takes it.
+    The scene's own `LayerRecord.visible` still applies underneath and cannot be
+    overridden.
+  - `<CanvasView>` (and `SceneCanvasApi.addView`) take the same two props,
+    applied after `layers` narrows the stack, for its paint and its picking. It
+    now also honors a layer's `defaultVisible`, as the surface does.
+  - `<SceneViewCanvas>`, `<MinimapCanvas>`, `renderSceneToCanvas` and
+    `buildSceneViewCommands` take `layerVisibility` / `layerOrder` keyed the same
+    way, so the main canvas's map can be passed straight to its minimap.
+  - `useSelectTool` takes `alphaOf` and `layerIsPainted`, so a consumer with an
+    adapter and no `Scene` can make faded or unpainted nodes unclickable.
+  - `ViewApi` gains an optional `layerIsPainted`; `selectAll`, `areaSelect` and
+    `lassoSelect` now require the `view` dep and pass it to
+    `AreaSelectDep.hitTestArea` / `LassoSelectDep.hitTestArea` / `hitTestLasso`
+    as a new optional last argument. A marquee or lasso on a canvas with
+    `alphaFor` also skips nodes painted at alpha 0, as a click already did.
+- b2f2d45: Let a `PoseDescriptor` see the node it is describing.
+  
+  Every method on the descriptor took a pose and nothing else, so two shapes
+  sharing a pose type — a sphere and a box both posed by position/rotation/scale —
+  were indistinguishable to it. New optional `forNode(node)` returns a descriptor
+  specialized to one node; `poseDescriptorForNode(descriptor, node)` is the
+  accessor, and returns the descriptor unchanged when it declares no
+  specialization.
+  
+  This widens API. No existing signature changed, so a descriptor that ignores the
+  node compiles and behaves exactly as before. The kit calls `forNode` from the
+  sites that already hold a node — marquee and lasso hit-testing, select-tool
+  picking, selection chrome bounds, the container-pose cascade, the minimap union,
+  `arrayAdapter`, and the move and rotate actions. Sites holding only an id keep
+  reading the unspecialized descriptor.
+- 6f5ff46: Pose geometry is supplied once. `<SceneCanvas poseDescriptor={…}>` tells every
+  built-in action, the selection chrome, picking and area select how to read and
+  rewrite this scene's poses; it defaults to `AUTO_POSE_DESCRIPTOR` (rect and
+  `Path` poses). A pose of any other shape now works end to end — before, dragging
+  one into a container wrote `NaN` into it.
+  
+  Breaking:
+  
+  - `PoseProjection` is renamed `PoseDescriptor`, and gains a required
+    `fromBounds(bounds, template)` and an optional `withRotation(pose, rotation)`.
+  - `ResizePose` and `AlignBounds` are removed; use `Bounds`.
+  - `RotateGeometry`, `AlignBoundsProjection` and `RECT_ALIGN_PROJECTION` are
+    removed.
+  - Removed options, replaced by the descriptor: `selectTool.resize.geometry` and
+    `useResizePolicy({ projection })` (use `<SceneCanvas poseDescriptor>`);
+    `UseRotateOptions.geometry` and `UseMoveOptions.translatePose` (both were
+    unread); `poseBounds` on `useSelectTool`, `arrayAdapter`, `sceneToAdapter`,
+    `MinimapCanvas` and `nestedHitTester` (use their `poseDescriptor` option);
+    `arrayAdapter`'s `intersectsRect` and `translatePose`; the selection overlay's
+    `getBounds` and `fromBounds`; the alignment behaviors' `projection`.
+  - `Canvas`'s `geometry` prop is renamed `poseDescriptor`. `SceneCanvas`'s own
+    `geometry` prop — the `pickEvery` / `boundsOf` hit-test overrides — is a
+    different prop and keeps its name.
+  - `computeFitView`'s fourth argument is a `PoseDescriptor`, not a bounds
+    function.
+  - `sceneToAdapter`'s `cascadeContainerPose` is a boolean; the cascade translates
+    through the descriptor.
+  - The kit's built-in painters only draw rect poses. A node with any other pose
+    needs its own painter.
+  - `Scene` has a read-only `registry`. For a custom pose kind,
+    `unionOfChildrenVia(descriptor)` builds the container-union function to
+    register under `UNION_OF_CHILDREN`.
+- edd5b39: `createPoseFeed(scene)` is the channel a renderer weasel does not own uses to
+  keep its objects in step with a `Scene`. It publishes `added` / `removed` /
+  `changed` with effective poses, so a retained renderer mutates only what moved
+  instead of rebuilding every node's draw record on any change.
+  
+  It reads the scene's two clocks separately. Committed edits bump
+  `Scene.getVersion()` and cost one `O(n)` walk of three reference comparisons per
+  node — the scene mutates node objects in place and swaps their `pose` and `data`
+  references, so it is those the feed snapshots. A drag lives in `Scene.overrides`,
+  which names the ids it touched and costs `O(changed)`, so the walk never runs on
+  the hot path. A `FeedNode` carries the effective pose beside the node's committed
+  one, so a host can draw both without a second channel.
+  
+  The delta carries no order: a host that draws in order re-reads
+  `renderOrderNodes()`, which is cached until a structural edit. The feed does not
+  coalesce notifications either — that is the host scheduler's job.
+  
+  The 3D lab is the first host.
+- 2e2041b: `resolvePreviews(sources, scene)` reads what an in-flight gesture is proposing,
+  with no renderer in it.
+  
+  An ongoing action publishes interim poses on its handle rather than writing them
+  to the scene, and until now `<SceneCanvas>`'s ghost layer was the only thing that
+  knew how to read them: which ids are in flight, whose preview wins when two
+  sources name the same id, which previewed nodes are roots and which are their
+  previewed children, and which are merely displaced rather than dragged. None of
+  that is about drawing. A consumer with its own renderer needed all of it and had
+  to rebuild it from `Dispatcher.getInFlightHandles()`.
+  
+  It returns the previewing subtrees as roots, each carrying the committed node
+  beside the interim pose and data; `flattenPreviews` walks them parents-first.
+  `usePreviewGhostLayer` now draws from it, and the 3D lab under
+  `packages/labkit/examples/3d-lab` reads its drag ghosts through it instead of
+  its own copy.
+  
+  The overlay channel — marquee, lasso, insert preview — is not covered: those
+  arrive as `DrawCommand[]`, which is core's own 2D renderer vocabulary.
+- 65806bc: Fix eleven latent routing faults surfaced by the extraction's correctness pass.
+  All predate the move into `@weasel-js/routing`.
+  
+  - Dispatcher and dep-registry ownership are stacks rather than single slots, so
+    with two canvases under one `<ActionsProvider>` the one still on screen keeps
+    its wiring when the other unmounts. `begin()` no longer returns `null`
+    permanently after that.
+  - An offhand hotkey hold now releases its own tool instead of whatever is on
+    top of the hold stack, so overlapping holds released out of order disengage
+    the right tool.
+  - `reportDeadClaim` no longer reads `process.env` bare. A consumer loading the
+    published ESM in a runtime with no `process` got a `ReferenceError` out of the
+    pointerdown listener on any unmatched exclusive claim.
+  - `ctx.drag.points` accumulates every pointermove vertex for actions that
+    declare no `onMove`. Such an action previously saw only the press point,
+    committing a one-vertex path.
+  - `ContributionsApi.entries` tracks the entry list rather than the entry list as
+    it stood when the focused tool last changed.
+  - The dev-only route-conflict reporter compares ambient entries against each
+    other (it never did), keeps two collisions on different predicates apart, and
+    checks a lone action against itself.
+  - `inFlightCursor` reports the most recently started gesture's cursor, agreeing
+    with `getActiveAction`; the dispatcher breaks same-specificity hotkey ties in
+    favor of the newest hold, agreeing with `ToolsApi.hotkeyEngaged`.
+  - **`Eligibility.capabilities` now gates.** It never did: `liveScope`
+    short-circuits when no `allows` predicate is supplied, and none was. A tool
+    declaring `capabilities` whose action carries no `eligible` rule kept routing
+    input in a mode that forbids those tags. The dispatcher builds the predicate
+    from the `RuleCtx` it already holds — so this changes behavior only for
+    consumers that wired the modes system, which is where the declaration was
+    meant to take effect.
+  - A multitouch handle is ended when the finger count changes rather than left in
+    flight, so a third finger landing mid-pinch no longer commits two gestures on
+    the final lift.
+  - The route-conflict reporter buckets each key alternative separately, so
+    `key: ['h','H']` is reported as colliding with `key: 'H'`. `RegistryEntry`
+    gains an optional `argAlternatives` carrying them.
+- a614be4: Extract binding-to-action routing into `@weasel-js/routing`.
+  
+  The gesture dispatcher, the action registry and invoker, tool and contribution
+  declaration, the route grammar's reflection surface, and the eligibility rule
+  algebra now live in their own package beside `@weasel-js/gestures` and
+  `@weasel-js/history`. It ships two entry points: the pure dispatcher on the main
+  entry — no React, no DOM — and the React seam that pumps browser events into it
+  behind `@weasel-js/routing/react`, with React an optional peer. A kernel that
+  drives routing itself can take the first without the second.
+  
+  `@weasel-js/core` depends on the new package and re-exports every symbol that
+  moved, so **no existing import changes**, including `@weasel-js/core/routing`.
+  A consumer that adds its own dependency still writes
+  `declare module '@weasel-js/core'`; the merge carries through core's re-export.
+  
+  `createPaintedCursorState` and its types move to `@weasel-js/cursor`, where the
+  cursor they hold is declared. `@weasel-js/core` re-exports them unchanged.
+- ef60ff6: The routing layer's types now state where the dispatch boundary runs, instead of leaving it implicit inside two large interfaces.
+  
+  `Action` splits into `ActionDispatch` — bindings, deps, invoker, scope, gates, cursors — and `ActionPresentation`: label, icon, group, shortcut. `Contribution` splits the same way into `ContributionRouting` and `ContributionChrome`. Both composed types keep every field they had, so nothing that authors an action or a contribution changes.
+  
+  New alongside them: `BindingSource`, the id-plus-`defaultBinding` shape `actionBindings` reads; and `ActionSource`, the single `list()` method the gesture dispatcher consults a registry through. `actionBindings`, `BoundGesture`, `evaluateEnabled`, `ActionEnabledResult`, `SliceDep`, `ClipboardDep` and `TextEditDep` are re-exported from the same barrel entries as before, from new homes. `ClaimableGesture` now lives in `@weasel-js/gestures` beside `GestureName`, and is still exported from `@weasel-js/core`.
+  
+  `_resetEnabledWarnsForTests` is removed. It had no callers and was never on the public barrel.
+  
+  Under this, core's import graph loses a 15-file strongly connected component spanning contributions, tools, actions, the dep schema and the dispatcher. Nothing in routing, tools or contributions is in an import cycle now.
+  
+  The consumer smoke test gained a check that a consumer's own `declare module '@weasel-js/core'` dep merges into `DepSchema` against the published declarations, and stopped reading a subpath import such as `@weasel-js/geom/booleans` as an undeclared package.
+- 269d432: Animated vertex colors now reach nodes the scene paints itself. `<SceneCanvas animator>` paints `animator.colorOverrides` — what `tweenVertexColors`, `springVertexColors`, `cycleVertexColors` and `staggerVertexColors` write — onto the scene's nodes: the built-in path, shape and derived-path painters apply them, and a custom `drawOne` receives them as the new `NodePaintCtx.vertexColors`. Before, only `createPathLayer` read the registry, so a default-painted node ignored every color animation.
+  
+  The same colors reach detached renders: `<SceneViewCanvas>` takes an `animator` prop, and `renderSceneToCanvas`, `renderSceneToPixels` and `buildSceneViewCommands` take the registry as `colorOverrides`. `ColorOverrideRegistry` gains `has(id)` and `resolve(id, channel, base, tMs)`, the one resolution `createPathLayer` and the scene walks now share.
+  
+  Path nodes also paint fill vertex colors from `data.vertexColors`, the same field `PathDrawCommand` uses.
+- 486f631: `staggerVertexColors` no longer jumps straight to its end colors. It published a function-form override that read its timestamp as time since the stagger began, but `createPathLayer` calls a function-form override with `performance.now()`, so on screen every anchor finished the moment the stagger started. The helper now publishes a plain color array on each tick, the same way `tweenVertexColors` does.
+- 0f374d8: `kit:text` nodes with `align: 'center'` or `'right'` now align within
+  `pose.width`. They were anchored on `pose.x`, so centered text hung half outside
+  the left edge of its box and right-aligned text ended at that edge.
+  
+  Alignment has its own width, separate from the wrap width:
+  `LayoutRunsOpts.alignWidth` and `TextDrawCommand.width`, both defaulting to
+  `maxWidth`, and a trailing `width` argument on `textCommand` /
+  `textCommandFromRuns`. The painter passes its pose width there and still does
+  not wrap. `textLineBoxes` and `caretIndexAt` align within `pose.width` even at
+  `maxWidth: Infinity`, so the silhouette and the caret follow the paint. A
+  `layoutRuns` call or text command that sets no alignment width lays out exactly
+  as before.
+- d25a09d: `useSceneTextEdit`'s editing overlay now follows the canvas's pan and zoom
+  without being handed a `view`. It reads the camera from the weasel canvas
+  mounted inside the `container` it is given — the canvas a double-click landed
+  on, when there are several — so the overlay's text sits on the glyphs it
+  replaces at any zoom. Passing `view` still works and still wins.
+  
+  The overlay is also clipped to that canvas's box, the same place the canvas
+  clips its glyphs. A zoomed text node used to paint its editor across the page
+  beside the canvas. Clipping the container with `overflow: hidden` was no fix:
+  the browser scrolls a `hidden` box to keep the caret in view, so typing past
+  the edge dragged the canvas sideways. The clip cannot scroll.
+  
+  `useTextEdit` gains the underlying option, `getClipRect`: a box in container
+  pixels to clip the overlay to, re-read every frame. The overlay now mounts
+  inside a clip box of its own, one level below `container`, rather than as the
+  container's direct child. With no clip rect, nothing is clipped.
+- deb9e79: Text wraps only where its style says so, and everything that lays a text node
+  out now agrees. `TextStyle.wrap` (default `false`) breaks lines between words
+  at the pose width; without it a line runs as long as its text and the width
+  only resolves `align`.
+  
+  Before this, `kit:text` never wrapped while `createTextLayer`, `textLineBoxes`,
+  `caretIndexAt`, `fitTextPose` and the edit overlay all wrapped at the pose
+  width. Opening an edit on a `kit:text` line longer than its box reflowed it,
+  and a double-click could put the caret on a line the canvas never drew.
+  
+  **Breaking:**
+  
+  - `createTextLayer` and `fitTextPose` (`axis: 'height'`) no longer wrap unless
+    the style sets `wrap: true`. Add it to text that should keep wrapping.
+  - `TextLineBoxesOpts.maxWidth` and `caretIndexAt`'s `opts` argument are gone,
+    along with the `CaretIndexAtOpts` type. Both read `style.wrap`.
+  - The edit overlay is `white-space: pre` for unwrapped text, sized to its
+    content, and never breaks inside a word in either mode.
+  
+  New: `layoutTextPose` and `textPoseLayoutInput` in `@weasel-js/text`, and
+  `textCommandFromPose` in `@weasel-js/core`, which `kit:text` and
+  `createTextLayer` both emit. `textLineBoxes` and `caretIndexAt` now resolve
+  `align: 'start' | 'end'` against `direction` as the painters do, and
+  `useSceneTextEdit` maps a double-click through the node's `verticalAlign`
+  (`getVerticalAlign` for custom data), which it used to ignore. SVG export
+  writes `data-weasel-wrap="true"` and import reads it back.
+- 830cf7e: A timeline can now book its events ahead of the frame against an outside clock,
+  so a sound lands at its true sub-frame time rather than on whichever frame
+  noticed the crossing. Pass `booking: { clock }` to `animator.timeline()` and give
+  an event a `book(when)` handler; `clock` is anything with `now()` in ms, and an
+  `AudioEngine` from `@weasel-js/audio` is one:
+  
+  ```ts
+  animator.timeline({
+    booking: { clock: engine },
+    tracks: [{ kind: 'event', events: [{ t: 500, book: (when) => engine.play(hit, { when }) }] }],
+  });
+  ```
+  
+  Each event is booked once per crossing, up to `lookahead` clock ms before its
+  edge (default 100). Returning a handle with `stop()` — a `VoiceHandle` is one —
+  lets a pause, seek, time-scale change, loop change, `edit` or cancel retract the
+  booking while the clock has not reached it; playback books it again wherever it
+  next reaches the event. A seek never books the span it skips. An event first
+  reached after its edge books at `clock.now()`, or is skipped once it is later
+  than `maxLate`. The frame clock's mapping onto the booking clock is smoothed per
+  frame, so per-frame read jitter does not reach `when`, and resynced when the two
+  jump apart.
+  
+  `TimelineEvent.fire` is now optional, since an event may only book. Reading
+  `event.fire` directly needs a check for `undefined`.
+- 50d2881: A number pref with a display unit now reads a unit typed into it: `0.25turn` or
+  `30°` in the rotation field stores π/2 or π/6, and `12mm` in a field showing
+  centimeters stores what 1.2cm is.
+  
+  **`prefUnit(system, displayUnit, { precision?, suffix? })`** builds a
+  `ToolPrefNumberUnit` from a `UnitSystem`, so a leaf no longer hand-writes its
+  conversion. `ToolPrefNumberUnit` gains `accepts`, the units a person may type
+  and the factor each scales by. `ANGLE_RADIANS` joins the unit tables, and
+  `rotationDegreesUnit` is built from it.
+  
+  **`parseNumber(text, units?)`** reads a trailing unit, longest name first, and
+  a unit beats a magnitude suffix: with meters accepted, `2m` is two meters.
+  
+  **`UnitField`** is a text field for a number that can carry a unit. Both
+  `SelectionPanel` and `PrefsForm` edit a unit leaf through it; a leaf with no
+  unit keeps `NumberField`.
+- a5f738a: Resolve a screen rectangle at a pose's own depth, and stop deriving a group's
+  bounds from poses the kit cannot read.
+  
+  `kernel3d`'s `PoseDescriptor.remapBounds` and `fromBounds` threw: a rectangle on
+  screen names a pose only once something says how far away it is. Both now
+  resolve it on the plane through the pose they were handed, facing the camera, so
+  neither changes depth. A resize scales uniformly — two screen extents cannot
+  name three — and `fromBounds` returns a world-axis-aligned box whose third
+  extent is the mean of the two the rectangle gives it.
+  
+  `core`'s `unionOfChildren`, which every scene carries under
+  `kit:unionOfChildren`, read its members as rects with no check and produced a
+  box of `NaN` in a scene posed otherwise. It now declines, and the container
+  keeps its authored pose; `unionOfChildrenVia(descriptor)` remains the way to
+  make such a container track its members.
+- ab90aa7: Views now clamp zoom to a positive floor. A view's zoom is always finite and at
+  least `ZOOM_FLOOR` (1e-9); a zoom of 0, a negative one, `NaN` or `Infinity`
+  becomes the floor, and a non-finite position becomes 0. Dev builds warn once
+  when that happens. A negative `View.scale` axis is still a flipped (y-up) axis
+  and keeps its sign.
+  
+  The rule lives in `normalizeZoom`, with `normalizeView` applying it to a `View`,
+  and every place a view enters the kit goes through it: `<Canvas>` and
+  `<SceneCanvas>` (the `view` and `defaultView` props, `setView`, the `view` dep),
+  `<CanvasView>` (including a thunked `view`), `<SceneViewCanvas>`,
+  `<MinimapCanvas>`, `createViewportLayer`, camera animation targets, `zoomAt`,
+  `fitViewToBounds` and `fitZoom`. In labkit, `CanvasStack`, `Stage`, `usePanZoom`,
+  `zoomAt`, `centerOn`, `ZoomControl`, a trial's zoom chrome and `as2DView` do the
+  same through the new `normalize2DView` and `withZoom`. A loupe's magnification
+  follows the same rule.
+  
+  So `screenToWorld`, `canvasCoords` and affordance hit-testing stay finite
+  without handling a zero zoom themselves. `pxExtent` no longer guards a zero
+  axis, which a view can no longer have, and labkit's `zoomAt` now treats a
+  non-finite opening zoom as the floor rather than as 1.
+- Updated dependencies [7586835]
+- Updated dependencies [2f1ddd0]
+- Updated dependencies [b65f4df]
+- Updated dependencies [aa45d32]
+- Updated dependencies [65806bc]
+- Updated dependencies [a614be4]
+- Updated dependencies [ef60ff6]
+- Updated dependencies [0f374d8]
+- Updated dependencies [deb9e79]
+  - @weasel-js/geom@1.5.0
+  - @weasel-js/routing@1.5.0
+  - @weasel-js/cursor@1.5.0
+  - @weasel-js/gestures@1.5.0
+  - @weasel-js/text@1.5.0
+  - @weasel-js/font@1.5.0
+  - @weasel-js/history@1.5.0
+  - @weasel-js/paint@1.5.0
+
 ## 1.4.4
 
 ### Patch Changes
@@ -1279,1951 +2223,158 @@
   - @weasel-js/modes@1.4.0
   - @weasel-js/paint@1.4.0
 
-## 1.4.0-pre.1
+## 1.3.0
 
-### Patch Changes
+### Minor Changes
 
-- 36b6ee7: Add `@weasel-js/cursor` and give three tools real cursors.
-  
-  A cursor glyph is SVG path `d` strings tagged with a paint role plus a hotspot
-  in glyph units — the one geometry form both a data-URI baker and a `Path2D`
-  painter consume without translating. `bakeCursor` renders one to a
-  `url(data:image/svg+xml,…)` string with the hotspot scaled to integer CSS px,
-  and `cursorFor` memoizes that per name and size. The pencil, pen and eyedropper
-  tools now show their own glyph instead of a shared `crosshair`.
-  
-  Cursors ship as SVG with no bitmap fallback: Chrome rasterizes an SVG data-URI
-  cursor at device scale, so it is already crisp on a retina display. `bakeCursor`
-  throws above 128 CSS px rather than emitting a cursor the browser would drop
-  silently — that size is where a later painted tier will take over.
+- bca99e3: Extract the typography layer into `@weasel-js/text`, and the paint vocabulary
+  into `@weasel-js/paint` — two new Tier A leaves.
   
-  Glyph geometry is authored in `scripts/glyphs/` and generated to resolved
-  literals by `npm run gen:cursors`; `npm run proof:cursors` renders the baked
-  assets over three backgrounds for inspection.
+  `@weasel-js/text` owns the run model, style resolution, `layoutRuns`, wrap and
+  measurement. It depends on `@weasel-js/font`, `@weasel-js/geom` and
+  `@weasel-js/paint`, and on nothing else: a consumer with its own renderer can
+  lay out text without taking the scene graph or a React peer dependency.
+  `layoutRuns` is now public — it was previously reachable only from inside core.
   
-  New API: `bakeCursor`, `cursorFor`, `GLYPHS`, `haloFitsInBox`, `CursorGlyph`,
-  `CursorPath`, `CursorGlyphName`, `BakeOptions`, and the register constants
-  `CURSOR_INK`, `CURSOR_HALO`, `CURSOR_HALO_WIDTH`, `CURSOR_MAX_CSS_PX`.
-- Updated dependencies [36b6ee7]
-  - @weasel-js/cursor@1.4.0-pre.1
-  - @weasel-js/font@1.4.0-pre.1
-  - @weasel-js/geom@1.4.0-pre.1
-  - @weasel-js/gestures@1.4.0-pre.1
-  - @weasel-js/history@1.4.0-pre.1
-  - @weasel-js/modes@1.4.0-pre.1
-  - @weasel-js/paint@1.4.0-pre.1
-  - @weasel-js/text@1.4.0-pre.1
-
-## 1.4.0-pre.0
-
-### Minor Changes
-
-- 1214ff5: Split a canvas's paint target from its input target.
+  `@weasel-js/paint` holds `FillStyle`, `Stroke`, gradients, dashes and
+  `TextureHandle`. It was the blocker named in the 2026-07-28 font split: the
+  layout could not move while its fill type lived in the renderer's graph.
   
-  `<SceneCanvas paintInto={{ canvas, x, y }} inputElement={el}>` paints into a
-  rect of a canvas you own and takes pointer input from an element you own, so N
-  canvases share one GL context and one buffer. Each needs its own
-  `<WeaselProvider isolate>`.
+  `@weasel-js/core` re-exports both surfaces, so its own API is unchanged.
+  `Rect` moves to `@weasel-js/geom`, beside `Box`.
   
-  The ref handle names both elements: `element` is where input, focus and the
-  cursor live, and is now typed `HTMLElement` because detached it is not a canvas;
-  `surface` is where pixels land. Attached, they are the same `<canvas>` and
-  `element` keeps working as before. The HUDs render when detached too, anchored
-  to the input box rather than to the shared surface every pane sits in.
+  Breaking for anyone importing these through core's internal paths rather than
+  its public entry (`core/paint-types`, `features/text/*`); those paths are gone.
   
-  Breaking, narrowly: `createLoupe`'s `element` option is now `canvas`, with an
-  optional `input` for the element aim is measured against.
-  `CanvasExtensionApi.element` no longer satisfies an `HTMLCanvasElement` — read
-  `surface` for pixels. And `clientToWorld`'s first parameter widens to
-  `HTMLElement`, which stops compiling for a consumer who annotated that parameter
-  as `HTMLCanvasElement`; one who let it infer is unaffected.
+  Advances and kerning still come from a baked MSDF atlas — laying out from font
+  bytes alone needs the metrics seam in
+  `docs/superpowers/specs/2026-08-28-text-package-extraction-design.md`.
   
-  <!-- bump-approved: minor: Mike — the labkit annotations arcs 1-4 (a shared drawing surface, a mark store, the overlay, and capture/export) plus this split of a canvas's paint target from its input target, on top of ~30 patch changesets carrying new public surface across core, ui and labkit; called explicitly in conversation on 2026-09-03: "we were going to cut a 1.4.0-pre release" -->
+  <!-- bump-approved: minor: Mike — two new published packages (@weasel-js/text, @weasel-js/paint) and layoutRuns promoted to public API, on top of ~50 patch changesets carrying new public surface across core, ui and labkit; called explicitly in conversation on 2026-08-29: "tag a minor release and push" -->
 
 ### Patch Changes
 
-- 5295c34: Draw on a lab's instrument: the `annotations` capability gets its overlay.
-  
-  An instrument that declares `annotations` now gets a drawing surface on every
-  target it names — weasel tools, weasel selection, marks that pan and zoom with
-  what they mark — plus a palette (select, freehand, line, arrow, rectangle,
-  ellipse, text) and its own tool slot. `useAnnotations()` reaches the store from
-  the instrument's render or from a chrome contribution, and re-renders its
-  caller as marks change.
+- 52c7b2a: Depend on `font` and `core` as exact peers
   
-  The lab's shared surface grew the buffer that makes this possible: one
-  `<canvas>` over `.lk-lab__body`, and `SurfaceHandle.registerPainter`, which is
-  how a resize of that buffer reaches every tile rather than the one that moved.
-  `getContainer()` names the element tile rects are measured against.
+  `@weasel-js/font` and `@weasel-js/core` keep registries that consumer code
+  writes into — registered faces and glyph-ready subscribers in one, content
+  handlers and paint kinds and shape painters in the other. Two physical copies
+  in a tree are two registries, so a face registered into one while layout
+  resolves against the other lays out nothing and the canvas is blank.
   
-  A mark is a weasel scene node in a scene of its own per target — a pane's
-  hit-test, marquee and paint walk the whole scene they are handed, so one shared
-  scene would put a neighbour's marks under the pointer. An annotation's id is
-  therefore `<target>/<node>`, and `createAnnotationStore` takes `targets` alone
-  plus an optional `restore`; `SerializedAnnotations` carries `scenes`, keyed by
-  target. Marks still do not survive a reload — the storage slot is the next arc.
+  Exact sibling pins are what produced the duplicate: a consumer mixing two
+  weasel releases left npm no choice but to nest a second copy, silently. As
+  peers, the same mix is an `ERESOLVE` at install time. `font` is now a peer of
+  `core`, `hud` and `text`; `core` is now a peer of `svg`, joining `d3`, `hud`
+  and `ui`, whose `>=` ranges tighten to exact so no version mix resolves by
+  accident.
   
-  Core adds `ArrowIcon` to the built-in tool glyphs.
-- 2fbf611: Give a canvas its own provider scope with `<WeaselProvider isolate>`
+  **This can break an install that currently succeeds.** Anyone resolving a
+  mixed set of weasel versions by luck now gets an install error instead of a
+  blank canvas. That is the point, but it is a break.
   
-  An actions registry holds exactly one dispatcher, so a second `<SceneCanvas>`
-  joining a scope displaced the first and took its input away. Worse, the
-  detach was unconditional: whichever canvas unmounted — or merely re-rendered
-  with a new dispatcher identity — cleared the slot for the one still on screen.
-  The symptom was a canvas that stopped responding, naming neither canvas nor the
-  registry they shared.
+  `labkit` deliberately keeps `core` as an ordinary dependency: its build aliases
+  every core entry point to core's built files and inlines them, so it never
+  resolves core at the consumer and has nothing to peer. The flip side is that
+  labkit ships its own copy of core's registries, so a consumer using both still
+  has two — this change does not address that.
+- 3386d64: Align, distribute and flip use visual bounds
   
-  `isolate` mounts every provider unconditionally instead of deferring to one
-  already in scope, so canvases that merely coexist get a scope each. This is the
-  shape consumers had already reached for by hand: `AnimationDemo` and
-  `BooleanOpsDemo` both mounted raw `ActionsProvider` / `SelectionContextProvider`
-  / `DepRegistryProvider` to shadow the ambient scope, and both now say `isolate`
-  instead.
+  These folded each member's unrotated pose box, so "Align Left" on a selection
+  containing a rotated shape lined up the boxes and left the rotated shape's ink
+  sticking out past the others. They now work on the visual bounding box, as
+  Figma and Illustrator do.
   
-  `setDispatcher` and `setDepRegistry` return a release that clears the slot only
-  while the caller still holds it, so a departing canvas can no longer disable a
-  surviving one. A second dispatcher claiming an occupied registry warns once,
-  naming `isolate` as the fix.
+  Both ends moved together — expanding only the union would have made alignment
+  worse, since the delta runs from an edge of the union to the same edge of each
+  member's box. The new exported `visualBoundsViaDescriptor(pose, geometry)`
+  reads a pose's bounds, recovers its rotation and expands via
+  `axisAlignedBounds`; the union folds those with `unionAABB`. The delta is still
+  applied as a translation of the stored pose through
+  `translatePoseViaDescriptor`, so a shape moves rather than being re-posed.
   
-  Two canvases still cannot *share* one registry: a toolbar outside both has
-  nothing to say which one it drives. That needs a focused-canvas concept and is
-  not in this change.
-- 7a0c568: Tell an event handler how late its crossing is
+  Flip needed only its union pivot changed: mirroring maps a centre and preserves
+  size, and an expanded box is concentric with the box it came from.
   
-  `EventTrack`'s `fire` took no arguments, so a handler could only ask its own
-  clock for "now" — when the frame was processed, not when the playhead crossed
-  the edge. That held footstep scheduling in the side-scroller at frame
-  resolution against an audio engine built for sample resolution: a measured peak
-  spread of 33–47 ms on the looping run cycle.
+  `alignMoveBehavior` folds the dragged selection the same way, so a drag snaps
+  by its ink.
+- ffafb7d: Never let an animation's virtual clock run backwards.
   
-  `fire(lateBy)` reports the gap between the crossing and the frame carrying it,
-  in timeline ms. It is never negative, including on the loop seam, where the
-  outgoing lap's tail fires after the playhead has already wrapped — the case
-  that makes a handler comparing against `handle.time()` read a negative
-  lateness. A nested timeline's events report the same figure as a top-level
-  one's; the track's offset cancels.
+  `useAnimator` seeds each animation's `lastRealNow` from `now()` at register
+  time, then advances its virtual clock by the difference against the timestamp
+  the frame loop supplies. Those two share a time origin in a browser, where the
+  rAF timestamp and `performance.now()` are both page-relative — but that is a
+  browser guarantee, not a universal one, and jsdom starts them roughly 600ms
+  apart. The first frame's delta then came out hugely negative and `virtualNow`
+  spent dozens of frames climbing back toward zero before a tween advanced at
+  all: a 40ms glide took 95 frames and over a second of wall time, growing worse
+  the longer the process had been alive.
   
-  Nothing has to change to compile: a zero-argument function is assignable to the
-  new signature.
+  A frame's elapsed time is never negative, so the sample is now clamped at
+  zero. Under a shared origin this is a no-op.
+- ba8b139: Camera animation: `viewport.animatedZoom` now does something
   
-  `lateBy` is a delta, not a clock reading, so events from two different
-  timelines still cannot be ordered against each other. That would need the
-  animator's virtual clock made public, which this does not do.
+  `animatedZoom` has been declared on `SceneCanvasProps.viewport` and read by
+  nothing; Cmd+=/-/0 was a bare `view.set`. It now routes the discrete zoom steps
+  through the kit's `Animator`. Wheel and pinch are unchanged and never animate —
+  their input already delivers a sample per frame.
   
-  `SideScrollerDemo` now places each footfall a fixed budget after its true
-  crossing, so which frame happened to notice a contact turns into constant
-  latency rather than audible spread.
-- a7fa697: Add an anchored-placement solver and keep HUD windows on their host.
+  Camera animation is a general surface, not a zoom flag. Three ways in, one
+  runner behind them:
   
-  `@weasel-js/geom` gains `placeRect` and `clampRectWithin`. `placeRect` resolves an
-  overlay against an anchor: it picks a side, flips to the opposite one when the
-  preferred side has no room, and slides along the alignment axis to stay inside a
-  boundary. `clampRectWithin` is the containment half on its own — move a rect the
-  shortest distance that puts it inside a boundary, keeping its size. Both are pure
-  and take an explicit boundary rect, so a boundary that does not start at the
-  origin resolves correctly.
+  - `useViewAnimation(view, animator?)` — `animate`, `animateToBounds`, `stop`,
+    `isAnimating`, `target`.
+  - The `view` dep gains optional `animate` / `stopAnimation` / `animationTarget`,
+    so any action can glide the camera.
+  - `SceneCanvasApi` gains `animateView` / `stopViewAnimation` /
+    `isViewAnimating` for fit-to-selection, recenter, or a scripted tour. All
+    three are **required** members: anyone hand-implementing `SceneCanvasApi`
+    (a test double, a wrapper) has to add them, the way `CanvasExtensionApi`
+    grew `getPaintedVersion`.
   
-  A HUD window could previously be dragged fully off its host with no way to
-  recover it: `createWindow` clamped size but never position. Move drags and
-  `setBounds` now keep the window on the host. Resize drags are deliberately left
-  alone, so pulling an edge past the host does not fight the gesture.
+  Scale interpolates geometrically and translation is derived from the screen
+  point the two views agree on, so a zoom stays anchored instead of drifting and
+  each frame changes the view by the same ratio. One animation runs at a time; any
+  other view write cancels it, and a cancel leaves the camera where it is rather
+  than jumping to the target. On an uncontrolled canvas the whole animation costs
+  no React render.
   
-  `@weasel-js/core` gains `hostAnchorRect`, `hostAnchorCss` and `useHostAnchor`,
-  which hold a fixed-position panel against a host element's corner and keep it
-  inside the viewport. The corner is an alignment per axis rather than a fixed
-  one, and `useHostAnchor` takes a function that resolves the host, so a host held
-  in a ref and one found by selector work the same way.
+  **Breaking:** `useViewTween` is removed. `useViewAnimation` keeps its name and
+  changes signature — it takes a `{ get, set }` view channel plus an optional
+  `Animator`, and `animateTo(from, to, { duration, easing })` becomes
+  `animate(to, { ms, easing })`. The `from` argument is gone because the runner
+  reads the live view, which is what lets an interrupted camera resume from where
+  it actually is instead of snapping back to a captured start. `cancel()` is now
+  `stop()`, and `animateToBounds(bounds, currentView, dims, { duration })` is now
+  `animateToBounds(bounds, dims, { ms })` — the `currentView` argument goes for
+  the same reason `from` does.
   
-  `hostAnchorCss` pins whichever edges the alignment names. That is not cosmetic:
-  a panel whose width tracks its content holds the anchored edge still and grows
-  away from it, so pinning the wrong edge makes the anchored corner drift on every
-  content change.
+  **Breaking:** `viewport.recenter` and `ViewApi.recenter` widen to
+  `() => View | void`. Returning the target view lets Cmd+0 animate there;
+  returning nothing keeps the existing behavior. `animatedZoom`'s config fields
+  are `ms` / `resetMs` rather than `duration` / `resetDuration`, matching the
+  animator's vocabulary.
+- 3fb3a46: Forward `onFocus` and `onBlur` from the canvas element
   
-  Four places were carrying their own copy of that anchor math and now share this
-  one — `CursorCoordsHud`, `PickHud`, `ModalityHud`, and WeaselDraw's
-  `DispatchTracePanel`, which anchors the opposite corner. None of the four
-  clamped, so a panel could hang off the edge when the host was scrolled or the
-  panel was tall.
-- 2272682: `createParallaxLayer` takes an optional `getOuterView`, so a plane can derive
-  from a ref-driven camera. It previously derived only from the canvas's `view`
-  prop; a consumer keeping a 60 Hz camera out of React state pins that prop to
-  identity and got identity back for every `pan` value — a backdrop that silently
-  never moved.
+  The canvas is focusable by default (`tabIndex` 0) but exposed no way to
+  observe focus, so consumers driving focus-dependent chrome had to attach a
+  listener to an ancestor and infer it. Both are now props on `CanvasProps`, and
+  so reach `SceneCanvasProps` and the canvas element unchanged.
+- 67bcb05: Drop four values the canvas layer memo no longer reads
   
-  `useHandTool` no longer builds a velocity tracker and a decay loop it never
-  uses. `inertia` and `axis` were already inert; they are now documented as such
-  until the `viewport.dragPan` action implements them.
-- 503b56d: Fix two path-walker bugs that produced wrong geometry with no error.
-  
-  `tessellate` treated `Z` as a no-op, so a command following a close flattened
-  from the last point drawn rather than from the subpath start — SVG puts the pen
-  back at the start. `pathDistanceToPoint` dispatched through an `if`/`else if`
-  chain with no final `else`, so an unrecognized command code left the coordinate
-  cursor unadvanced and silently misaligned every later read; it now throws.
-- ac2deea: Add `polylineFromPoints` — the open counterpart to `polygonFromPoints`.
-  
-  Same geometry, without the closing edge. A freehand stroke or a measurement
-  line wants this; a region wants the closed one. The pencil tool's drag preview
-  was building its ghost with `polygonFromPoints`, so the edge from the newest
-  sample back to the first swept across the drawing as the stroke grew and read
-  as a marquee.
-- 23ffb2f: `WeaselRenderer` can draw into a rect of a buffer it does not own.
-  `setTarget({ origin, clear })` applies a viewport and scissor inside `render()`,
-  so N renderers can share one WebGL context and one canvas without a frame clear
-  erasing a co-tenant. The rect's size is the renderer's own `width`/`height`, so
-  `resize()` remains the single source of it.
-  
-  Adds API. Two behaviour changes for existing callers: `render()` now
-  re-establishes blend, depth, cull and clear colour every frame instead of once at
-  construction, so a co-tenant moving that state no longer corrupts weasel's
-  frames; and the constructor now throws when handed a WebGL2 context whose
-  attributes report no stencil buffer, which previously rendered clips and even-odd
-  fills wrong rather than failing. A context that cannot report its attributes is
-  unaffected.
-- 016851c: Stop a stroke with no paint from blanking the whole document.
-  
-  `SelectionPanel`'s object leaf started from `{}` when the node held no value
-  yet, so editing any non-paint field of `data.stroke` on an unstroked node
-  committed that field alone — a `Stroke` with no `paint`, which the type
-  forbids. The leaf's declared `default` was dead for writes; it now seeds from
-  it, so writing one field materializes a complete value.
-  
-  Such a stroke threw out of `fillInPoseFrame`, and the throw escaped the painter
-  and took the frame with it: the document page and every other node vanished,
-  and the canvas stayed stale until something unrelated requested a redraw — so
-  WeaselDraw opened on an empty workspace and only drew once the pointer moved.
-  `resolveNodeStroke` now reads a paintless stroke as no stroke, and the text
-  painter routes through it like every other painter. The frame loop no longer
-  loses its dirty flag when a paint throws, so one bad frame is retried rather
-  than stranding the surface.
-- c9dd37f: Render text decorations as a toggle row, and ship a builtin font-family control
-  
-  `SelectionPanel` rendered every boolean leaf as a `Switch`, ignoring the leaf's
-  `control` entirely — so the three text decorations arrived as three switch rows
-  where every text editor puts one row of U / S / O. `ToolPrefBooleanControl` now
-  accepts `'toggle'`, `ToolPrefBoolean` carries a `short` label for it (the pair
-  takes the row's name, leaving the leaf only a glyph's worth of room), and the
-  panel honors both. Core's text schema asks for it: `underline`,
-  `strikethrough` and `overline` share a `Decoration` pair.
-  
-  A run of adjacent leaves sharing a `pair` renders as one `ToggleBar`, not one
-  bar per leaf — the same segmented control the `Align` row beside it already
-  draws. Each segment still writes only its own leaf, so flipping one decoration
-  never invents values for the other two. An unset toggle is left unselected
-  rather than dimmed: unselected is what a toggle button's off state means, and
-  the dimming the `Switch` path uses for the same case reads as disabled on one.
-  A leaf a consumer claims with its own `renderers` entry drops out of the run.
-  
-  `FontFamilySelect` moves from WeaselDraw into `@weasel-js/ui`, and
-  `SelectionPanel` reaches for it on a `font-family` leaf. Core's own default
-  text schema declares that kind, so a consumer passing no `renderers` — the
-  Storybook story, any app taking the defaults — got the literal
-  `(font-family: no renderer)` placeholder where the font picker belongs. The
-  control offers both tiers that can actually paint and probes substitution at
-  the node's own weight and style, so its label names the variant that will
-  render. `@weasel-js/ui` now depends on `@weasel-js/font`.
-- 9a000ea: A stroked text node now gets hit reach from its stroke. `TEXT_PAINTER` declared
-  no `ink`, so picking fell back to a zero-outset default and a heavily outlined
-  glyph was unpickable across the width of its own outline.
-  
-  `kit:derived` also now evaluates ahead of `kit:path` / `kit:shape` / `kit:image`.
-  A derived node whose `data` happens to carry a `path`, `shape` or `image` field
-  was silently painted by those painters instead of from its derived path.
-- 016851c: Add an editor surface for superscript, subscript and overline.
-  
-  `StyledRun.script`, `baselineShift`, `fontScale` and `overline` reached layout,
-  SVG and the DOM overlay but nothing could apply them. The character bar now
-  carries an x² / x₂ pair, an overline toggle beside B / I / U / S, and the two
-  primitives `script` presets — baseline shift and scale — as percentage fields
-  that show what the preset supplies and override just that half when typed over.
-  `overline` also joins the sidebar's node-level Character group. Superscript and
-  subscript take Cmd+Shift+= and Cmd+Shift+-; the unshifted pair is browser zoom,
-  which a page cannot cancel.
-  
-  A styling written at a collapsed caret now arms `useTextEdit`'s new
-  `pendingStyle` and applies to the next character typed, instead of being
-  dropped or restyling the whole node. That is what `script` needs — it has no
-  node-level counterpart to write to by design — and it makes the bar agree with
-  Cmd+B, which already behaved this way. `rangeStyle` reports the styling *at* a
-  collapsed caret rather than `{}`, and `toggleStyle` is public.
-  
-  Three fixes fall out of putting both paths through one implementation:
-  lowering a flag the node sets now works from the bar and from a collapsed
-  caret, not only from the keyboard over a range; a toggle reads the node's flags
-  as well as the runs, so Cmd+B inside a `fontWeight: 700` node clears bold
-  instead of adding it; and focus returns to the text after a styling control is
-  clicked, so typing continues in the document rather than reaching the app as
-  tool shortcuts.
-- 8ddec11: Accept a named or cubic-bezier easing wherever a curve is taken, and let a
-  timeline's loop policy change after it is created.
-  
-  `easing` was a bare function everywhere, which is fine to call and impossible to
-  name back, show in a picker, or serialize. It now also accepts the name of a
-  built-in (`'easeOutBack'`) or control points (`{ bezier: [0.4, 0, 0.2, 1] }`),
-  resolved by `resolveEasing` at the four places a curve is actually invoked. The
-  union is additive, so every existing function value stays assignable. Bezier x
-  control points are clamped to 0..1, which is what keeps the solve monotone, and
-  the control-point tuple is `readonly` so an `as const` preset is assignable.
-  
-  `TimelineHandle.setLoop(loop)` sets policy and nothing else. A timeline already
-  parked at its duration does not restart — `rearm` declines to revive one — so
-  play it again by seeking to 0 and resuming. Restoring saved transport state
-  therefore cannot start playback as a side effect.
-  
-  Both settings now read back. `AnimationHandle.timeScale()` returns an
-  animation's own scale, and `Animator.timeScale()` the global one, the way
-  `isPaused()` already pairs with `pause()`. `TimelineHandle.loop()` returns the
-  policy as it stands — `true`, `false`, or the laps a finite loop has left, which
-  falls as they are consumed. A transport UI can drive itself off the handle
-  instead of mirroring what it last wrote, which drifts as soon as anything else
-  holding the handle sets it.
-- 28894b9: Fix the viewport primitives on an axis with negative scale.
-  
-  `View.scale` is documented as pixels per world unit _per axis_, so `scale.y < 0`
-  is the ordinary way to spell a y-up camera. Two primitives did not read it that
-  way, and both failed silently rather than erroring.
-  
-  `zoomAt` clamped the signed scale against positive bounds
-  (`min(max, max(min, scale * factor))`), so one wheel step on a y-up view
-  returned `scale.y = +0.1`: the axis flipped and the zoom collapsed to the
-  minimum. It now bounds the magnitude and restores the sign, so a clamp limits a
-  flipped axis instead of unflipping it.
-  
-  `clampView` computed the visible world extent as `canvas.height / scale.y`,
-  which is negative on a flipped axis. That made the "is the view zoomed out past
-  the bounds" test never fire, and put the scroll interval on the wrong side of
-  the anchor — a y-up view could be panned outside its own bounds. It now takes
-  the extent as a magnitude and anchors the interval at the rect's far edge when
-  the axis is flipped.
-  
-  Found while giving labkit's instrument canvas a declarable coordinate system:
-  routing its wheel through `zoomAt` looked like the obvious way to stop
-  reimplementing fixed-point zoom, and would have been a bug.
-- c4ccd0a: Zoom now has one clamp. `DEFAULT_MIN_ZOOM` / `DEFAULT_MAX_ZOOM` are exported from
-  `@weasel-js/core` and every zoom path defaults from them — `zoomAt`, the
-  `viewport.zoom` and pinch actions, `usePinchZoomTool`, `fitViewToBounds`,
-  `computeWheelAction` and `useZoom`.
-  
-  **Behavior change:** the three paths that carried the second, undocumented pair
-  now cap at 8x rather than 10x. `fitViewToBounds` could previously land at 10x and
-  the next pinch frame would clamp it straight back to 8x. Pass an explicit
-  `maxScale` / `max` to keep 10x.
-- Updated dependencies [a7fa697]
-  - @weasel-js/geom@1.4.0-pre.0
-  - @weasel-js/text@1.4.0-pre.0
-  - @weasel-js/font@1.4.0-pre.0
-  - @weasel-js/gestures@1.4.0-pre.0
-  - @weasel-js/history@1.4.0-pre.0
-  - @weasel-js/modes@1.4.0-pre.0
-  - @weasel-js/paint@1.4.0-pre.0
-
-## 1.3.0
-
-### Minor Changes
-
-- bca99e3: Extract the typography layer into `@weasel-js/text`, and the paint vocabulary
-  into `@weasel-js/paint` — two new Tier A leaves.
-  
-  `@weasel-js/text` owns the run model, style resolution, `layoutRuns`, wrap and
-  measurement. It depends on `@weasel-js/font`, `@weasel-js/geom` and
-  `@weasel-js/paint`, and on nothing else: a consumer with its own renderer can
-  lay out text without taking the scene graph or a React peer dependency.
-  `layoutRuns` is now public — it was previously reachable only from inside core.
-  
-  `@weasel-js/paint` holds `FillStyle`, `Stroke`, gradients, dashes and
-  `TextureHandle`. It was the blocker named in the 2026-07-28 font split: the
-  layout could not move while its fill type lived in the renderer's graph.
-  
-  `@weasel-js/core` re-exports both surfaces, so its own API is unchanged.
-  `Rect` moves to `@weasel-js/geom`, beside `Box`.
-  
-  Breaking for anyone importing these through core's internal paths rather than
-  its public entry (`core/paint-types`, `features/text/*`); those paths are gone.
-  
-  Advances and kerning still come from a baked MSDF atlas — laying out from font
-  bytes alone needs the metrics seam in
-  `docs/superpowers/specs/2026-08-28-text-package-extraction-design.md`.
-  
-  <!-- bump-approved: minor: Mike — two new published packages (@weasel-js/text, @weasel-js/paint) and layoutRuns promoted to public API, on top of ~50 patch changesets carrying new public surface across core, ui and labkit; called explicitly in conversation on 2026-08-29: "tag a minor release and push" -->
-
-### Patch Changes
-
-- 52c7b2a: Depend on `font` and `core` as exact peers
-  
-  `@weasel-js/font` and `@weasel-js/core` keep registries that consumer code
-  writes into — registered faces and glyph-ready subscribers in one, content
-  handlers and paint kinds and shape painters in the other. Two physical copies
-  in a tree are two registries, so a face registered into one while layout
-  resolves against the other lays out nothing and the canvas is blank.
-  
-  Exact sibling pins are what produced the duplicate: a consumer mixing two
-  weasel releases left npm no choice but to nest a second copy, silently. As
-  peers, the same mix is an `ERESOLVE` at install time. `font` is now a peer of
-  `core`, `hud` and `text`; `core` is now a peer of `svg`, joining `d3`, `hud`
-  and `ui`, whose `>=` ranges tighten to exact so no version mix resolves by
-  accident.
-  
-  **This can break an install that currently succeeds.** Anyone resolving a
-  mixed set of weasel versions by luck now gets an install error instead of a
-  blank canvas. That is the point, but it is a break.
-  
-  `labkit` deliberately keeps `core` as an ordinary dependency: its build aliases
-  every core entry point to core's built files and inlines them, so it never
-  resolves core at the consumer and has nothing to peer. The flip side is that
-  labkit ships its own copy of core's registries, so a consumer using both still
-  has two — this change does not address that.
-- 3386d64: Align, distribute and flip use visual bounds
-  
-  These folded each member's unrotated pose box, so "Align Left" on a selection
-  containing a rotated shape lined up the boxes and left the rotated shape's ink
-  sticking out past the others. They now work on the visual bounding box, as
-  Figma and Illustrator do.
-  
-  Both ends moved together — expanding only the union would have made alignment
-  worse, since the delta runs from an edge of the union to the same edge of each
-  member's box. The new exported `visualBoundsViaDescriptor(pose, geometry)`
-  reads a pose's bounds, recovers its rotation and expands via
-  `axisAlignedBounds`; the union folds those with `unionAABB`. The delta is still
-  applied as a translation of the stored pose through
-  `translatePoseViaDescriptor`, so a shape moves rather than being re-posed.
-  
-  Flip needed only its union pivot changed: mirroring maps a centre and preserves
-  size, and an expanded box is concentric with the box it came from.
-  
-  `alignMoveBehavior` folds the dragged selection the same way, so a drag snaps
-  by its ink.
-- ffafb7d: Never let an animation's virtual clock run backwards.
-  
-  `useAnimator` seeds each animation's `lastRealNow` from `now()` at register
-  time, then advances its virtual clock by the difference against the timestamp
-  the frame loop supplies. Those two share a time origin in a browser, where the
-  rAF timestamp and `performance.now()` are both page-relative — but that is a
-  browser guarantee, not a universal one, and jsdom starts them roughly 600ms
-  apart. The first frame's delta then came out hugely negative and `virtualNow`
-  spent dozens of frames climbing back toward zero before a tween advanced at
-  all: a 40ms glide took 95 frames and over a second of wall time, growing worse
-  the longer the process had been alive.
-  
-  A frame's elapsed time is never negative, so the sample is now clamped at
-  zero. Under a shared origin this is a no-op.
-- ba8b139: Camera animation: `viewport.animatedZoom` now does something
-  
-  `animatedZoom` has been declared on `SceneCanvasProps.viewport` and read by
-  nothing; Cmd+=/-/0 was a bare `view.set`. It now routes the discrete zoom steps
-  through the kit's `Animator`. Wheel and pinch are unchanged and never animate —
-  their input already delivers a sample per frame.
-  
-  Camera animation is a general surface, not a zoom flag. Three ways in, one
-  runner behind them:
-  
-  - `useViewAnimation(view, animator?)` — `animate`, `animateToBounds`, `stop`,
-    `isAnimating`, `target`.
-  - The `view` dep gains optional `animate` / `stopAnimation` / `animationTarget`,
-    so any action can glide the camera.
-  - `SceneCanvasApi` gains `animateView` / `stopViewAnimation` /
-    `isViewAnimating` for fit-to-selection, recenter, or a scripted tour. All
-    three are **required** members: anyone hand-implementing `SceneCanvasApi`
-    (a test double, a wrapper) has to add them, the way `CanvasExtensionApi`
-    grew `getPaintedVersion`.
-  
-  Scale interpolates geometrically and translation is derived from the screen
-  point the two views agree on, so a zoom stays anchored instead of drifting and
-  each frame changes the view by the same ratio. One animation runs at a time; any
-  other view write cancels it, and a cancel leaves the camera where it is rather
-  than jumping to the target. On an uncontrolled canvas the whole animation costs
-  no React render.
-  
-  **Breaking:** `useViewTween` is removed. `useViewAnimation` keeps its name and
-  changes signature — it takes a `{ get, set }` view channel plus an optional
-  `Animator`, and `animateTo(from, to, { duration, easing })` becomes
-  `animate(to, { ms, easing })`. The `from` argument is gone because the runner
-  reads the live view, which is what lets an interrupted camera resume from where
-  it actually is instead of snapping back to a captured start. `cancel()` is now
-  `stop()`, and `animateToBounds(bounds, currentView, dims, { duration })` is now
-  `animateToBounds(bounds, dims, { ms })` — the `currentView` argument goes for
-  the same reason `from` does.
-  
-  **Breaking:** `viewport.recenter` and `ViewApi.recenter` widen to
-  `() => View | void`. Returning the target view lets Cmd+0 animate there;
-  returning nothing keeps the existing behavior. `animatedZoom`'s config fields
-  are `ms` / `resetMs` rather than `duration` / `resetDuration`, matching the
-  animator's vocabulary.
-- 3fb3a46: Forward `onFocus` and `onBlur` from the canvas element
-  
-  The canvas is focusable by default (`tabIndex` 0) but exposed no way to
-  observe focus, so consumers driving focus-dependent chrome had to attach a
-  listener to an ancestor and infer it. Both are now props on `CanvasProps`, and
-  so reach `SceneCanvasProps` and the canvas element unchanged.
-- 67bcb05: Drop four values the canvas layer memo no longer reads
-  
-  `hit-test affordances against the painted chrome state` moved the selection
-  overlay to reading bounds off the chrome state at paint time, which left
-  `selectedIds`, `multiActive`, `previewToolPose` and `previewToolBounds`
-  referenced only by the `layers` memo's dependency array — nothing in the body
-  used them. Removing them from the array made all four dead locals, so they go
-  too.
-  
-  The memo now rebuilds the layer array on layer/tool/geometry changes rather
-  than additionally on every selection and preview-pose change. Selection chrome
-  is unaffected: it repaints from chrome state, not from the identity of this
-  array.
-- 47cbb08: A closed subpath's dash no longer seams at its start vertex
-  
-  `splitForDash` flushed the run still open when a closed subpath's walk returned
-  to the vertex it started from as its own open sub-polyline, so it and the run
-  that began there rendered as two butt-capped ribbons meeting at a point — a
-  notch on the corner of any dashed rectangle whose perimeter isn't a whole
-  multiple of the pattern. They are joined now, and the join the stroke asked for
-  is drawn across the seam like any other corner. A pattern whose first "on"
-  length covers the whole perimeter emits a closed ribbon, identical to the
-  undashed stroke.
-- f43e9c2: A derived edge follows the drag that moves its endpoint
-  
-  `move`, `resize` and `rotate` kept their in-flight poses in action-local
-  scratch and published them only as `previewIds` / `previewPose`. That surface
-  is enough to paint a ghost and size selection chrome, but nothing that asks
-  the *scene* where a node is can see it — and `scenePoseLookup`, which resolves
-  a derived node's geometry, asks the scene. So dragging a box left its edge
-  anchored to the pre-drag position until the drop, when the commit invalidated
-  the dependents and the edge jumped.
-  
-  The three actions now also publish each frame into the scene's ephemeral pose
-  overrides (`syncPreviewOverrides` / `dropPreviewOverrides` in
-  `interactions/actions/previewOverrides.ts`). Overrides bypass `executeAndLog`,
-  so a drag still commits as exactly one undo entry — the reason the actions
-  avoided per-frame scene writes in the first place was history, and this writes
-  no history. Entries are set once and mutated in place, published with a single
-  `commit()` per frame.
-  
-  Picking follows for free: the pick source resolves a derived path through its
-  own override-aware `poseOf`, so an edge is grabbable where it is drawn
-  mid-gesture rather than where it used to be.
-  
-  `clone` is deliberately untouched — its previews are the new ghosts at the
-  drag target, and the originals never move, so nothing derives from a changed
-  pose.
-  
-  Also closes the matching gap in the preview-ghost layer, which built a
-  container's clip with no derived path and so ghosted a derived container
-  without one.
-  
-  Note for anyone with a hand-written `Scene` stand-in: `overrides` is now read
-  on every gesture frame. It was already required by the `Scene` contract, but a
-  partial fake that omitted it will now throw rather than silently skip.
-- bb27e83: A derived node is clickable where it paints
-  
-  A node whose geometry comes from `derivePath` had no silhouette and no `ink`:
-  `NodeShapeEntry.silhouette` took only `(node, pose)`, and a derived path is
-  resolved from the *dependencies'* poses, which a painter has no handle on. So
-  `kit:derived` could not report one, `shapeCoversPoint` read the resulting null
-  as "no opinion" and answered `true` everywhere, and picking fell back to the
-  node's own pose — for an edge, a zero-sized placeholder at the origin. An edge
-  was unpickable, and a derived container contributed no clip.
-  
-  `silhouette` now takes a `NodeSilhouetteCtx` carrying `derivedPath`, on the
-  same convention `NodePaintCtx` already uses, and `kit:derived` reports the
-  derived path as its silhouette and its declared stroke as its `ink`.
-  
-  Resolving that path needs the scene, so it is the *source* that answers, not
-  the painter: `PickSource.derivedPathOf`, a matching optional argument to
-  `buildSceneTree`, and `SceneSlotConfig.derivedPathOf` — the slot already
-  carried the derived path a node *paints*, and now also the clip a derived
-  container *imposes*, so the live canvas and the headless walk clip alike. The
-  bare-adapter paths supply none of them and behave exactly as before.
-  
-  The pre-filter had to move with it. `useSceneSelectTool` grew its region test
-  from the node's pose, which for a derived node is the wrong box entirely, so
-  the edge was rejected before the shape test could claim it. It now tests the
-  derived path when there is one — `poseContains` already reads a path-like pose
-  as a path, so this reuses it rather than adding a second reach calculation.
-  
-  `findShapeSilhouette` skips its memo when handed a derived path. That slot is
-  keyed on `(node, pose, data)` and cannot see the path, so it would serve one
-  caller's silhouette to a caller that passed a different one — the same reason
-  `kit:derived` already skips `PAINT_SLOT`.
-- 6a33c3f: A node's path can be derived from other nodes' poses
-  
-  A node declares `dependsOn: NodeId[]` and a `derivePath` function resolved by key
-  through `SceneRegistry`, and the scene walks resolve its path before painting
-  rather than it being authored. An edge drawn between two boxes is then an
-  ordinary scene node — selectable, styleable, exportable — whose geometry never
-  enters undo history. The seam and its traps are in `docs/extending.md`.
-  
-  New surface: `scene.removeMany(ids)`; `dependsOn` and `derivePath` on
-  `NodeBase` and on `AddNodeSpec`, which is what a consumer writes;
-  `SceneRegistry.derivePath`; `SerializedNode.dependsOn` and
-  `SerializedNode.derivePathKey`, both additions to the serialization format;
-  `NodePaintCtx.derivedPath`.
-  
-  Deleting a node now deletes everything that derives from it, transitively,
-  including those nodes' own subtrees, in one undo entry — so `scene.remove` can
-  remove nodes anywhere in the tree that the caller never named, and `removeLayer`
-  reaches nodes on other layers. Undo after the built-in **Delete** key does not
-  yet restore the cascaded nodes; see "Derived geometry follow-ups" in
-  `docs/TODO.md`.
-  
-  **Breaking: `defaultDrawOne` takes `(node, pose, view?, ctx?)`.** The paint
-  context moves to a fourth parameter, so a call passing a `NodePaintCtx` third is
-  now a type error rather than a silent slide into the `view` slot. The same
-  fourth parameter is added to the `SceneViewDrawOne` and `SceneSlotConfig.drawOne`
-  callback types, which is not a break: an existing three-parameter implementation
-  still satisfies them, and an existing three-argument call still compiles.
-  
-  **Breaking: `Scene` gained a required `removeMany`.** A hand-written object
-  typed as a `Scene` — a test double, most likely — no longer typechecks until it
-  implements it.
-  
-  **Breaking: `kit:remove`'s op payload changed shape.** `rootId` / `parent` /
-  `index` became `detached: { id, parent, index }[]`, because a cascaded dependent
-  is not a descendant of the removed node and the tree has to be told about every
-  subtree that came out of it. A history persisted by an older build now throws
-  mid-undo rather than degrading. The break is deliberate; kit op payloads are not
-  versioned.
-- c24e7de: Detached views follow pose overrides
-  
-  `<SceneViewCanvas>` and `<MinimapCanvas>` re-rendered off `scene.getVersion()`,
-  which a pose override deliberately never bumps — so they kept painting document
-  poses while `<SceneCanvas>` painted the overridden ones. A minimap beside a
-  canvas driving a drag or a simulation silently disagreed with it.
-  
-  `<SceneViewCanvas>` now paints through `useFrameLoop` instead of from React, and
-  subscribes to `scene.overrides`. A render (prop change or version bump) and an
-  override commit both just mark the surface dirty, and one animation frame
-  coalesces them — so a 60 Hz override loop repaints these views with no React
-  render, and a backgrounded tab stops painting them entirely. The mount paint
-  stays synchronous, so the first frame is still the scene rather than a blank
-  canvas. `<MinimapCanvas>` inherits all of this through it.
-  
-  Repaints driven by a prop change are now asynchronous: they land on the next
-  animation frame rather than in the layout effect of the render that caused them.
-  Code that renders and then reads pixels in the same tick needs to wait a frame.
-  
-  A minimap's *framing* still derives from document poses, so a node overridden
-  outside the document bounds paints outside the fitted frame — recomputing the
-  fit per frame would rescale the whole minimap throughout a settle.
-- ce82f4a: An enum leaf can ask for a segmented control, and `pair` works inside an object
-  
-  `ToolPrefEnumControl` gains `'toggle'`: a three-option enum shows all three at
-  once instead of hiding two behind a select. Options carry an optional `short`
-  label — a capital or two — for the width a property row has; the full `label`
-  stays the accessible name, so the abbreviation never becomes the only thing
-  naming the option. A mixed selection selects no segment rather than picking a
-  winner.
-  
-  `pair` now merges fields inside an object leaf, as it already did for section
-  rows — a hint shouldn't mean something different for being a field of a value
-  rather than a sibling of one. It merges *adjacent* leaves in both places, so
-  the schema orders family, size, weight: size and weight pair, and family (which
-  sat between them) moves ahead of the pair rather than splitting it.
-  
-  A stroke's cap, join and align share one row; property rows wrap rather than
-  overflow when the controls in them don't fit.
-- be697dc: Add ephemeral pose overrides to the scene
-  
-  `scene.overrides` holds a per-node `{ pose?, alpha? }` that the render and
-  hit-test paths read through and that history, `toJSON()` and `getVersion()`
-  never see. It is additive: a scene with no overrides behaves exactly as before.
-  
-  This is where per-frame motion belongs. A 60 Hz loop previously had to write
-  through `setPose`, which records an undo entry (one per frame at best, batched)
-  and bumps the scene version, re-rendering every `useSyncExternalStore`
-  subscriber. It also had to allocate a fresh pose object per moving node per
-  frame, because the painter memo keys on pose reference. An override entry is
-  hoisted once and mutated in place; `overrides.commit()` publishes the frame and
-  invalidates the memo for the overridden nodes only.
-  
-  `commit()` is required after an in-place mutation — without it the memo serves
-  the previous frame's draw. Overrides are cleared when a node is removed, since
-  ids are reusable. To make a frame permanent, write it once through `setPose`
-  and clear the override; that single step is the undo entry.
-  
-  `ForceGraphDemo` now settles with zero history entries and bakes the result as
-  one, replacing a per-tick batch of 24 `setPose` calls.
-- e909a3b: `fitTextPose` sizes a box the renderer will actually fill
-  
-  It was the fourth site measuring text its own way: `ctx.measureText` per
-  character against system fonts, no kerning, `pose.text` only. Nothing masked
-  it the way the WebGL context masked the caret — a consumer calling it got a
-  box that disagreed with the paint, narrower by a kern on every pair and wrong
-  by the whole difference between the installed family and the registered face.
-  It goes through the shared layout now, so it sees kerning and per-run styling.
-  
-  **Breaking:** `fitTextPose(ctx, pose, opts)` is now `fitTextPose(pose, opts)`.
-- 26bbdcf: Paint the canvas from its own animation frame instead of from a React render
-  
-  `requestRedraw()` marks the surface dirty and the next frame paints, so many
-  redraws in one tick cost one paint. The view gains an imperative path on the
-  canvas handle — `setView` / `getView` / `subscribeView` — and `SceneCanvas` no
-  longer holds it in React state, so a camera moving at 60 Hz costs no renders.
-  Consumers passing a `view` prop stay controlled and are unaffected.
-  
-  Opt-ins that come with it: `syncPaint` paints inside the commit for a consumer
-  that wants the old whole-cloth guarantee, `useScene(…, { subscribe: false })`
-  gives a host the scene without a render per mutation, `useSceneTextEdit`'s
-  `view` option accepts a thunk so the overlay tracks a ref-driven camera, and a
-  `contentVersion` prop feeds the version that `getPaintedVersion()` reports.
-  
-  Two public signatures changed. `usePinchZoomTool` takes a view getter,
-  `getView: () => View`, where it took a `View` — nothing re-renders to refresh a
-  captured value any more. `CanvasExtensionApi` gained five required members —
-  `getView`, `setView`, `subscribeView`, `subscribeFrame`, `getPaintedVersion` —
-  so external code hand-implementing that interface stops typechecking; code that
-  only calls through the ref is unaffected.
-  
-  Pixels and DOM can now be a frame apart, in whichever direction the change came
-  from. A view change leads with pixels: `setView` paints without rendering, so
-  DOM built from the view is stale until something re-renders it — position
-  world-anchored DOM from `subscribeView`. A scene change leads with DOM:
-  `SceneCanvas` still subscribes to the scene, so a `batch` commits now and the
-  pixels land next frame — compare `getPaintedVersion()` against the version you
-  are about to render when chrome must be in lockstep. Do not render scene-derived
-  DOM inside `startTransition`: React defers it and nothing forces it to catch up.
-  
-  Anything reading the drawing buffer back outside a paint — the hud loupe's pixel
-  mode is the one in-tree case — can likewise see a buffer one frame older;
-  `subscribeFrame` runs on the frame that painted and removes the lag. Nothing
-  paints while `document.hidden` is true, `syncPaint` included, so a readback from
-  a background tab returns the frame from before the tab was hidden.
-- 546f67d: Copy typed-array arguments into `makeGLRecorder`'s call log as they are
-  recorded. A caller is entitled to reuse the array it uploads from, so storing
-  the reference recorded a value that later frames overwrote — a test reading
-  two frames back saw the same numbers twice and passed. Test-only surface.
-- 3fb3a46: Release held keys when the window loses focus
-  
-  A window that blurs mid-hold never delivers the keyup, so every in-flight
-  `key-held` handle stayed engaged until that key was pressed again — holding
-  Space and tabbing away left the hand tool on the hotkey stack indefinitely.
-  
-  The gesture dispatcher now fires the `key-held` up phase for each held key on
-  window blur. Consumers that hand-rolled this reset can drop it; ongoing
-  invocations see a normal `onEnd`.
-- ccd51cc: Add a 43-glyph monochrome icon set to `@weasel-js/ui`.
-  
-  One register: a 20x20 viewBox drawn in `currentColor` at stroke-width 1.5 with
-  round caps and joins, hairline weight reserved for structure, and filled
-  regions only where an action has a subject. Covers transport, history, view,
-  trial lifecycle, collection, state, instrument and status vocabulary. Import a
-  named component (`CloneIcon`), or `Icon` when the glyph is chosen at runtime.
-  
-  `@weasel-js/ui` also re-exports the tool glyphs that live in `@weasel-js/core`,
-  so consumers have one import site for the whole set. `ImageIcon` was reachable
-  from core's icons folder but missing from its public barrel; it is exported
-  now.
-  
-  Glyph geometry is generated (`npm run gen:icons`) from `packages/ui/scripts/icons/`
-  rather than hand-placed, because arrowheads and joins that miss their terminus
-  are invisible at chrome size.
-- 3fb3a46: Compose `before` and `after` layer chains in both directions
-  
-  `composeOrderedLayers` walked the two anchor maps separately: a chain hanging
-  off an `after` anchor only followed further `after` links, and likewise for
-  `before`. A custom layer anchored `before: 'scene'` carrying a second custom
-  anchored `after` it dropped that second layer to the tail with a spurious
-  dangling-reference warning.
-  
-  Both walks now emit a layer's `before` chain, the layer, then its `after`
-  chain, so the two mix freely. Cycle detection and orphan fallback are
-  unchanged.
-- d9f110e: Stop every frame loop while nothing can see it
-  
-  New public hook `useVisibleRaf` in `@weasel-js/core` owns the question of
-  whether a frame may run: nothing runs while `document.hidden`, and a loop that
-  names an element also stops while that element is outside the viewport. A
-  request made while suspended is held rather than dropped and re-armed on
-  resume, so a loop never polls visibility or needs restarting by hand.
-  
-  Ten loops now run behind it — `useFrameLoop`, `useAnimator`, `useSimulation`,
-  `useDecayLoop`, `useTextEdit`'s overlay follow, `CursorCoordsHud`'s FPS
-  counter, `Badge`'s crawl, and labkit's `FpsMeter`, `useTiledSurface` and
-  `useLayerScheduler`. Only `useFrameLoop` consulted `document.hidden` before;
-  the rest ran on any page left open. `useLayerScheduler` looked safe and wasn't:
-  it paints only dirty layers, but a hidden tab still commits React updates and
-  its view/size effect marks every layer dirty.
-  
-  Loops measuring elapsed time rebase their clock through the new `onResume`
-  option, so an hour spent hidden does not arrive as one hour-long frame — an FPS
-  meter reporting a rate nobody achieved, a tween jumping to its end value on
-  return. `dangerouslyRunWhenHidden` opts a loop out for offscreen recording or
-  export; nothing in the tree sets it.
-  
-  `npm run check:frame-loops` fails the build on a bare `requestAnimationFrame`
-  in kit source, and runs in CI.
-- 0dd35a1: Fix pinch-to-zoom: mac trackpads zoomed the page, and `viewport.pinchZoom` zoomed twice
-  
-  A trackpad pinch reaches the page as `wheel { ctrlKey: true }`. On a mac
-  `viewport.zoom`'s `mods: { mod: true }` binding requires metaKey and forbids
-  ctrl, and `viewport.wheelPan` forbids ctrl too, so nothing claimed the event
-  and the browser's own ctrl+wheel page zoom ran. `viewport.zoom` now carries a
-  second wheel binding on bare ctrl. Off mac it duplicates the `mod` binding,
-  where the matcher picks a single winner.
-  
-  Nothing caught that because `IS_MAC` read `navigator.platform ?? userAgent`,
-  and jsdom reports an empty-string platform — not nullish, so the fallback never
-  fired and every mac binding in the kit was exercised only on the non-mac
-  branch. It reads `||` now.
-  
-  Separately, `viewport.pinchZoom: true` mounted `<Canvas>`'s `usePinchZoomTool`
-  alongside the `viewport.pinchZoom` action that already handled the same
-  gesture, applying one pinch's factor twice — the opt-in broke the path that
-  worked without it. SceneCanvas drives pinch through the action alone, and the
-  flag configures it: new `makePinchZoomAction({ min, max })` (exported), with
-  the kit's 0.1–8 clamp now applied by default. `pinchZoom: false` disables pinch
-  for real; it previously left the action running. Bare `<Canvas>` keeps the hook
-  as its own pinch path.
-- 1a0bea3: `useNodeOverlayFrame`: the coordinate frame a DOM overlay pinned to a node needs
-  
-  Nothing in the kit exported one, so consumers hand-rolled it — their own
-  `ResizeObserver` next to the existing `useCanvasSize`, and a translate-and-scale
-  inverse built by projecting two points. That inverse silently drops
-  `pose.rotation`, which is why on-canvas gradient handles on a rotated node sat
-  beside the paint instead of on it.
-  
-  ```ts
-  useNodeOverlayFrame(scene, containerRef, nodeId, { view })
-  // → { box, toScreen, toLocal, width, height } | null
-  ```
-  
-  `box` is the node's composed world box, unrotated — the frame `toScreen` maps
-  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. Rotation
-  lives in the pose→world leg, where it belongs: a node's stored geometry and its
-  bounds-frame paint are pre-rotation by definition, so neither of those two
-  changes.
-  
-  `@weasel-js/ui` gains `SceneGradientHandles`, the scene-aware half of
-  `GradientHandles`: it reads the gradient out of a node's `fill` **or** its
-  `stroke` — `slot` is a prop — and commits each drag through `setFill` or
-  `setStroke` as one undo entry. `GradientHandles` itself stays frame-agnostic.
-  
-  Also: `isGradientFill` narrows a `FillStyle` to its three gradient members, and
-  `useCanvasSize` accepts any `HTMLElement` rather than only a `div`.
-- 9d95836: A node's `data.stroke` takes a whole `Stroke`, not just a color
-  
-  `NodeStroke = string | Stroke`, mirroring `NodeFill`. A string is still a
-  color and `'none'` still skips the stroke; an object is a core `Stroke` whose
-  `width`, `cap`, `join`, `dash`, `miterLimit` and `align` all reach the
-  renderer, which has accepted them on `PathDrawCommand` all along. The object
-  wins outright over `data.strokeWidth` rather than merging with it, the same
-  rule `withLeafStroke` already applied to text. A bounds-relative stroke paint
-  is baked onto the pose box the way a fill is, so a gradient stroke resolves
-  against the box it was authored against.
-  
-  `kit:shape` now honors `stroke: 'none'`, which only `kit:path` checked before.
-  
-  `NodeInk` reports `{ filled, outset, inset }` instead of `{ filled,
-  strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
-  `'outer'` none inside, which one number could not say, so picking grabbed the
-  wrong side. `ink` takes an optional context carrying the view scale, so a
-  `{ px }` stroke width resolves to world units. A painter that still returns
-  `{ filled, strokeWidth }` is read as a centered stroke and keeps working.
-  
-  `setStroke` and `setStrokeOpacity` no longer stringify a node's `Stroke`: a
-  color pick replaces its paint and keeps width, cap, join and dash, and an
-  opacity drag sets the paint's `opacity`, which is the only form that works on
-  a gradient stroke.
-  
-  Editing UI for the rich form is not here yet — a schema-driven color control
-  still writes a bare string over the object, so nodes carrying one are for
-  programmatic authorship until `SelectionPanel` learns the union. See
-  `docs/proposals/2026-08-26-node-stroke-union.md`.
-- 62a3c46: Paint a gradient or pattern stroke instead of throwing.
-  
-  `Stroke.paint` has always been a full `FillStyle`, and SVG import puts paint
-  servers there deliberately, but the renderer refused anything but a solid — so
-  importing a shape with `stroke="url(#grad)"` produced a scene that threw on the
-  next frame. Both stroke paths now paint the ribbon through the same route a
-  fill takes, including under the inner/outer alignment stencil. A non-solid
-  even-odd fill no longer renders black.
-- 5f6c28e: An object leaf's fields can be organised into groups
-  
-  `ToolPrefObject.children` takes a `ToolPrefGroup` as well as a leaf. A group
-  heads its fields under a label and contributes nothing to the path — the same
-  rule group keys follow at the top level of a schema, so a field inside one is
-  still addressed as a field of the object.
-  
-  Without it, a value with many fields renders as one undifferentiated list. A
-  `TextStyle` is the case that needs it: its character and paragraph fields are
-  one value but read as two lists.
-- 3cd1ee8: A schema leaf can hold an object, with its fields hanging off it
-  
-  A compound value — a stroke, a shadow, a pattern spec — could be described as
-  sibling leaves addressing into it (`data.stroke.width`, `data.stroke.cap`).
-  It shouldn't be: each control then writes one field of a value it can only
-  half see, and writing a field into something that isn't an object yet corrupts
-  it outright.
-  
-  `ToolPrefObject` describes the value instead. Its `children` are ordinary
-  leaves whose paths are relative to the object, and every child edit commits
-  the parent object whole. A field that is itself a union declares the kind that
-  edits that union — a stroke's `paint` is a `paint` leaf. `fromScalar` lifts a
-  value still held in a scalar form before a child edit lands on it, which is
-  how a stroke stored as a bare colour string gains a width.
-  
-  `defaultNodeProperties` describes `data.stroke` this way, so the panel shows
-  Color, Width, Cap, Join and Align under one Stroke block, and the separate
-  `data.strokeWidth` leaf is gone. `SelectionPanel` now honours `block`, which
-  `PrefsForm` already did. The one-off `stroke` pref kind added days ago is
-  replaced by this general one.
-  
-  `dash` has no leaf: it is a `number[]` and no kind edits one. It survives
-  import, export and rendering untouched.
-- 2ea772f: Selection handles are hit-tested at the size they are painted
-  
-  Handles painted at `HANDLE_BASE_PX * targetScale` and hit-tested at the bare
-  constant, and neither `buildAffordanceAt` call site passed the option that
-  would have scaled it. A coarse pointer got a bigger picture and exactly the
-  same 8px grab zone it had on a mouse — the touch forgiveness the coarse profile
-  exists to provide never reached the hit-test. The slops debug overlay was a
-  third unscaled copy, so it drew hit regions where they were not.
-  
-  `core/device/targets.ts` now holds one base table and one accessor,
-  `targetSizesPx(targetScale)`. Paint, hit-test and the debug overlay all resolve
-  through it. `HANDLE_BASE_PX`, `ANCHOR_HIT_BASE_PX` and
-  `ROTATION_HANDLE_BASE_PX` keep their names and values and now read off the
-  table; the internal `HANDLE_HIT_RADIUS` and `ANCHOR_HIT_RADIUS` are gone.
-  
-  `buildAffordanceAt` and `createSlopsDebugLayer` take an optional `targetScale`.
-  `selectTool.handleHitRadius` now actually reaches the hit-test — it previously
-  reached nothing.
-  
-  `useRotateTool`'s `handleHitRadius` option is **removed**. The rotation
-  affordance is an annulus with a band thickness and no point radius, so the
-  option could only ever have been a second name for `rotationHandleDistance`,
-  which is live and now defaults from the same table.
-  
-  Known gap: `CanvasView` is a second `buildAffordanceAt` call site that reads no
-  device profile, so a nested view still hit-tests at the fine-pointer size.
-- f77bd95: `getChildren` means one thing on an adapter
-  
-  `MoveAdapter` declared `getChildren(id)` — a node's direct children, for the
-  drag cascade — and `OrderedAdapter` declared `getChildren(parentId | null)`,
-  the z-ordering seam where `null` means the root. Both land on the same adapter
-  object, so `arrayAdapter` took the first shape from its config and exposed it
-  under the name the ops read with the second meaning. An op asking for root
-  order got `[]`, which reads as "the root has no siblings", and the slot it
-  captured was silently lost.
-  
-  The two declarations are now one contract, and `arrayAdapter` answers the root
-  from its own item array rather than delegating — a consumer callback written
-  for node ids returns `[]` there, which cannot be told apart from a genuine
-  empty answer. A consumer's `getChildren` config is still only ever asked about
-  a node id.
-  
-  `arrayAdapter` still exposes no `setChildOrder`, so it places by ordinal rather
-  than by anchor. That is unchanged, and it is why the ordinal fallback exists.
-- 2ea772f: The canvas and the gradient editor now sample one gradient
-  
-  `buildGradientRamp` carried its own interpolation beside
-  `sampleGradientStops`, and the two disagreed three ways: the ramp had no guard
-  at either end and extrapolated past the first and last stop, the two picked
-  opposite sides of a coincident pair, and they parsed color differently — a stop
-  written as a CSS named color rendered on the canvas and threw in the editor.
-  
-  `sampleGradientStops` keeps its semantics and is now the only implementation.
-  `resolveGradientStops` sorts and parses the list once; `sampleResolvedStops`
-  returns the color at `t`. The ramp cache builds its texels through those, so
-  there is no interpolation math left in the renderer.
-  
-  Two behavior changes worth naming. `resolveColor` is the surviving parser, so
-  gradient stops accept named and functional colors everywhere — but no longer
-  hex without a leading `#`, which only the editor path had tolerated and the
-  canvas never accepted. And `sampleGradientStops` returns normalized hex at the
-  endpoints instead of echoing the raw stop string, so `'red'` comes back as
-  `'#ff0000'`.
-  
-  **SVG export:** a conic gradient left the exporter as a dangling `url(#…)` —
-  the element already carried the reference, the built-in serializer returned
-  nothing, and the registry's `toSvg` slot has no in-repo implementation, so the
-  shape disappeared in a browser with no warning at all. Serialization now falls
-  through to the same warning the pattern path already emits when nothing can
-  produce a paint server. A consumer that registers a `toSvg` for
-  `conic-gradient` still serializes and gets no warning.
-- aba8d91: Answer "can this node be hit" in one place
-  
-  Four tree walks answered it separately — the generic-adapter point pick, the
-  one `<SceneCanvas>` installs, `sceneToAdapter`'s area walk, and the live
-  marquee/lasso — plus a fifth that shadowed the third. They agreed on every case
-  that had a test and disagreed on the rest, three times, silently. `pickWalk`
-  now owns every gate; a query supplies only its own shape test and the clip
-  predicate for its region.
-  
-  Behavior that changes as a result:
-  
-  - **A node painted at alpha 0 is no longer clickable.** The pick path reads the
-    same number the painter does — the view's `alphaFor` times any per-node
-    override alpha — so a node faded out of sight stops claiming clicks. The
-    floor is exactly zero, so a fade-in is pickable from its first nonzero frame.
-    Alpha is per view: dimming a node in one view leaves it pickable in another.
-  - **A layer that is not painted no longer claims pointer events.** `drawLayers`
-    drops any layer missing from a supplied `layerOrder`, and the chrome hit path
-    only consulted `layerVisibility`. Both gates now run through one
-    `isLayerPainted`, which is exported.
-  - `sceneToAdapter`'s area walk reads override poses and hidden layers, which it
-    did not; its default `poseBounds` answers a path pose instead of `NaN`, which
-    is what the shadow walk existed to work around.
-  - An ancestor clip now rejects an area query that reaches into the clip where
-    the node is not, or reaches the node where the clip is not — the two terms
-    together, where one alone let false positives through.
-  
-  `useSceneSelectTool` takes `alphaOf` and `layerIsPainted` for the asking view.
-  `passesAncestorClips` and its module are gone; `pickWalk`, `scenePickSource`,
-  `adapterPickSource` and `ownClipOf` replace them.
-- 2ea772f: A drag-to-insert reports the bounds it paints
-  
-  The painter, the commit factory and `getGestureBounds()` each sized an
-  in-flight insert differently. The reporter read the drag rect alone, so a
-  centered Alt-drag reported a half-extent of `d` against a painted circumradius
-  of `d√2`, a purely horizontal Alt-drag reported **height 0** for a visibly tall
-  star, and a pencil scribble that looped back to its start reported nothing at
-  all. The painter and the commit agreed on polygon and star but not on line or
-  pencil: the commit posed the drag AABB for a line the painter drew endpoint to
-  endpoint, and fell back to the drag rect for a trail under four samples.
-  
-  One function now answers it for all three. The zero-area skip in the painter
-  and the reporter tests the resolved extent rather than the raw drag rect, and
-  an `InsertNodeFactory` that returns no `pose` falls back to the extent. The
-  `bounds` argument handed to a factory is unchanged.
-- 3386d64: Path command opcodes derive from one table
-  
-  `M`/`L`/`C`/`Q`/`Z` and their coordinate counts were declared five times —
-  once in core, once in `@weasel-js/geom`, and three more as `COORD_COUNT`
-  literals in the path transform, pose-rotation and pose-descriptor walkers. They
-  agreed, and nothing held them to each other: a sixth opcode desynchronizes two
-  packages' reading of the same `Uint8Array` with no exception and no type error,
-  and every walker misparses the coordinate stream from that command on.
-  
-  `PATH_COMMANDS` in `@weasel-js/geom` is now the table. `PATH_M`…`PATH_Z`,
-  `PATH_CMD_LENGTHS` and the new `pathCommandCoordCount` all derive from it, and
-  core re-exports them by name, so the opcode constants keep their names, values
-  and literal types. The three walkers moved onto `forEachSegment` rather than
-  onto the accessor alone — they were duplicating the coordinate-cursor advance
-  as well as the length, and the cursor is the half that actually misreads.
-  
-  Eight further files switch on these opcodes with inline literals. Five throw on
-  an unknown code; three — the path boolean adapter, the anchor-editing geometry,
-  and geom's own boolean adapter — have no `default` arm and would silently stop
-  advancing. Left as-is; they need per-command semantics, not one walker.
-- 68d2651: Pref leaf kinds are declared once, and every renderer is exhaustive
-  
-  `@weasel-js/ui` carried its own copy of the pref-leaf union under a comment
-  saying to keep it in sync with core's field-for-field. It had drifted: ui's enum
-  leaf had neither `encoding` nor `options[].disabled`, so a dash-array
-  preference did not merely fail to select — choosing an option wrote the option
-  string over the stored dash array. labkit's two renderers were missing the
-  `paint` and `object` kinds outright.
-  
-  ui's schema is now a rename re-export of core's declaration. The public `Pref*`
-  names are unchanged, and there is nothing left to keep in sync.
-  
-  More importantly, all four renderer switches ended in `default:`, so adding a
-  built-in kind produced no error at any site and simply rendered nothing —
-  verified by adding one and typechecking. `ToolPrefLeaf` widens `kind` to
-  `string` so app-defined prefs can ride the same tree, which means a `never`
-  guard cannot sit on it directly. New from core: `TOOL_PREF_KINDS`, a
-  `Record<ToolPrefKind, true>` that a new kind fails to compile against first, and
-  `isBuiltinToolPref(leaf)`, which narrows to the closed union so each renderer
-  can discriminate and end in a `never`. App-defined kinds take the placeholder
-  path as before.
-  
-  Dash-array preferences now select and commit correctly in `PrefsForm`: the enum
-  arm threads sibling values, routes through `encoding.read` / `encoding.write`,
-  and honors `option.disabled`. `SelectionPanel` already did all of this — it was
-  only the forked copy that could not express it.
-- 3386d64: Dragging out a text box shows a live preview
-  
-  The set of insertable kinds and the `KitInsertShape` union sat on adjacent
-  lines with no linkage, and seven more sites restated one list or the other. The
-  drift was already live: the text tool binds `actionId: 'insert'` and commits
-  through the insert dep, but the runtime set never listed `text`, so a
-  drag-to-insert text box had no preview.
-  
-  `SHAPE_KINDS` is now one descriptor table — a row per kind, flagged for whether
-  it has a built-in tool and whether it takes an insert preview. Both unions,
-  `KIT_SHAPE_KINDS`, `BUNDLE_TOOLS.exhaustive`, the known-builtin-id list and the
-  preview gate all derive from it.
-  
-  Two type-surface consequences. `KIT_SHAPE_KINDS` is typed
-  `readonly BuiltinShapeToolId[]` rather than a literal tuple — same contents,
-  same order, and `(typeof KIT_SHAPE_KINDS)[number]` is unchanged; what goes is
-  positional and length typing, which nothing uses. And `OngoingOverlay['shape']`
-  gains `'text'`, which is the fix itself: a consumer switching exhaustively over
-  it gains a case, handled by the existing box arm.
-- c6c499d: Text layout is computed once, and the caret reads the layout that was painted
-  
-  The paint, the pose silhouette and the click-to-edit caret each ran their own
-  walk. The paint went through a memoized `layoutRuns`; the silhouette re-ran
-  `layoutRuns` on every pose change, because it allocates a fresh `ResolvedRun[]`
-  per call and the cache keyed on array identity; and the caret summed
-  `ctx.measureText` per character, which sees no kerning, reads system fonts
-  rather than the registered face, and ignores per-run styling entirely. The
-  caret could therefore answer with a different line, and a different glyph, than
-  the one under the pointer — masked in practice only because it asked a WebGL
-  canvas for a 2D context and got `null`, degrading silently to no caret at all.
-  
-  `cachedLayoutRuns` now lives in `@weasel-js/text` beside the function it caches,
-  and all three go through it. It keeps the array-identity `WeakMap` as the
-  renderer's zero-cost path and falls through to a bounded LRU keyed on the runs'
-  structure, which is what lets a caller that cannot hold a stable array hit it —
-  about 230× cheaper than laying out again, at roughly 4× the cost of the
-  identity hit. `LaidOutLineBox` carries the caret stops the pen produced, so
-  snapping is to the advance cells the glyphs were actually painted in.
-  
-  **Breaking:** `caretIndexAt(ctx, x, y, pose)` is now
-  `caretIndexAt(x, y, pose, opts?)` — the `CanvasRenderingContext2D` is gone, and
-  an optional `maxWidth` mirrors `textLineBoxes` for nodes the `kit:text` painter
-  draws unwrapped. `useSceneTextEdit` no longer acquires a 2D context, so a
-  double-click always seeds the caret instead of falling back to editing from
-  offset 0. `@weasel-js/text` gains a `./test-seams` entry point exporting
-  `_resetLayoutCacheForTests`.
-- 4f1ef0b: Lay text out from font bytes alone — no baked atlas.
-  
-  `registerFontOutlines` was a paint upgrade for a family that already had an
-  MSDF atlas; a family with only font bytes could not resolve, so it rendered
-  nothing. It is now a tier in its own right: `OutlineFace` reports `ascender`,
-  `advanceOf` and `kernOf` in em units, `resolveFontVariant` resolves an
-  outline-only family, and `layoutRuns` reads advances, kerning and the baseline
-  through one source the atlas and a parsed face both satisfy. `outlineMinSize`
-  does not gate such a family — there is no other tier to prefer.
-  
-  This does not touch metric neutrality where it applies: a family that has an
-  atlas still resolves to the atlas, so registering outlines cannot move text
-  that was already rendering.
-  
-  Also fixes the outline tier in Node. opentype.js publishes ESM under `module`
-  and UMD under `main`; Node takes the UMD build, whose named exports it cannot
-  detect, so `parse` was undefined and every face failed to load — silently, via
-  the fallback to SDF. A browser bundler reading `module` never saw it.
-  
-  Breaking for a consumer-supplied `OutlineParser`: a face must now report
-  metrics as well as geometry.
-- 0114abf: Add `PaintInput`, a control that edits a whole `FillStyle`.
-  
-  A kind bar over a per-kind body, driven by the paint-kind registry rather than
-  a fixed list, so a consumer's registered kind appears in the bar and renders
-  that entry's `Editor`. `SelectionPanel`'s `paint` leaf renders it in place of
-  the chip that showed a gradient as indeterminate and wrote a solid over it on
-  first touch — so the checkerboard now means a mixed selection and nothing else,
-  and a gradient stroke is editable rather than merely paintable.
-  
-  Switching kinds keeps a per-kind memory for the control's lifetime, so
-  linear -> solid -> linear comes back with its stops instead of the ramp
-  `withGradientKind` cannot carry.
-  
-  `PatternPicker` moves from WeaselDraw into `@weasel-js/ui`, which now depends
-  on `@weasel-js/svg` for its tile previews.
-  
-  The bar offers **None**: "what kind of paint is this?" takes no-paint as an
-  answer. `setFill` and `setStroke` accept `paint: null` to write it — a fill
-  becomes `null`, and a stroke goes away entirely rather than keeping a width
-  that draws no ink. `PaintKindEntry` gains an optional `icon`, and the five
-  built-in kinds carry glyphs so six segments fit a property row.
-  
-  `FILL` and `STROKE` are now peer sections: the `appearance` group goes headless
-  and `data.fill` becomes a block leaf. The stroke's paint is no longer paired
-  with its width — a whole paint editor cannot share a row with a slider.
-- 50bc909: `FillStyle` is open: register a sixth paint kind and it renders, converts
-  frames and serializes.
-  
-  `registerPaintKind(entry)` returns a disposer and `_resetPaintKindsForTests`
-  re-seeds the five built-ins, matching the kit's other module-global
-  registries. An entry carries the editor's slots (`label`, `seed`, `colorOf`,
-  `Editor`), a render slot, both frame-conversion directions, and an SVG
-  `<defs>` slot. `listPaintKinds()` enumerates them, and `asPaint` types a
-  consumer's own paint as a `FillStyle` — the union itself stays closed, because
-  opening its discriminant would widen every built-in member.
-  
-  Three defects fall out of the same change, each of which a sixth kind hit
-  immediately. The renderer's fill dispatch fell off the end of its switch into
-  an unguarded cast to the gradient union, so an unknown kind read `stops` off a
-  paint with none and threw mid-frame. `fillInPoseFrame` and its inverse returned
-  an unknown kind untouched, leaving it painting in screen space on a node that
-  moves. `<defs>` emitted nothing for a kind `gradientXml` did not know while
-  still writing the `url(#id)` that referenced it.
-  
-  Registering a kind now bumps the node memo generation, so a node painted
-  before the registration repaints rather than holding the frame it resolved
-  when the kind was unknown.
-- 6a06f6d: Node paint is an object: `data.fill` is a `FillStyle`, `data.stroke` a `Stroke`
-  
-  Each concept now has exactly one shape. `data.fill` holds a `FillStyle`,
-  `data.stroke` a whole `Stroke`, and `null` on either is an explicit "no paint"
-  where `undefined` takes the painter's fallback. Two new authoring helpers keep
-  hand-written node data short:
-  
-  ```ts
-  data: { path, fill: solid('#7fb069'), stroke: strokeOf('#1c1c1c', 2) }
-  ```
-  
-  **Breaking, with no compatibility path.** A document written against the old
-  shapes renders wrong rather than failing, which is accepted:
-  
-  - `NodeFill = string | FillStyle` and `NodeStroke = string | Stroke` are gone,
-    and so are the string branches of `resolveNodeFill` / `resolveNodeStroke`.
-    A node holding `fill: '#f00'` now paints the default grey.
-  - `data.strokeWidth` is deleted. A stroke's width is `Stroke.width`.
-  - `data.color` — the legacy alias `kit:path` and the rect fallback read — is
-    deleted. The fallback painter reads `data.fill` like everything else.
-  - `fill: 'none'` is now `fill: null`; `stroke: 'none'` is `stroke: null`.
-  - `NodeInkResult` is gone: a painter's `ink` returns `NodeInk` and nothing
-    else. A painter returning `{ filled, strokeWidth }` no longer type-checks
-    and its reach is read as zero.
-  - `@weasel-js/ui` drops `isStrokeObject`, which existed only to discriminate
-    the union; `strokeColorOf` and `strokeWithColor` lose their string branches.
-  - `@weasel-js/svg`'s `strokeDataFromSvg` returns `Stroke | undefined` instead
-    of a `{ stroke, strokeWidth }` pair, and stops flattening a plain solid
-    stroke into a color. SVG's `fill="none"` imports as `fill: null`.
-  
-  **A paint's alpha lives in `opacity`, one slot for every paint kind.** That is
-  the only slot a gradient or a pattern has, so it is the slot all of them use,
-  and the renderer multiplies a hex alpha by it — the two would fight if both
-  carried the value. `solid()` therefore moves an alpha channel out of the hex:
-  `solid('#ff000080')` is `{ color: '#ff0000', opacity: 0.502 }`.
-  
-  The four setter actions follow: `setFillOpacity` / `setStrokeOpacity` write
-  `opacity` rather than splicing hex, so they now work on a gradient fill, which
-  they used to leave untouched. `setFill` / `setStroke` given a `color` recolor
-  the node's existing paint through the new `paintWithColor`, keeping its opacity
-  unless the picked color states an alpha of its own — and `setStroke` keeps the
-  stroke's width, cap, join and dash instead of replacing the whole value.
-  
-  New exports: `solid`, `strokeOf`, `paintAlpha`, `paintWithAlpha`,
-  `paintWithColor`, `DEFAULT_SHAPE_FILL`.
-  
-  `defaultNodeProperties` moves `data.fill` from a `color` leaf to a `paint` one
-  — a color control pointed at a `FillStyle` reads `undefined` off a gradient and
-  writes a bare string over it — and the `data.stroke` object leaf drops its
-  `fromScalar`, which had nothing left to lift.
-- a37ee0b: Separate a text node's content from its typography, and draw depth only where a label marks it
-  
-  The text schema put `data.text` in a group named Text, so the section read
-  TEXT and the row inside it read Text — one word nested in itself — and the
-  style groups below it read as fields of the content string rather than as its
-  siblings. Content is its own section now, with the field full-width because
-  the section already names it.
-  
-  A group with an empty `name` renders no heading. That already worked for
-  sections and is now documented on `ToolPrefGroup`, since it is how a schema
-  says "this group organises, it doesn't name": `Character` and `Paragraph`
-  carry the labels, and a `Typography` heading over them named nothing new.
-  It stays opt-in rather than a rule that rolls up any all-group parent —
-  a `Border` over `Top` / `Right` / `Bottom` needs its name.
-  
-  Rows under a suppressed heading no longer indent. Depth drawn without a
-  visible parent put `Character` a level deeper than `Content` while being its
-  peer, which is the panel's own tree discipline broken by its own hand.
-- 611b30e: Layers and deps answer for the view they are drawn for
-  
-  Nine lookups closed over the *surface's* state at construction, so they answered
-  for view zero in every view. `<CanvasView>` draws the surface's layer array
-  unchanged and only the draw envelope differs, which makes a `draw: (_data, …)`
-  a guarantee of answering for the wrong view rather than merely an unused
-  argument. A drag in view B ghosted in view A, the marquee painted in the wrong
-  view, chrome-caps resolved against the surface's selection, every Cmd+V centered
-  on the wrong camera, and Escape in view B cancelled view A.
-  
-  **New on `CanvasViewHelpers`** — `getPreviewSources()`, `getGestureOverlays()`
-  and `getIsVisible()`. All three are **required members**: anyone hand-writing a
-  `CanvasViewHelpers` (a test double, a wrapper) has to add them.
-  `getIsVisible` **moves off `CanvasSurfaceHelpers`**, where it could only ever
-  have answered for one view.
-  
-  **New on `GestureSource`** — `previewSources()` and `overlays()`, also required,
-  alongside the newly exported `GesturePreviewSource`. `toolPreviewSources(tools)`
-  is the tool half.
-  
-  **Layer options changed.** `createPathEditingOverlayLayer` and
-  `createSlopsDebugLayer` take `getPose(id, previews)` and have lost their
-  `isVisible` / `selectionRef` / `boundsOf` options — those come off the envelope
-  now. `usePreviewGhostLayer` has lost `tools`. Both it and
-  `useDispatcherOverlayLayer` keep `dispatcher` **only** to subscribe for repaint.
-  
-  **Picking takes a camera.** `pickEvery`, `pickBest` and `makeGetNodeAtPoint`'s
-  result accept an optional trailing `PickCamera`. A world point does not carry
-  the scale it was produced under and picking has no draw envelope, so the caller
-  that produced the point supplies it; omitting it keeps the surface camera.
-  
-  `useHoverTracking` took a `clientToWorld` thunk beside a world-space
-  `getNodeAtPoint` — the first resolved the view and the second did not, so hover
-  picked at the surface's scale inside a panel. It takes one
-  `nodeAtClientPoint(clientX, clientY)` now.
-  
-  Anchor-editing target state stays surface-wide; only the preview resolution on
-  that path is per-view.
-- 9ad8cb2: Picking answers for what was painted
-  
-  Three defects in `<SceneCanvas>`'s hit paths, all one shape — a pick answering
-  from something other than what the renderer drew.
-  
-  **Pose overrides were painted through and picked around.** `PoseOverride.pose`
-  is documented as replacing the document pose *everywhere the render and
-  hit-test paths read one*, and `sceneAdapter.getPose` honored it. But
-  `<SceneCanvas>` supplies its own `pickEvery`, which read `node.pose` raw — as
-  did the bounds resolver feeding selection chrome and the affordance
-  `ChromeState`, and the marquee/lasso scan. A consumer animating nodes through
-  overrides painted them at one place and picked them at another. `effectivePose`
-  is now the single rule and every one of those reads through it.
-  
-  **A clipped-away child was still clickable.** A container clips its subtree and
-  the renderer honors it, so a child outside the clip is not painted.
-  `useSelectTool`'s own walk has rejected those since clipping shipped; the walk
-  `<SceneCanvas>` installs instead had no clip term at all. The new
-  `passesAncestorClips` walks the parent chain per surviving candidate, so a flat
-  render-order scan can apply the same test.
-  
-  **The marquee's fast-reject used the unrotated pose box.** A 100×20 rect turned
-  45° puts a corner 32 units above that box; a rubber-band over that corner was
-  rejected before the rotation-correct silhouette test ran, while a click on the
-  same pixel selected the shape.
-- c1b8511: Repaint the scene-graph side-scroller demo's world from `data.fill`. Its
-  tiles, coins, enemies and flagpole still declared `data.color`, the alias
-  removed when node paint became an object, so every one of them rendered in
-  the default gray — the demo whose whole point is being the visual twin of the
-  immediate-mode load test.
-- d793d3c: Flip negates rotation; alignment guides and `gaps` distribute measure ink
-  
-  Three paths read a pose's stored, unrotated box where the rotated extent was
-  wanted.
-  
-  `flipPoseAboutBounds` carried rotation through untouched, so a mirrored shape
-  came back turned the same way — invisible on a rectangle, whose AABB is
-  symmetric under a sign flip, and plainly wrong on an asymmetric one, which
-  translated instead of mirroring. It now negates the pose's rotation.
-  
-  `deriveAlignmentGuides` advertised a stationary rotated sibling's lines at its
-  stored edges, while the dragged selection matched against them by its ink.
-  `RECT_ALIGN_PROJECTION.boundsOf` now returns the rotated AABB and
-  `deriveAlignmentGuides` reads its targets through the same projection — a new
-  `projection` option defaulting to the rect one, so existing callers get the fix
-  without a change.
-  
-  `useDistribute`'s `gaps` mode divided the leftover span by stored widths, so a
-  rotated member ended up with a gap short by the difference; `centers` shared the
-  line and the blind spot. Both now measure with `visualBoundsViaDescriptor`.
-  `distributeHorizontalAction` / `distributeVerticalAction` also take
-  `params.mode`, so `gaps` is reachable from a binding rather than only from the
-  hook.
-  
-  Flip and distribute return different poses than before for rotated shapes.
-  That is the fix, but it is a behavior change for anything depending on the
-  old output.
-- 3386d64: `@weasel-js/core/routing` exports the route-string projection
-  
-  Anything rendering a `GestureSpec` as a route string had to re-implement the
-  projection, and the copy in WeaselDraw's registry inspector had drifted three
-  ways: it answered `drop` and `paste` with no gesture name, so every binding of
-  either vanished from the route list; its argument lookup missed a spec field;
-  and it gated targets on a hand-listed set of kinds, dropping them for
-  `pointerDown`, `longPress` and `wheel`.
-  
-  New from the routing subpath: `routesForSpec(spec)` — every route string one
-  spec declares — plus `routeGestureForSpecKind(kind)` over the single spec-kind
-  map, and `PREDICATE_TARGET`, which `registry.ts` already exported but the
-  subpath index did not, so consumers reading `RegistryEntry.target` had no way
-  to compare against the sentinel its own docs name.
-- ce2b5c7: Make the inline run grammar a parameter instead of a hardcoded branch.
-  
-  `runsToMarkdown` and `markdownToRuns` each had the markdown subset spelled out
-  in their control flow — `***`/`**`/`*` and a two-character escape set — so
-  reading or writing any other spelling meant forking both. They now take a
-  `RunGrammar`: a table of markers pairing a repeated delimiter with the run
-  flags it toggles, defaulting to `MARKDOWN_RUN_GRAMMAR`, which is exactly
-  today's behavior. Escaping follows the grammar's own delimiters.
-  
-  Nothing changes for a caller that passes no grammar. `underline` and
-  `strikethrough` still have no markdown spelling and are still dropped by
-  `runsToMarkdown` — a grammar that wants `~~struck~~` now adds one marker
-  rather than editing the parser.
-- 2ea772f: `createSelectionOutlineLayer` and `createSelectionHandlesLayer` now do what the overlay layer does
-  
-  `createSelectionOverlayLayer` documents itself as equivalent to stacking the
-  other two, and it was not. It reads `ChromeState` off the draw envelope,
-  resolves the synthetic multi-resize id to the union AABB, honors chrome-caps
-  visibility and suppressed ids, and takes selection and poses from the envelope
-  when they are omitted. The two primitives did none of that: they ignored the
-  draw envelope entirely, required a construction-time `getPose` cascade, and
-  knew nothing about the multi-selection union — so a consumer who stacked them,
-  on the wrapper's own promise, got chrome in the wrong place with no way to
-  tell.
-  
-  All three now run one body and differ only in which passes they enable, so the
-  promise holds by construction. `SelectionOutlineLayerOpts` and
-  `SelectionHandlesLayerOpts` become the overlay's option set minus the visuals
-  that don't apply, which makes `getSelection` and `getPose` optional on both and
-  adds `getOutlineIds` and `getSuppressedIds`. Handle visuals are now the named
-  `SelectionHandleStyle`.
-- 3fb3a46: Key `usePublishSelection` on the publish callback, not the context value
-  
-  The effect depended on the whole selection-context value, and the provider
-  mints a new value object on every publish. So one publisher publishing refired
-  the effect for every other publisher in scope, each of which republished its
-  own ids — a newer selection got stomped back to an older one, and two
-  publishers holding different ids under one provider never settled at all.
-  
-  `publishSelection` is already a stable `useCallback`, so the effect now depends
-  on it directly. No provider change and no API change.
-- 84db1f6: Close four gaps that produced wrong answers with no error
-  
-  Three path walkers — `pathToMultiPolygon` in core and in `@weasel-js/geom`, and
-  `enumerateAnchors` behind the bezier-edit overlay — handled M/L/C/Q/Z with no
-  `default:` arm, so a command code they did not know fell out of the switch
-  without advancing the coordinate cursor and every segment after it read the
-  wrong floats. They now throw, matching the six sibling walkers. This is a
-  behavior change for anyone feeding these a path built with an opcode outside
-  `PATH_COMMANDS`: what used to come back subtly wrong now raises.
-  
-  A `<CanvasView>` built its affordance hit-test without a device profile, so a
-  nested view resolved fine-pointer radii even under a coarse pointer — 8px grab
-  zones against the 14px chrome the surface paints. It reads the profile
-  `<SceneCanvas>` publishes.
-  
-  `moveGestureAdapter`'s `insertNode` took no `index`, and the adapter carried
-  neither `getChildren` nor `setChildOrder`, so the sibling slot a delete op
-  records had nowhere to land: undoing a delete through the move pipeline
-  appended the node to the end of its parent instead of putting it back where it
-  was. All three are there now.
-  
-  The dev inspector's gesture panel formatted bindings with a private formatter
-  that reported only modifiers set to `true`. The `ingest` action marks every
-  modifier `'optional'`, so its drop and paste bindings rendered blank and the
-  action was invisible on both gestures. Both of the panel's plain-text
-  formatters now go through the kit's `routesForSpec`.
-- 3386d64: Undoing a multi-node delete or group restores document order
-  
-  Restoring by stored index cannot survive replay: history runs a batch's
-  inverses in reverse, while indices captured before the mutation are only
-  correct in ascending order. Deleting `b, c, d` from `[a, b, c, d, e]` and
-  undoing gave `a, b, e, c, d`; Cmd+G on the same three did the same.
-  
-  Ops now record a `Slot` — an ordinal plus the id of the following sibling at
-  capture. The anchor is the source of truth whenever it resolves, and it
-  resolves whatever else the batch has already restored. The ordinal remains as
-  the fallback for an adapter that can place by index but cannot enumerate
-  children. `before: null` means "last" and needs no sibling list; an absent
-  `before` means "unobserved", and the two survive `History.serialize` because
-  `undefined` drops out of JSON and `null` does not.
-  
-  The ops observe their own slot during `apply()` rather than taking one from the
-  caller, so every existing emitter gets this without a call-site change.
-  `createDeleteOp`'s `index` argument is now a seed that `apply` supersedes; its
-  docstring said it was sufficient on its own, which it never was.
-  
-  Adapters without an ordering seam still append, as they did before:
-  `arrayAdapter` has no `setChildOrder`, and the move gesture's adapter has
-  neither that nor an `index` parameter on `insertNode`.
-- 7a746df: A stroke's dash is edited as a style, not as an array
-  
-  `Stroke.dash` already rendered, imported and exported; it had no control,
-  because a `number[]` has no leaf kind. It doesn't need one — the thing a person
-  chooses is a style, and the array is how it is stored. The stroke block gains a
-  Solid / Dashed / Dotted / Custom bar under cap, join and align.
-  
-  `ToolPrefEnum` gains `encoding`: `read`/`write` between the stored value and
-  the option string, the counterpart of the `unit` a number leaf already has for
-  a value stored in a canonical unit. Both directions are handed the object the
-  leaf is a field of, because a dash pattern is meaningless without the width it
-  scales by — SVG dash lengths are absolute, so a fixed `[6, 3]` is dots on a
-  hairline and a railroad on a 20px stroke. `dashForStrokeStyle` /
-  `strokeDashStyleOf` are the mapping, exported: **dashed is 3× the width on and
-  2× off, dotted 1× on and 2× off**. An array matching neither reads as `custom`,
-  a new `disabled` option — one a control reports but refuses to author, since
-  there is no array behind it. `solid` is stored as no dash at all, and an object
-  leaf's field written as `undefined` is now removed rather than left holding it.
-- 4f19274: Cap, join and align are chosen by glyph, and the stroke block drops its labels
-  
-  Nine option glyphs and four category glyphs join the icon set. The option
-  glyphs are filled silhouettes — the glyph is the ink, so a choice reads as a
-  shape rather than as a diagram of one. `align` is a circle zoomed until the
-  ink band's far edge leaves the box: `inner` closes into a disc, `outer` into
-  the box's complement of it, and `center` is the annulus straddling the path,
-  so the three are one band at three offsets. The categories are the bare path
-  each row treats, drawn in the outlined register.
-  
-  A schema carries a glyph *id*, not a component: `ToolPrefEnum`'s options gain
-  `icon`, and every leaf gains one for rows whose own label is spent on a
-  `pair`. Core ships no icon set and cannot depend on one, so the field is a
-  plain string; weasel-ui resolves it against `ICON_PATHS` and falls back to
-  `short` where it names no glyph.
-  
-  `SelectionPanel` now honours `block` inside an object leaf, not only at the
-  section level. A row whose fields are all `block` drops the 64px label column
-  and spans the block. The default stroke schema uses both: paint and width
-  share one label-less row, and cap/join/align share the next.
-  
-  `align`'s options run inner, center, outer — the order the ink moves outward.
-- 94f2446: Add stroke markers — arrowheads and other line terminators as stroke style.
-  
-  `markerStart` / `markerMid` / `markerEnd` on `Stroke` take a key resolved
-  through a new registry (`registerMarker`), shipping eight built-in shapes.
-  Unlike SVG, the stroke stops short of a filled head rather than running under
-  it to the tip; the distance is declared per marker, so an open V still reaches
-  the vertex. Round-trips through `@weasel-js/svg` as `marker-*` attributes plus
-  `<marker>` defs.
-- 07fd2de: `setStroke` takes a whole paint, so a gradient or pattern stroke is writable.
-  
-  It accepted `{ color }` only, and merged through `paintWithColor`, which
-  supersedes a non-solid paint with a solid one — a gradient stroke was
-  unreachable even though `setStrokeOpacity` could already reach its alpha.
-  `paint` now wins over `color`, a color arriving later in the gesture supersedes
-  an earlier paint, and the stroke's width, cap, join, dash and align survive
-  either. New `strokeWith(paint, width?)` is `strokeOf`'s sibling for a paint
-  that has no color to pass.
-  
-  Two fixes alongside it: `setFill` started with no `color` and no `paint` seeded
-  from `DEFAULT_STROKE_COLOR`, painting the selection black where
-  `setFillOpacity` seeds the same slot from `DEFAULT_FILL_COLOR`; and
-  `gradientForBounds`'s doc comment claimed a corner-to-corner linear gradient
-  where the body builds a left-edge-to-right-edge one.
-  
-  `@weasel-js/ui` no longer exports `strokeWithColor`. It shared a name with
-  core's and disagreed with it — core's keeps the paint's opacity, ui's dropped
-  it — and nothing imported it.
-- 81213fc: Edit a node's stroke as the union it is
-  
-  `data.stroke` holds `string | Stroke`, and the schema described it with a
-  `color` leaf — which reads `undefined` off the object form, shows its own
-  default, and writes a bare hex back over the stroke's width, cap, join and
-  dash on the first edit. The same trap `ToolPrefPaint` was introduced to avoid
-  for `FillStyle`.
-  
-  A `stroke` pref kind now describes it, and `defaultNodeProperties` uses it.
-  Its control shows whichever color the value has — the string itself, or a
-  solid paint's color — gives a gradient stroke the indeterminate chip rather
-  than claiming a color it doesn't have, and preserves the form on write.
-  
-  `PrefsForm` gained the `stroke` case and the `paint` case it never had; a
-  `paint` leaf used to render as the literal text `(paint: no renderer)`.
-  `solidColorOf`, `strokeColorOf`, `strokeWithColor` and `isStrokeObject` are
-  exported from `@weasel-js/ui` for consumers writing their own property
-  renderers against either union.
-  
-  Cap, join and dash are not editable from a panel yet, and `data.strokeWidth`
-  remains its own leaf — see `docs/proposals/2026-08-26-node-stroke-union.md`
-  for why that waits on the SVG mapping.
-- 2f225d7: A thick stroke is clickable across its whole width
-  
-  `shapeCoversPoint` grants a grab out to a stroke's outward reach — a full
-  stroke width for an `outer` align — but the AABB pre-filter that runs before it
-  grew only by the pointer slop. So half a thick outer stroke's ink was
-  unclickable: the point was rejected before the refinement that would have
-  claimed it ever ran. `poseContains` carried a comment claiming the pre-filter
-  was at least as generous as the refinement, which it cannot be on its own,
-  since it never sees the stroke. That budget is the caller's, and the comment
-  says so now.
-  
-  `ShapeCoversPointOptions.scale` was never passed either, so a stroke width
-  declared in `px` resolved as world units and the reach was wrong at every zoom
-  but 1 — while the caller computed `meanScale(view.scale)` one line above.
-- 68069dc: Right-to-left text lays out in visual order
-  
-  `LayoutRunsOpts` takes an optional `bidi` engine. Given one, `layoutRuns`
-  analyses the paragraph, reorders each line after the wrap, and mirrors brackets
-  in right-to-left runs. Given none, nothing changes: text lays out logically,
-  exactly as before.
-  
-  `@weasel-js/text` declares the `BidiResolver` interface and does not depend on
-  `@weasel-js/bidi` — the dependency runs the other way from the usual, so a
-  consumer who renders no right-to-left text never installs the Unicode tables,
-  and a different implementation can be substituted. `@weasel-js/bidi` is a
-  devDependency here only, for a test that drives real Hebrew through the real
-  engine; types lining up is not evidence the semantics do.
-  
-  `LaidOutCell` gains `advance` and `level`, and **`x` is no longer monotonic
-  across `cells`**. Cells stay in logical order — slot `i` is still character `i`
-  — while their x values follow the reordering. Sort on `x` for visual order, and
-  read a cell's extent as `[x, x + advance)` rather than reaching for the next
-  cell's `x`. Hit-testing was doing exactly that and now sweeps in visual order
-  against each cell's own extent, taking a right-to-left cell's visually-leading
-  half as the character's logical end.
-  
-  Kerning is a gap between two adjacent characters, and the wrap measures it
-  logically. Reordering can put a different pair side by side, so the gap taken
-  is the one belonging to whichever of the two is logically second, and none at
-  all across a direction boundary — where the pair never touched in the source.
-  
-  Laying out right-to-left text with no engine now warns once, naming the import.
-  The alternative is glyphs silently appearing reversed, which is the one real
-  hazard of making this opt-in.
-- 5d0ff9c: Every code point on a line gets a cell
-  
-  `LaidOutLineBox` replaces its `caretXs` / `caretIndices` pair with
-  `cells: LaidOutCell[]` plus a `srcEnd` closing offset. A cell carries
-  `srcIndex`, `srcEnd`, `cp`, `x` and `drawsInk`, so slot `i` is `cells[i]` and
-  a consumer indexing per character no longer has to reconcile a sparse array
-  against the source string.
-  
-  The old arrays were documented as non-contiguous, and two causes were real:
-  
-  - A code point no tier could serve was dropped outright, taking its caret stop
-    with it. It now occupies a zero-advance cell. This is reachable whenever the
-    dynamic canvas fallback is off — which is the normal configuration for a
-    consumer registering its own outlines, where the outline tier has no rung
-    below it.
-  - A space opening a line — at the start of the text, or after a newline — was
-    discarded. It now keeps its cell and still consumes no width, so a line is
-    addressable per character without gaining an indent. A space that opens a
-    *wrapped* line was never affected: the wrap leaves it as a trailing cell on
-    the line before.
-  
-  Neither changes any geometry: both cells carry zero advance, zero tracking and
-  no kerning, so bounds, line widths and glyph positions are unchanged.
-  
-  A newline still has no cell, since it separates cells rather than being one.
-  `srcEnd` is what a blank line carries in its place.
-  
-  `drawsInk` is a property of the code point and the face, not of the call that
-  produced it: it does not flip when a dynamic bake lands or the outline
-  threshold is crossed, so the same text reports the same slots every time. A
-  zero-advance combining mark is `true` — it inks without advancing.
-- c1b8511: **Breaking:** paint leaves `TextStyle`. A text node's color and outline are
-  `data.fill` and `data.stroke` — the same two leaves every other node kind
-  paints from — and `TextStyle` holds typography only. `TextStyle.fill` and
-  `TextStyle.stroke` are gone, with no compatibility read: a document that put
-  its color in `style.fill` now renders in the default black rather than
-  erroring, so check documents that predate this.
-  
-  This fixes a real asymmetry rather than only moving fields. `data.stroke`
-  already reached text through a fold in the painter, but `data.fill` did not:
-  picking a fill color with a text node selected wrote a field nothing read, so
-  the canvas did not change. `setFill`, `setFillOpacity`, the opacity scrub and
-  the Appearance leaf now all mean the same thing on text as on a rect. The
-  duplicate `data.style.fill` control is gone from the text schema with them.
-  
-  `resolveTextStyle(style, paint)` takes the node's paint as a second argument
-  and is what derives the caret and selection colors, so the edit overlay
-  matches the glyphs it sits on; `useTextEdit` gained a `getPaint` option for
-  the same reason, defaulted by `useSceneTextEdit` from `data.fill` /
-  `data.stroke`. `TextPose` gained `fill` / `stroke`, so text drawn through
-  `createTextLayer` is painted rather than black. `SvgTextNode` gained the same
-  two, and SVG import and export carry text paint there instead of inside the
-  style. `StyledRun.fill` and `.stroke` are unchanged and still override the
-  node's per range — which is also where a caller with no node at all, a HUD
-  widget or a debug overlay, now states its color.
-  
-  `textCommandFromRuns` is exported from the package root.
-- 546f67d: Draw text from a ring of reused vertex buffers instead of minting a vertex
-  array and two buffers per draw. `drawTextGroup` and `drawTextDecorations` were
-  the last paths still doing what `drawImage` stopped doing; text now costs
-  **3.3 us/command, down from 6.65** at 512 commands a frame on an M2 Max via
-  ANGLE (`tests/perf/transition-matrix.spec.ts`), which puts it level with an
-  image draw. No other command kind moved.
-  
-  A text group is as many quads as it has glyphs, so unlike the image ring a
-  slot's buffer grows to the largest run it has seen rather than being fixed at
-  four vertices. The quad index pattern is a pure function of the quad count —
-  the pattern for N quads is a prefix of the pattern for any larger N — so one
-  index buffer serves every slot, grown the same way and written only when it
-  grows.
-- c2ffa49: Alignment can resolve against reading direction
-  
-  `align` gains `start` and `end` alongside `left` / `center` / `right`, and
-  `TextStyle` gains `direction: 'ltr' | 'rtl'`. The split is CSS `text-align`'s:
-  the relative pair resolves against the direction, the absolute pair ignores it.
-  `resolveAlign(align, direction)` collapses one to the other and is exported for
-  consumers that need an edge rather than an intent.
-  
-  Direction is an input, not something this package discovers. `@weasel-js/text`
-  has no DOM, so a consumer that reads `getComputedStyle(box).direction` passes
-  what it found; nothing here sniffs an environment.
-  
-  Defaults are unchanged — `align: 'left'`, `direction: 'ltr'` — so no existing
-  layout moves. Making `start` the default alignment is a separate call.
-  
-  `@weasel-js/svg` carries the direction through: `direction` joins the
-  inheritable presentation properties, and `text-anchor` is now written and read
-  against it. Two things were wrong before and are worth naming, because both
-  rendered plausible output:
-  
-  - `align: 'start'` serialized to `text-anchor="end"` — the opposite edge — via
-    a mapping that assumed three values and read the fourth as its `else`.
-  - SVG's initial `text-anchor` is `start`, which under `direction="rtl"` is the
-    right edge, while this model's default `align` is `left`. They agree under
-    `ltr` and only there, so an RTL document with no explicit anchor imported as
-    left-aligned.
-  
-  This is alignment and round-tripping only. Layout still walks code points in
-  logical order with the pen always increasing: there is no bidi reordering and
-  no shaping, so a Hebrew or Arabic string aligns to the correct edge and still
-  renders in logical order, and Arabic still renders unjoined.
-- 4c097ef: Sit every run on a line on one baseline
-  
-  Mixed-size text hung each run off the *line top* at its own ascent instead of
-  off a shared baseline, so a 16-unit run beside a 40-unit run floated up level
-  with the big run's cap rather than standing on the line with it. Two faces with
-  different ascents at the same size diverged the same way. Baseline alignment is
-  what inline text does everywhere else, and the module header already claimed
-  this behavior — the walk just never implemented it.
-  
-  A line now sinks one baseline far enough to clear its tallest run's ascent and
-  places every glyph against it. Glyph quads derive their top from that baseline
-  rather than from the pen's line top, which is the whole of the change:
-  `qy0 = baselineY + (yoffset - metrics.base) * scale`.
-  
-  Uniform-size text — nearly all text — is unchanged, since the maximum over one
-  value is that value. Only lines that actually mix sizes or faces move, and they
-  move to where they always should have been.
-  
-  The test named "mixed-size runs share a baseline on the same line" asserted only
-  a quad count and passed throughout; it now asserts the baselines.
-- 2b86e00: A text node's style is one value, not ten sibling paths
-  
-  `data.style.fontSize`, `.fontWeight`, `.align` and the rest addressed into one
-  `TextStyle` from ten independent leaves, each control writing a field of a
-  value it could only half see. `data.style` is an object leaf now, with
-  Character and Paragraph as groups inside it — groups head their fields and
-  contribute nothing to the path, so a field is still a field of the style and
-  one commit writes the whole thing.
-  
-  An object leaf whose fields are entirely grouped no longer prints its own
-  heading, which would stack straight onto the first group's, and a group's
-  fields sit under a rule so the nesting reads. WeaselDraw's inspector descends
-  into an object leaf when listing what a kind exposes — the fields are the
-  editable surface; the leaf is the container.
-  
-  `SelectionPanel` has a story now, which is how the two layout defects above
-  were found.
-- d933a89: Superscript, subscript and overline for styled runs
-  
-  `StyledRun` gains `script: 'super' | 'sub'` — a raised or lowered baseline and
-  a smaller size together, the pair `<sup>` and `<sub>` imply. It is a preset
-  over two new primitives rather than a mechanism of its own:
-  
-  - `baselineShift` — raise (positive) or lower (negative) a run off the line's
-    shared baseline, in ems of the inherited font size.
-  - `fontScale` — a multiplier on the inherited font size, the relative
-    counterpart to `fontSize`. An absolute `fontSize` still wins over it.
-  
-  Naming either directly overrides that half of `script` and leaves the other
-  alone. The preset's numbers are exported as `SCRIPT_METRICS` (58.3% size,
-  ±33.3% position — Adobe's defaults, so a character panel can show percentages
-  its users already recognize) and are derived, not read from the font: `OS/2`
-  carries real `ySuperscript*` metrics but the baked atlas tier has no slot for
-  them, and metrics that applied on one glyph tier and not the other would
-  reflow text as it crossed the size threshold.
-  
-  `resolveRuns` folds all of it into one world-unit `baselineShift` and a final
-  `fontSize`, so layout never learns superscripts exist — it places a run against
-  a baseline and an offset. The shift moves a run's glyphs, its outline geometry
-  and its own decoration rules together, and deliberately does not feed back into
-  the line's baseline or height: a superscript rides the line rather than
-  reflowing it.
-  
-  `overline` joins `underline` and `strikethrough` on both `TextStyle` and
-  `StyledRun`, additive over the node style like the other two, and is now
-  available to a custom `RunGrammar` as a `RunFlag`. The default markdown grammar
-  is unchanged — it stays silent on the decorations, as it always has been.
-- 5923c8b: `Animator.tween` no longer fires `onDone` for a tween that was cancelled during
-  its own final `onTick`. The last tick emitted the value and completed in one
-  pass, so a write made from that tick — cancelling the tween — still got the
-  completion callback, against the documented "not called on cancel" contract.
-- 2ea772f: Undo of a delete restores the subtree; undo of a group restores the slot
-  
-  Two ops inverted to something narrower than what they applied, so undo
-  silently lost data.
-  
-  `createDeleteOp.invert()` re-inserted a single node while `apply()` called
-  `removeNode`, which cascades the whole subtree. Delete a container with two
-  children, undo, and the container came back with `children: []` while both
-  children were gone. The op now snapshots its descendants preorder through the
-  adapter's optional `getNode` / `getChildren` — the snapshot is written back
-  into `args`, so an op rebuilt from a serialized entry still inverts — and
-  re-inserts each descendant at its captured slot. A flat adapter's `removeNode`
-  does not cascade, so the inverse skips any descendant the adapter still reports
-  as live rather than duplicating it.
-  
-  `createReparentOp` carried only the parent ids, so undoing a Cmd+G appended
-  instead of restoring the sibling slot and paint order changed. `ReparentArgs`
-  now carries `fromIndex` / `toIndex` and places through the existing
-  `getChildren` / `setChildOrder` seam that `createReorderOp` already uses —
-  `setParent`'s signature is unchanged. Adapters without that seam no-op as
-  before. `groupAction` captures each member's index before mutating; `move` and
-  `snapToContainer` pass none and are byte-identical.
-  
-  `ops/delete.test.ts` stubbed `removeNode` as a one-id delete that did not
-  cascade, which is why nothing caught the first bug. It now runs against a
-  tree-backed fake.
-- 2ea772f: Selection chrome, gesture bounds and SVG export fold rotated ink, not pose boxes
-  
-  Every union a user looks at or clicks folded each member's *unrotated* box.
-  Select two shapes, rotate one, and the multi-selection frame and its handles
-  sat inside the rotated shape's ink — affordances hand `ChromeState.unionBounds`
-  out as the target bounds for paint *and* hit-test, so the handles were both
-  drawn and grabbable in the wrong place, while `getGestureBounds()` reported the
-  correct larger box.
-  
-  `unionAABB` expands each rotated member via `axisAlignedBounds` before folding
-  and is now the one implementation. It lives in `core/geometry/unionBounds.ts`
-  beside the rotation-free `unionBounds`, which stays correct for commit-time
-  actions that write poses back in the unrotated frame; the module says which to
-  reach for. `unionGestureBounds` is **removed** — it was `unionAABB` under
-  another name. Both new functions are exported from the package root.
-  
-  Moved onto it: `ChromeState.unionBounds`, the selection overlay's
-  container-to-leaves resolver, the multi-rotate pivot (which put the pivot in
-  the wrong place whenever a member was rotated), and WeaselDraw's export
-  viewBox, which clipped rotated shapes out of the copied SVG.
-- 3fb3a46: Warn in dev when `useAction` finds no `ActionsProvider`
-  
-  `useAction` returned early on a null registry, so an action registered above
-  the provider — or with no provider mounted — silently never fired its
-  bindings. It now warns in dev, naming the action id. Runtime behavior in
-  production builds is unchanged.
-- Updated dependencies [5c8e9e6]
-- Updated dependencies [2621cbf]
-- Updated dependencies [0f936da]
-- Updated dependencies [4180095]
-- Updated dependencies [9977908]
-- Updated dependencies [52c7b2a]
-- Updated dependencies [3386d64]
-- Updated dependencies [c6c499d]
-- Updated dependencies [20097e6]
-- Updated dependencies [84db1f6]
-- Updated dependencies [94f2446]
-- Updated dependencies [68069dc]
-- Updated dependencies [5d0ff9c]
-- Updated dependencies [0bb27a5]
-- Updated dependencies [c2ffa49]
-- Updated dependencies [4c097ef]
-- Updated dependencies [d933a89]
-  - @weasel-js/text@1.3.0
-  - @weasel-js/geom@1.3.0
-  - @weasel-js/font@1.3.0
-  - @weasel-js/gestures@1.3.0
-  - @weasel-js/history@1.3.0
-  - @weasel-js/modes@1.3.0
-  - @weasel-js/paint@1.3.0
-
-## 2.0.0-pre.0
-
-### Minor Changes
-
-- bca99e3: Extract the typography layer into `@weasel-js/text`, and the paint vocabulary
-  into `@weasel-js/paint` — two new Tier A leaves.
-
-  `@weasel-js/text` owns the run model, style resolution, `layoutRuns`, wrap and
-  measurement. It depends on `@weasel-js/font`, `@weasel-js/geom` and
-  `@weasel-js/paint`, and on nothing else: a consumer with its own renderer can
-  lay out text without taking the scene graph or a React peer dependency.
-  `layoutRuns` is now public — it was previously reachable only from inside core.
-
-  `@weasel-js/paint` holds `FillStyle`, `Stroke`, gradients, dashes and
-  `TextureHandle`. It was the blocker named in the 2026-07-28 font split: the
-  layout could not move while its fill type lived in the renderer's graph.
-
-  `@weasel-js/core` re-exports both surfaces, so its own API is unchanged.
-  `Rect` moves to `@weasel-js/geom`, beside `Box`.
-
-  Breaking for anyone importing these through core's internal paths rather than
-  its public entry (`core/paint-types`, `features/text/*`); those paths are gone.
-
-  Advances and kerning still come from a baked MSDF atlas — laying out from font
-  bytes alone needs the metrics seam in
-  `docs/superpowers/specs/2026-08-28-text-package-extraction-design.md`.
-
-  <!-- bump-approved: minor: Mike — two new published packages (@weasel-js/text, @weasel-js/paint) and layoutRuns promoted to public API, on top of ~50 patch changesets carrying new public surface across core, ui and labkit; called explicitly in conversation on 2026-08-29: "tag a minor release and push" -->
-
-### Patch Changes
-
-- 3386d64: Align, distribute and flip use visual bounds
-
-  These folded each member's unrotated pose box, so "Align Left" on a selection
-  containing a rotated shape lined up the boxes and left the rotated shape's ink
-  sticking out past the others. They now work on the visual bounding box, as
-  Figma and Illustrator do.
-
-  Both ends moved together — expanding only the union would have made alignment
-  worse, since the delta runs from an edge of the union to the same edge of each
-  member's box. The new exported `visualBoundsViaDescriptor(pose, geometry)`
-  reads a pose's bounds, recovers its rotation and expands via
-  `axisAlignedBounds`; the union folds those with `unionAABB`. The delta is still
-  applied as a translation of the stored pose through
-  `translatePoseViaDescriptor`, so a shape moves rather than being re-posed.
-
-  Flip needed only its union pivot changed: mirroring maps a centre and preserves
-  size, and an expanded box is concentric with the box it came from.
-
-  `alignMoveBehavior` folds the dragged selection the same way, so a drag snaps
-  by its ink.
-
-- ffafb7d: Never let an animation's virtual clock run backwards.
-
-  `useAnimator` seeds each animation's `lastRealNow` from `now()` at register
-  time, then advances its virtual clock by the difference against the timestamp
-  the frame loop supplies. Those two share a time origin in a browser, where the
-  rAF timestamp and `performance.now()` are both page-relative — but that is a
-  browser guarantee, not a universal one, and jsdom starts them roughly 600ms
-  apart. The first frame's delta then came out hugely negative and `virtualNow`
-  spent dozens of frames climbing back toward zero before a tween advanced at
-  all: a 40ms glide took 95 frames and over a second of wall time, growing worse
-  the longer the process had been alive.
-
-  A frame's elapsed time is never negative, so the sample is now clamped at
-  zero. Under a shared origin this is a no-op.
-
-- ba8b139: Camera animation: `viewport.animatedZoom` now does something
-
-  `animatedZoom` has been declared on `SceneCanvasProps.viewport` and read by
-  nothing; Cmd+=/-/0 was a bare `view.set`. It now routes the discrete zoom steps
-  through the kit's `Animator`. Wheel and pinch are unchanged and never animate —
-  their input already delivers a sample per frame.
-
-  Camera animation is a general surface, not a zoom flag. Three ways in, one
-  runner behind them:
-
-  - `useViewAnimation(view, animator?)` — `animate`, `animateToBounds`, `stop`,
-    `isAnimating`, `target`.
-  - The `view` dep gains optional `animate` / `stopAnimation` / `animationTarget`,
-    so any action can glide the camera.
-  - `SceneCanvasApi` gains `animateView` / `stopViewAnimation` /
-    `isViewAnimating` for fit-to-selection, recenter, or a scripted tour. All
-    three are **required** members: anyone hand-implementing `SceneCanvasApi`
-    (a test double, a wrapper) has to add them, the way `CanvasExtensionApi`
-    grew `getPaintedVersion`.
-
-  Scale interpolates geometrically and translation is derived from the screen
-  point the two views agree on, so a zoom stays anchored instead of drifting and
-  each frame changes the view by the same ratio. One animation runs at a time; any
-  other view write cancels it, and a cancel leaves the camera where it is rather
-  than jumping to the target. On an uncontrolled canvas the whole animation costs
-  no React render.
-
-  **Breaking:** `useViewTween` is removed. `useViewAnimation` keeps its name and
-  changes signature — it takes a `{ get, set }` view channel plus an optional
-  `Animator`, and `animateTo(from, to, { duration, easing })` becomes
-  `animate(to, { ms, easing })`. The `from` argument is gone because the runner
-  reads the live view, which is what lets an interrupted camera resume from where
-  it actually is instead of snapping back to a captured start. `cancel()` is now
-  `stop()`, and `animateToBounds(bounds, currentView, dims, { duration })` is now
-  `animateToBounds(bounds, dims, { ms })` — the `currentView` argument goes for
-  the same reason `from` does.
-
-  **Breaking:** `viewport.recenter` and `ViewApi.recenter` widen to
-  `() => View | void`. Returning the target view lets Cmd+0 animate there;
-  returning nothing keeps the existing behavior. `animatedZoom`'s config fields
-  are `ms` / `resetMs` rather than `duration` / `resetDuration`, matching the
-  animator's vocabulary.
-
-- 3fb3a46: Forward `onFocus` and `onBlur` from the canvas element
-
-  The canvas is focusable by default (`tabIndex` 0) but exposed no way to
-  observe focus, so consumers driving focus-dependent chrome had to attach a
-  listener to an ancestor and infer it. Both are now props on `CanvasProps`, and
-  so reach `SceneCanvasProps` and the canvas element unchanged.
-
-- 67bcb05: Drop four values the canvas layer memo no longer reads
-
   `hit-test affordances against the painted chrome state` moved the selection
   overlay to reading bounds off the chrome state at paint time, which left
   `selectedIds`, `multiActive`, `previewToolPose` and `previewToolBounds`
   referenced only by the `layers` memo's dependency array — nothing in the body
   used them. Removing them from the array made all four dead locals, so they go
   too.
-
+  
   The memo now rebuilds the layer array on layer/tool/geometry changes rather
   than additionally on every selection and preview-pose change. Selection chrome
   is unaffected: it repaints from chrome state, not from the identity of this
   array.
-
 - 47cbb08: A closed subpath's dash no longer seams at its start vertex
-
+  
   `splitForDash` flushed the run still open when a closed subpath's walk returned
   to the vertex it started from as its own open sub-polyline, so it and the run
   that began there rendered as two butt-capped ribbons meeting at a point — a
@@ -3232,17 +2383,16 @@
   is drawn across the seam like any other corner. A pattern whose first "on"
   length covers the whole perimeter emits a closed ribbon, identical to the
   undashed stroke.
-
 - f43e9c2: A derived edge follows the drag that moves its endpoint
-
+  
   `move`, `resize` and `rotate` kept their in-flight poses in action-local
   scratch and published them only as `previewIds` / `previewPose`. That surface
   is enough to paint a ghost and size selection chrome, but nothing that asks
-  the _scene_ where a node is can see it — and `scenePoseLookup`, which resolves
+  the *scene* where a node is can see it — and `scenePoseLookup`, which resolves
   a derived node's geometry, asks the scene. So dragging a box left its edge
   anchored to the pre-drag position until the drop, when the commit invalidated
   the dependents and the edge jumped.
-
+  
   The three actions now also publish each frame into the scene's ephemeral pose
   overrides (`syncPreviewOverrides` / `dropPreviewOverrides` in
   `interactions/actions/previewOverrides.ts`). Overrides bypass `executeAndLog`,
@@ -3250,101 +2400,98 @@
   avoided per-frame scene writes in the first place was history, and this writes
   no history. Entries are set once and mutated in place, published with a single
   `commit()` per frame.
-
+  
   Picking follows for free: the pick source resolves a derived path through its
   own override-aware `poseOf`, so an edge is grabbable where it is drawn
   mid-gesture rather than where it used to be.
-
+  
   `clone` is deliberately untouched — its previews are the new ghosts at the
   drag target, and the originals never move, so nothing derives from a changed
   pose.
-
+  
   Also closes the matching gap in the preview-ghost layer, which built a
   container's clip with no derived path and so ghosted a derived container
   without one.
-
+  
   Note for anyone with a hand-written `Scene` stand-in: `overrides` is now read
   on every gesture frame. It was already required by the `Scene` contract, but a
   partial fake that omitted it will now throw rather than silently skip.
-
 - bb27e83: A derived node is clickable where it paints
-
+  
   A node whose geometry comes from `derivePath` had no silhouette and no `ink`:
   `NodeShapeEntry.silhouette` took only `(node, pose)`, and a derived path is
-  resolved from the _dependencies'_ poses, which a painter has no handle on. So
+  resolved from the *dependencies'* poses, which a painter has no handle on. So
   `kit:derived` could not report one, `shapeCoversPoint` read the resulting null
   as "no opinion" and answered `true` everywhere, and picking fell back to the
   node's own pose — for an edge, a zero-sized placeholder at the origin. An edge
   was unpickable, and a derived container contributed no clip.
-
+  
   `silhouette` now takes a `NodeSilhouetteCtx` carrying `derivedPath`, on the
   same convention `NodePaintCtx` already uses, and `kit:derived` reports the
   derived path as its silhouette and its declared stroke as its `ink`.
-
-  Resolving that path needs the scene, so it is the _source_ that answers, not
+  
+  Resolving that path needs the scene, so it is the *source* that answers, not
   the painter: `PickSource.derivedPathOf`, a matching optional argument to
   `buildSceneTree`, and `SceneSlotConfig.derivedPathOf` — the slot already
-  carried the derived path a node _paints_, and now also the clip a derived
-  container _imposes_, so the live canvas and the headless walk clip alike. The
+  carried the derived path a node *paints*, and now also the clip a derived
+  container *imposes*, so the live canvas and the headless walk clip alike. The
   bare-adapter paths supply none of them and behave exactly as before.
-
+  
   The pre-filter had to move with it. `useSceneSelectTool` grew its region test
   from the node's pose, which for a derived node is the wrong box entirely, so
   the edge was rejected before the shape test could claim it. It now tests the
   derived path when there is one — `poseContains` already reads a path-like pose
   as a path, so this reuses it rather than adding a second reach calculation.
-
+  
   `findShapeSilhouette` skips its memo when handed a derived path. That slot is
   keyed on `(node, pose, data)` and cannot see the path, so it would serve one
   caller's silhouette to a caller that passed a different one — the same reason
   `kit:derived` already skips `PAINT_SLOT`.
-
 - 6a33c3f: A node's path can be derived from other nodes' poses
-
+  
   A node declares `dependsOn: NodeId[]` and a `derivePath` function resolved by key
   through `SceneRegistry`, and the scene walks resolve its path before painting
   rather than it being authored. An edge drawn between two boxes is then an
   ordinary scene node — selectable, styleable, exportable — whose geometry never
   enters undo history. The seam and its traps are in `docs/extending.md`.
-
+  
   New surface: `scene.removeMany(ids)`; `dependsOn` and `derivePath` on
   `NodeBase` and on `AddNodeSpec`, which is what a consumer writes;
   `SceneRegistry.derivePath`; `SerializedNode.dependsOn` and
   `SerializedNode.derivePathKey`, both additions to the serialization format;
   `NodePaintCtx.derivedPath`.
-
+  
   Deleting a node now deletes everything that derives from it, transitively,
   including those nodes' own subtrees, in one undo entry — so `scene.remove` can
   remove nodes anywhere in the tree that the caller never named, and `removeLayer`
   reaches nodes on other layers. Undo after the built-in **Delete** key does not
   yet restore the cascaded nodes; see "Derived geometry follow-ups" in
   `docs/TODO.md`.
-
+  
   **Breaking: `defaultDrawOne` takes `(node, pose, view?, ctx?)`.** The paint
   context moves to a fourth parameter, so a call passing a `NodePaintCtx` third is
   now a type error rather than a silent slide into the `view` slot. The same
   fourth parameter is added to the `SceneViewDrawOne` and `SceneSlotConfig.drawOne`
   callback types, which is not a break: an existing three-parameter implementation
   still satisfies them, and an existing three-argument call still compiles.
-
+  
   **Breaking: `Scene` gained a required `removeMany`.** A hand-written object
   typed as a `Scene` — a test double, most likely — no longer typechecks until it
   implements it.
-
+  
   **Breaking: `kit:remove`'s op payload changed shape.** `rootId` / `parent` /
   `index` became `detached: { id, parent, index }[]`, because a cascaded dependent
   is not a descendant of the removed node and the tree has to be told about every
   subtree that came out of it. A history persisted by an older build now throws
   mid-undo rather than degrading. The break is deliberate; kit op payloads are not
   versioned.
-
 - c24e7de: Detached views follow pose overrides
-
+  
   `<SceneViewCanvas>` and `<MinimapCanvas>` re-rendered off `scene.getVersion()`,
   which a pose override deliberately never bumps — so they kept painting document
   poses while `<SceneCanvas>` painted the overridden ones. A minimap beside a
   canvas driving a drag or a simulation silently disagreed with it.
-
+  
   `<SceneViewCanvas>` now paints through `useFrameLoop` instead of from React, and
   subscribes to `scene.overrides`. A render (prop change or version bump) and an
   override commit both just mark the surface dirty, and one animation frame
@@ -3352,39 +2499,37 @@
   render, and a backgrounded tab stops painting them entirely. The mount paint
   stays synchronous, so the first frame is still the scene rather than a blank
   canvas. `<MinimapCanvas>` inherits all of this through it.
-
+  
   Repaints driven by a prop change are now asynchronous: they land on the next
   animation frame rather than in the layout effect of the render that caused them.
   Code that renders and then reads pixels in the same tick needs to wait a frame.
-
-  A minimap's _framing_ still derives from document poses, so a node overridden
+  
+  A minimap's *framing* still derives from document poses, so a node overridden
   outside the document bounds paints outside the fitted frame — recomputing the
   fit per frame would rescale the whole minimap throughout a settle.
-
 - ce82f4a: An enum leaf can ask for a segmented control, and `pair` works inside an object
-
+  
   `ToolPrefEnumControl` gains `'toggle'`: a three-option enum shows all three at
   once instead of hiding two behind a select. Options carry an optional `short`
   label — a capital or two — for the width a property row has; the full `label`
   stays the accessible name, so the abbreviation never becomes the only thing
   naming the option. A mixed selection selects no segment rather than picking a
   winner.
-
+  
   `pair` now merges fields inside an object leaf, as it already did for section
   rows — a hint shouldn't mean something different for being a field of a value
-  rather than a sibling of one. It merges _adjacent_ leaves in both places, so
+  rather than a sibling of one. It merges *adjacent* leaves in both places, so
   the schema orders family, size, weight: size and weight pair, and family (which
   sat between them) moves ahead of the pair rather than splitting it.
-
+  
   A stroke's cap, join and align share one row; property rows wrap rather than
   overflow when the controls in them don't fit.
-
 - be697dc: Add ephemeral pose overrides to the scene
-
+  
   `scene.overrides` holds a per-node `{ pose?, alpha? }` that the render and
   hit-test paths read through and that history, `toJSON()` and `getVersion()`
   never see. It is additive: a scene with no overrides behaves exactly as before.
-
+  
   This is where per-frame motion belongs. A 60 Hz loop previously had to write
   through `setPose`, which records an undo entry (one per frame at best, batched)
   and bumps the scene version, re-rendering every `useSyncExternalStore`
@@ -3392,47 +2537,45 @@
   frame, because the painter memo keys on pose reference. An override entry is
   hoisted once and mutated in place; `overrides.commit()` publishes the frame and
   invalidates the memo for the overridden nodes only.
-
+  
   `commit()` is required after an in-place mutation — without it the memo serves
   the previous frame's draw. Overrides are cleared when a node is removed, since
   ids are reusable. To make a frame permanent, write it once through `setPose`
   and clear the override; that single step is the undo entry.
-
+  
   `ForceGraphDemo` now settles with zero history entries and bakes the result as
   one, replacing a per-tick batch of 24 `setPose` calls.
-
 - e909a3b: `fitTextPose` sizes a box the renderer will actually fill
-
+  
   It was the fourth site measuring text its own way: `ctx.measureText` per
   character against system fonts, no kerning, `pose.text` only. Nothing masked
   it the way the WebGL context masked the caret — a consumer calling it got a
   box that disagreed with the paint, narrower by a kern on every pair and wrong
   by the whole difference between the installed family and the registered face.
   It goes through the shared layout now, so it sees kerning and per-run styling.
-
+  
   **Breaking:** `fitTextPose(ctx, pose, opts)` is now `fitTextPose(pose, opts)`.
-
 - 26bbdcf: Paint the canvas from its own animation frame instead of from a React render
-
+  
   `requestRedraw()` marks the surface dirty and the next frame paints, so many
   redraws in one tick cost one paint. The view gains an imperative path on the
   canvas handle — `setView` / `getView` / `subscribeView` — and `SceneCanvas` no
   longer holds it in React state, so a camera moving at 60 Hz costs no renders.
   Consumers passing a `view` prop stay controlled and are unaffected.
-
+  
   Opt-ins that come with it: `syncPaint` paints inside the commit for a consumer
   that wants the old whole-cloth guarantee, `useScene(…, { subscribe: false })`
   gives a host the scene without a render per mutation, `useSceneTextEdit`'s
   `view` option accepts a thunk so the overlay tracks a ref-driven camera, and a
   `contentVersion` prop feeds the version that `getPaintedVersion()` reports.
-
+  
   Two public signatures changed. `usePinchZoomTool` takes a view getter,
   `getView: () => View`, where it took a `View` — nothing re-renders to refresh a
   captured value any more. `CanvasExtensionApi` gained five required members —
   `getView`, `setView`, `subscribeView`, `subscribeFrame`, `getPaintedVersion` —
   so external code hand-implementing that interface stops typechecking; code that
   only calls through the ref is unaffected.
-
+  
   Pixels and DOM can now be a frame apart, in whichever direction the change came
   from. A view change leads with pixels: `setView` paints without rendering, so
   DOM built from the view is stale until something re-renders it — position
@@ -3441,64 +2584,60 @@
   pixels land next frame — compare `getPaintedVersion()` against the version you
   are about to render when chrome must be in lockstep. Do not render scene-derived
   DOM inside `startTransition`: React defers it and nothing forces it to catch up.
-
+  
   Anything reading the drawing buffer back outside a paint — the hud loupe's pixel
   mode is the one in-tree case — can likewise see a buffer one frame older;
   `subscribeFrame` runs on the frame that painted and removes the lag. Nothing
   paints while `document.hidden` is true, `syncPaint` included, so a readback from
   a background tab returns the frame from before the tab was hidden.
-
 - 546f67d: Copy typed-array arguments into `makeGLRecorder`'s call log as they are
   recorded. A caller is entitled to reuse the array it uploads from, so storing
   the reference recorded a value that later frames overwrote — a test reading
   two frames back saw the same numbers twice and passed. Test-only surface.
 - 3fb3a46: Release held keys when the window loses focus
-
+  
   A window that blurs mid-hold never delivers the keyup, so every in-flight
   `key-held` handle stayed engaged until that key was pressed again — holding
   Space and tabbing away left the hand tool on the hotkey stack indefinitely.
-
+  
   The gesture dispatcher now fires the `key-held` up phase for each held key on
   window blur. Consumers that hand-rolled this reset can drop it; ongoing
   invocations see a normal `onEnd`.
-
 - ccd51cc: Add a 43-glyph monochrome icon set to `@weasel-js/ui`.
-
+  
   One register: a 20x20 viewBox drawn in `currentColor` at stroke-width 1.5 with
   round caps and joins, hairline weight reserved for structure, and filled
   regions only where an action has a subject. Covers transport, history, view,
   trial lifecycle, collection, state, instrument and status vocabulary. Import a
   named component (`CloneIcon`), or `Icon` when the glyph is chosen at runtime.
-
+  
   `@weasel-js/ui` also re-exports the tool glyphs that live in `@weasel-js/core`,
   so consumers have one import site for the whole set. `ImageIcon` was reachable
   from core's icons folder but missing from its public barrel; it is exported
   now.
-
+  
   Glyph geometry is generated (`npm run gen:icons`) from `packages/ui/scripts/icons/`
   rather than hand-placed, because arrowheads and joins that miss their terminus
   are invisible at chrome size.
-
 - 3fb3a46: Compose `before` and `after` layer chains in both directions
-
+  
   `composeOrderedLayers` walked the two anchor maps separately: a chain hanging
   off an `after` anchor only followed further `after` links, and likewise for
   `before`. A custom layer anchored `before: 'scene'` carrying a second custom
   anchored `after` it dropped that second layer to the tail with a spurious
   dangling-reference warning.
-
+  
   Both walks now emit a layer's `before` chain, the layer, then its `after`
   chain, so the two mix freely. Cycle detection and orphan fallback are
   unchanged.
-
 - d9f110e: Stop every frame loop while nothing can see it
-
+  
   New public hook `useVisibleRaf` in `@weasel-js/core` owns the question of
   whether a frame may run: nothing runs while `document.hidden`, and a loop that
   names an element also stops while that element is outside the viewport. A
   request made while suspended is held rather than dropped and re-armed on
   resume, so a loop never polls visibility or needs restarting by hand.
-
+  
   Ten loops now run behind it — `useFrameLoop`, `useAnimator`, `useSimulation`,
   `useDecayLoop`, `useTextEdit`'s overlay follow, `CursorCoordsHud`'s FPS
   counter, `Badge`'s crawl, and labkit's `FpsMeter`, `useTiledSurface` and
@@ -3506,30 +2645,29 @@
   the rest ran on any page left open. `useLayerScheduler` looked safe and wasn't:
   it paints only dirty layers, but a hidden tab still commits React updates and
   its view/size effect marks every layer dirty.
-
+  
   Loops measuring elapsed time rebase their clock through the new `onResume`
   option, so an hour spent hidden does not arrive as one hour-long frame — an FPS
   meter reporting a rate nobody achieved, a tween jumping to its end value on
   return. `dangerouslyRunWhenHidden` opts a loop out for offscreen recording or
   export; nothing in the tree sets it.
-
+  
   `npm run check:frame-loops` fails the build on a bare `requestAnimationFrame`
   in kit source, and runs in CI.
-
 - 0dd35a1: Fix pinch-to-zoom: mac trackpads zoomed the page, and `viewport.pinchZoom` zoomed twice
-
+  
   A trackpad pinch reaches the page as `wheel { ctrlKey: true }`. On a mac
   `viewport.zoom`'s `mods: { mod: true }` binding requires metaKey and forbids
   ctrl, and `viewport.wheelPan` forbids ctrl too, so nothing claimed the event
   and the browser's own ctrl+wheel page zoom ran. `viewport.zoom` now carries a
   second wheel binding on bare ctrl. Off mac it duplicates the `mod` binding,
   where the matcher picks a single winner.
-
+  
   Nothing caught that because `IS_MAC` read `navigator.platform ?? userAgent`,
   and jsdom reports an empty-string platform — not nullish, so the fallback never
   fired and every mac binding in the kit was exercised only on the non-mac
   branch. It reads `||` now.
-
+  
   Separately, `viewport.pinchZoom: true` mounted `<Canvas>`'s `usePinchZoomTool`
   alongside the `viewport.pinchZoom` action that already handled the same
   gesture, applying one pinch's factor twice — the opt-in broke the path that
@@ -3538,36 +2676,34 @@
   the kit's 0.1–8 clamp now applied by default. `pinchZoom: false` disables pinch
   for real; it previously left the action running. Bare `<Canvas>` keeps the hook
   as its own pinch path.
-
 - 1a0bea3: `useNodeOverlayFrame`: the coordinate frame a DOM overlay pinned to a node needs
-
+  
   Nothing in the kit exported one, so consumers hand-rolled it — their own
   `ResizeObserver` next to the existing `useCanvasSize`, and a translate-and-scale
   inverse built by projecting two points. That inverse silently drops
   `pose.rotation`, which is why on-canvas gradient handles on a rotated node sat
   beside the paint instead of on it.
-
+  
   ```ts
-  useNodeOverlayFrame(scene, containerRef, nodeId, { view });
+  useNodeOverlayFrame(scene, containerRef, nodeId, { view })
   // → { box, toScreen, toLocal, width, height } | null
   ```
-
+  
   `box` is the node's composed world box, unrotated — the frame `toScreen` maps
   from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. Rotation
   lives in the pose→world leg, where it belongs: a node's stored geometry and its
   bounds-frame paint are pre-rotation by definition, so neither of those two
   changes.
-
+  
   `@weasel-js/ui` gains `SceneGradientHandles`, the scene-aware half of
   `GradientHandles`: it reads the gradient out of a node's `fill` **or** its
   `stroke` — `slot` is a prop — and commits each drag through `setFill` or
   `setStroke` as one undo entry. `GradientHandles` itself stays frame-agnostic.
-
+  
   Also: `isGradientFill` narrows a `FillStyle` to its three gradient members, and
   `useCanvasSize` accepts any `HTMLElement` rather than only a `div`.
-
 - 9d95836: A node's `data.stroke` takes a whole `Stroke`, not just a color
-
+  
   `NodeStroke = string | Stroke`, mirroring `NodeFill`. A string is still a
   color and `'none'` still skips the stroke; an object is a core `Stroke` whose
   `width`, `cap`, `join`, `dash`, `miterLimit` and `align` all reach the
@@ -3576,99 +2712,94 @@
   rule `withLeafStroke` already applied to text. A bounds-relative stroke paint
   is baked onto the pose box the way a fill is, so a gradient stroke resolves
   against the box it was authored against.
-
+  
   `kit:shape` now honors `stroke: 'none'`, which only `kit:path` checked before.
-
+  
   `NodeInk` reports `{ filled, outset, inset }` instead of `{ filled,
-strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
+  strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   `'outer'` none inside, which one number could not say, so picking grabbed the
   wrong side. `ink` takes an optional context carrying the view scale, so a
   `{ px }` stroke width resolves to world units. A painter that still returns
   `{ filled, strokeWidth }` is read as a centered stroke and keeps working.
-
+  
   `setStroke` and `setStrokeOpacity` no longer stringify a node's `Stroke`: a
   color pick replaces its paint and keeps width, cap, join and dash, and an
   opacity drag sets the paint's `opacity`, which is the only form that works on
   a gradient stroke.
-
+  
   Editing UI for the rich form is not here yet — a schema-driven color control
   still writes a bare string over the object, so nodes carrying one are for
   programmatic authorship until `SelectionPanel` learns the union. See
   `docs/proposals/2026-08-26-node-stroke-union.md`.
-
 - 62a3c46: Paint a gradient or pattern stroke instead of throwing.
-
+  
   `Stroke.paint` has always been a full `FillStyle`, and SVG import puts paint
   servers there deliberately, but the renderer refused anything but a solid — so
   importing a shape with `stroke="url(#grad)"` produced a scene that threw on the
   next frame. Both stroke paths now paint the ribbon through the same route a
   fill takes, including under the inner/outer alignment stencil. A non-solid
   even-odd fill no longer renders black.
-
 - 5f6c28e: An object leaf's fields can be organised into groups
-
+  
   `ToolPrefObject.children` takes a `ToolPrefGroup` as well as a leaf. A group
   heads its fields under a label and contributes nothing to the path — the same
   rule group keys follow at the top level of a schema, so a field inside one is
   still addressed as a field of the object.
-
+  
   Without it, a value with many fields renders as one undifferentiated list. A
   `TextStyle` is the case that needs it: its character and paragraph fields are
   one value but read as two lists.
-
 - 3cd1ee8: A schema leaf can hold an object, with its fields hanging off it
-
+  
   A compound value — a stroke, a shadow, a pattern spec — could be described as
   sibling leaves addressing into it (`data.stroke.width`, `data.stroke.cap`).
   It shouldn't be: each control then writes one field of a value it can only
   half see, and writing a field into something that isn't an object yet corrupts
   it outright.
-
+  
   `ToolPrefObject` describes the value instead. Its `children` are ordinary
   leaves whose paths are relative to the object, and every child edit commits
   the parent object whole. A field that is itself a union declares the kind that
   edits that union — a stroke's `paint` is a `paint` leaf. `fromScalar` lifts a
   value still held in a scalar form before a child edit lands on it, which is
   how a stroke stored as a bare colour string gains a width.
-
+  
   `defaultNodeProperties` describes `data.stroke` this way, so the panel shows
   Color, Width, Cap, Join and Align under one Stroke block, and the separate
   `data.strokeWidth` leaf is gone. `SelectionPanel` now honours `block`, which
   `PrefsForm` already did. The one-off `stroke` pref kind added days ago is
   replaced by this general one.
-
+  
   `dash` has no leaf: it is a `number[]` and no kind edits one. It survives
   import, export and rendering untouched.
-
 - 2ea772f: Selection handles are hit-tested at the size they are painted
-
+  
   Handles painted at `HANDLE_BASE_PX * targetScale` and hit-tested at the bare
   constant, and neither `buildAffordanceAt` call site passed the option that
   would have scaled it. A coarse pointer got a bigger picture and exactly the
   same 8px grab zone it had on a mouse — the touch forgiveness the coarse profile
   exists to provide never reached the hit-test. The slops debug overlay was a
   third unscaled copy, so it drew hit regions where they were not.
-
+  
   `core/device/targets.ts` now holds one base table and one accessor,
   `targetSizesPx(targetScale)`. Paint, hit-test and the debug overlay all resolve
   through it. `HANDLE_BASE_PX`, `ANCHOR_HIT_BASE_PX` and
   `ROTATION_HANDLE_BASE_PX` keep their names and values and now read off the
   table; the internal `HANDLE_HIT_RADIUS` and `ANCHOR_HIT_RADIUS` are gone.
-
+  
   `buildAffordanceAt` and `createSlopsDebugLayer` take an optional `targetScale`.
   `selectTool.handleHitRadius` now actually reaches the hit-test — it previously
   reached nothing.
-
+  
   `useRotateTool`'s `handleHitRadius` option is **removed**. The rotation
   affordance is an annulus with a band thickness and no point radius, so the
   option could only ever have been a second name for `rotationHandleDistance`,
   which is live and now defaults from the same table.
-
+  
   Known gap: `CanvasView` is a second `buildAffordanceAt` call site that reads no
   device profile, so a nested view still hit-tests at the fine-pointer size.
-
 - f77bd95: `getChildren` means one thing on an adapter
-
+  
   `MoveAdapter` declared `getChildren(id)` — a node's direct children, for the
   drag cascade — and `OrderedAdapter` declared `getChildren(parentId | null)`,
   the z-ordering seam where `null` means the root. Both land on the same adapter
@@ -3676,36 +2807,35 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   under the name the ops read with the second meaning. An op asking for root
   order got `[]`, which reads as "the root has no siblings", and the slot it
   captured was silently lost.
-
+  
   The two declarations are now one contract, and `arrayAdapter` answers the root
   from its own item array rather than delegating — a consumer callback written
   for node ids returns `[]` there, which cannot be told apart from a genuine
   empty answer. A consumer's `getChildren` config is still only ever asked about
   a node id.
-
+  
   `arrayAdapter` still exposes no `setChildOrder`, so it places by ordinal rather
   than by anchor. That is unchanged, and it is why the ordinal fallback exists.
-
 - 2ea772f: The canvas and the gradient editor now sample one gradient
-
+  
   `buildGradientRamp` carried its own interpolation beside
   `sampleGradientStops`, and the two disagreed three ways: the ramp had no guard
   at either end and extrapolated past the first and last stop, the two picked
   opposite sides of a coincident pair, and they parsed color differently — a stop
   written as a CSS named color rendered on the canvas and threw in the editor.
-
+  
   `sampleGradientStops` keeps its semantics and is now the only implementation.
   `resolveGradientStops` sorts and parses the list once; `sampleResolvedStops`
   returns the color at `t`. The ramp cache builds its texels through those, so
   there is no interpolation math left in the renderer.
-
+  
   Two behavior changes worth naming. `resolveColor` is the surviving parser, so
   gradient stops accept named and functional colors everywhere — but no longer
   hex without a leading `#`, which only the editor path had tolerated and the
   canvas never accepted. And `sampleGradientStops` returns normalized hex at the
   endpoints instead of echoing the raw stop string, so `'red'` comes back as
   `'#ff0000'`.
-
+  
   **SVG export:** a conic gradient left the exporter as a dangling `url(#…)` —
   the element already carried the reference, the built-in serializer returned
   nothing, and the registry's `toSvg` slot has no in-repo implementation, so the
@@ -3713,18 +2843,17 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   through to the same warning the pattern path already emits when nothing can
   produce a paint server. A consumer that registers a `toSvg` for
   `conic-gradient` still serializes and gets no warning.
-
 - aba8d91: Answer "can this node be hit" in one place
-
+  
   Four tree walks answered it separately — the generic-adapter point pick, the
   one `<SceneCanvas>` installs, `sceneToAdapter`'s area walk, and the live
   marquee/lasso — plus a fifth that shadowed the third. They agreed on every case
   that had a test and disagreed on the rest, three times, silently. `pickWalk`
   now owns every gate; a query supplies only its own shape test and the clip
   predicate for its region.
-
+  
   Behavior that changes as a result:
-
+  
   - **A node painted at alpha 0 is no longer clickable.** The pick path reads the
     same number the painter does — the view's `alphaFor` times any per-node
     override alpha — so a node faded out of sight stops claiming clicks. The
@@ -3740,13 +2869,12 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   - An ancestor clip now rejects an area query that reaches into the clip where
     the node is not, or reaches the node where the clip is not — the two terms
     together, where one alone let false positives through.
-
+  
   `useSceneSelectTool` takes `alphaOf` and `layerIsPainted` for the asking view.
   `passesAncestorClips` and its module are gone; `pickWalk`, `scenePickSource`,
   `adapterPickSource` and `ownClipOf` replace them.
-
 - 2ea772f: A drag-to-insert reports the bounds it paints
-
+  
   The painter, the commit factory and `getGestureBounds()` each sized an
   in-flight insert differently. The reporter read the drag rect alone, so a
   centered Alt-drag reported a half-extent of `d` against a painted circumradius
@@ -3755,45 +2883,43 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   all. The painter and the commit agreed on polygon and star but not on line or
   pencil: the commit posed the drag AABB for a line the painter drew endpoint to
   endpoint, and fell back to the drag rect for a trail under four samples.
-
+  
   One function now answers it for all three. The zero-area skip in the painter
   and the reporter tests the resolved extent rather than the raw drag rect, and
   an `InsertNodeFactory` that returns no `pose` falls back to the extent. The
   `bounds` argument handed to a factory is unchanged.
-
 - 3386d64: Path command opcodes derive from one table
-
+  
   `M`/`L`/`C`/`Q`/`Z` and their coordinate counts were declared five times —
   once in core, once in `@weasel-js/geom`, and three more as `COORD_COUNT`
   literals in the path transform, pose-rotation and pose-descriptor walkers. They
   agreed, and nothing held them to each other: a sixth opcode desynchronizes two
   packages' reading of the same `Uint8Array` with no exception and no type error,
   and every walker misparses the coordinate stream from that command on.
-
+  
   `PATH_COMMANDS` in `@weasel-js/geom` is now the table. `PATH_M`…`PATH_Z`,
   `PATH_CMD_LENGTHS` and the new `pathCommandCoordCount` all derive from it, and
   core re-exports them by name, so the opcode constants keep their names, values
   and literal types. The three walkers moved onto `forEachSegment` rather than
   onto the accessor alone — they were duplicating the coordinate-cursor advance
   as well as the length, and the cursor is the half that actually misreads.
-
+  
   Eight further files switch on these opcodes with inline literals. Five throw on
   an unknown code; three — the path boolean adapter, the anchor-editing geometry,
   and geom's own boolean adapter — have no `default` arm and would silently stop
   advancing. Left as-is; they need per-command semantics, not one walker.
-
 - 68d2651: Pref leaf kinds are declared once, and every renderer is exhaustive
-
+  
   `@weasel-js/ui` carried its own copy of the pref-leaf union under a comment
   saying to keep it in sync with core's field-for-field. It had drifted: ui's enum
   leaf had neither `encoding` nor `options[].disabled`, so a dash-array
   preference did not merely fail to select — choosing an option wrote the option
   string over the stored dash array. labkit's two renderers were missing the
   `paint` and `object` kinds outright.
-
+  
   ui's schema is now a rename re-export of core's declaration. The public `Pref*`
   names are unchanged, and there is nothing left to keep in sync.
-
+  
   More importantly, all four renderer switches ended in `default:`, so adding a
   built-in kind produced no error at any site and simply rendered nothing —
   verified by adding one and typechecking. `ToolPrefLeaf` widens `kind` to
@@ -3803,34 +2929,32 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   `isBuiltinToolPref(leaf)`, which narrows to the closed union so each renderer
   can discriminate and end in a `never`. App-defined kinds take the placeholder
   path as before.
-
+  
   Dash-array preferences now select and commit correctly in `PrefsForm`: the enum
   arm threads sibling values, routes through `encoding.read` / `encoding.write`,
   and honors `option.disabled`. `SelectionPanel` already did all of this — it was
   only the forked copy that could not express it.
-
 - 3386d64: Dragging out a text box shows a live preview
-
+  
   The set of insertable kinds and the `KitInsertShape` union sat on adjacent
   lines with no linkage, and seven more sites restated one list or the other. The
   drift was already live: the text tool binds `actionId: 'insert'` and commits
   through the insert dep, but the runtime set never listed `text`, so a
   drag-to-insert text box had no preview.
-
+  
   `SHAPE_KINDS` is now one descriptor table — a row per kind, flagged for whether
   it has a built-in tool and whether it takes an insert preview. Both unions,
   `KIT_SHAPE_KINDS`, `BUNDLE_TOOLS.exhaustive`, the known-builtin-id list and the
   preview gate all derive from it.
-
+  
   Two type-surface consequences. `KIT_SHAPE_KINDS` is typed
   `readonly BuiltinShapeToolId[]` rather than a literal tuple — same contents,
   same order, and `(typeof KIT_SHAPE_KINDS)[number]` is unchanged; what goes is
   positional and length typing, which nothing uses. And `OngoingOverlay['shape']`
   gains `'text'`, which is the fix itself: a consumer switching exhaustively over
   it gains a case, handled by the existing box arm.
-
 - c6c499d: Text layout is computed once, and the caret reads the layout that was painted
-
+  
   The paint, the pose silhouette and the click-to-edit caret each ran their own
   walk. The paint went through a memoized `layoutRuns`; the silhouette re-ran
   `layoutRuns` on every pose change, because it allocates a fresh `ResolvedRun[]`
@@ -3840,7 +2964,7 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   caret could therefore answer with a different line, and a different glyph, than
   the one under the pointer — masked in practice only because it asked a WebGL
   canvas for a 2D context and got `null`, degrading silently to no caret at all.
-
+  
   `cachedLayoutRuns` now lives in `@weasel-js/text` beside the function it caches,
   and all three go through it. It keeps the array-identity `WeakMap` as the
   renderer's zero-cost path and falls through to a bounded LRU keyed on the runs'
@@ -3848,7 +2972,7 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   about 230× cheaper than laying out again, at roughly 4× the cost of the
   identity hit. `LaidOutLineBox` carries the caret stops the pen produced, so
   snapping is to the advance cells the glyphs were actually painted in.
-
+  
   **Breaking:** `caretIndexAt(ctx, x, y, pose)` is now
   `caretIndexAt(x, y, pose, opts?)` — the `CanvasRenderingContext2D` is gone, and
   an optional `maxWidth` mirrors `textLineBoxes` for nodes the `kit:text` painter
@@ -3856,9 +2980,8 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   double-click always seeds the caret instead of falling back to editing from
   offset 0. `@weasel-js/text` gains a `./test-seams` entry point exporting
   `_resetLayoutCacheForTests`.
-
 - 4f1ef0b: Lay text out from font bytes alone — no baked atlas.
-
+  
   `registerFontOutlines` was a paint upgrade for a family that already had an
   MSDF atlas; a family with only font bytes could not resolve, so it rendered
   nothing. It is now a tier in its own right: `OutlineFace` reports `ascender`,
@@ -3866,48 +2989,46 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   outline-only family, and `layoutRuns` reads advances, kerning and the baseline
   through one source the atlas and a parsed face both satisfy. `outlineMinSize`
   does not gate such a family — there is no other tier to prefer.
-
+  
   This does not touch metric neutrality where it applies: a family that has an
   atlas still resolves to the atlas, so registering outlines cannot move text
   that was already rendering.
-
+  
   Also fixes the outline tier in Node. opentype.js publishes ESM under `module`
   and UMD under `main`; Node takes the UMD build, whose named exports it cannot
   detect, so `parse` was undefined and every face failed to load — silently, via
   the fallback to SDF. A browser bundler reading `module` never saw it.
-
+  
   Breaking for a consumer-supplied `OutlineParser`: a face must now report
   metrics as well as geometry.
-
 - 0114abf: Add `PaintInput`, a control that edits a whole `FillStyle`.
-
+  
   A kind bar over a per-kind body, driven by the paint-kind registry rather than
   a fixed list, so a consumer's registered kind appears in the bar and renders
   that entry's `Editor`. `SelectionPanel`'s `paint` leaf renders it in place of
   the chip that showed a gradient as indeterminate and wrote a solid over it on
   first touch — so the checkerboard now means a mixed selection and nothing else,
   and a gradient stroke is editable rather than merely paintable.
-
+  
   Switching kinds keeps a per-kind memory for the control's lifetime, so
   linear -> solid -> linear comes back with its stops instead of the ramp
   `withGradientKind` cannot carry.
-
+  
   `PatternPicker` moves from WeaselDraw into `@weasel-js/ui`, which now depends
   on `@weasel-js/svg` for its tile previews.
-
+  
   The bar offers **None**: "what kind of paint is this?" takes no-paint as an
   answer. `setFill` and `setStroke` accept `paint: null` to write it — a fill
   becomes `null`, and a stroke goes away entirely rather than keeping a width
   that draws no ink. `PaintKindEntry` gains an optional `icon`, and the five
   built-in kinds carry glyphs so six segments fit a property row.
-
+  
   `FILL` and `STROKE` are now peer sections: the `appearance` group goes headless
   and `data.fill` becomes a block leaf. The stroke's paint is no longer paired
   with its width — a whole paint editor cannot share a row with a slider.
-
 - 50bc909: `FillStyle` is open: register a sixth paint kind and it renders, converts
   frames and serializes.
-
+  
   `registerPaintKind(entry)` returns a disposer and `_resetPaintKindsForTests`
   re-seeds the five built-ins, matching the kit's other module-global
   registries. An entry carries the editor's slots (`label`, `seed`, `colorOf`,
@@ -3915,7 +3036,7 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   `<defs>` slot. `listPaintKinds()` enumerates them, and `asPaint` types a
   consumer's own paint as a `FillStyle` — the union itself stays closed, because
   opening its discriminant would widen every built-in member.
-
+  
   Three defects fall out of the same change, each of which a sixth kind hit
   immediately. The renderer's fill dispatch fell off the end of its switch into
   an unguarded cast to the gradient union, so an unknown kind read `stops` off a
@@ -3923,25 +3044,24 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   an unknown kind untouched, leaving it painting in screen space on a node that
   moves. `<defs>` emitted nothing for a kind `gradientXml` did not know while
   still writing the `url(#id)` that referenced it.
-
+  
   Registering a kind now bumps the node memo generation, so a node painted
   before the registration repaints rather than holding the frame it resolved
   when the kind was unknown.
-
 - 6a06f6d: Node paint is an object: `data.fill` is a `FillStyle`, `data.stroke` a `Stroke`
-
+  
   Each concept now has exactly one shape. `data.fill` holds a `FillStyle`,
   `data.stroke` a whole `Stroke`, and `null` on either is an explicit "no paint"
   where `undefined` takes the painter's fallback. Two new authoring helpers keep
   hand-written node data short:
-
+  
   ```ts
   data: { path, fill: solid('#7fb069'), stroke: strokeOf('#1c1c1c', 2) }
   ```
-
+  
   **Breaking, with no compatibility path.** A document written against the old
   shapes renders wrong rather than failing, which is accepted:
-
+  
   - `NodeFill = string | FillStyle` and `NodeStroke = string | Stroke` are gone,
     and so are the string branches of `resolveNodeFill` / `resolveNodeStroke`.
     A node holding `fill: '#f00'` now paints the default grey.
@@ -3957,176 +3077,169 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   - `@weasel-js/svg`'s `strokeDataFromSvg` returns `Stroke | undefined` instead
     of a `{ stroke, strokeWidth }` pair, and stops flattening a plain solid
     stroke into a color. SVG's `fill="none"` imports as `fill: null`.
-
+  
   **A paint's alpha lives in `opacity`, one slot for every paint kind.** That is
   the only slot a gradient or a pattern has, so it is the slot all of them use,
   and the renderer multiplies a hex alpha by it — the two would fight if both
   carried the value. `solid()` therefore moves an alpha channel out of the hex:
   `solid('#ff000080')` is `{ color: '#ff0000', opacity: 0.502 }`.
-
+  
   The four setter actions follow: `setFillOpacity` / `setStrokeOpacity` write
   `opacity` rather than splicing hex, so they now work on a gradient fill, which
   they used to leave untouched. `setFill` / `setStroke` given a `color` recolor
   the node's existing paint through the new `paintWithColor`, keeping its opacity
   unless the picked color states an alpha of its own — and `setStroke` keeps the
   stroke's width, cap, join and dash instead of replacing the whole value.
-
+  
   New exports: `solid`, `strokeOf`, `paintAlpha`, `paintWithAlpha`,
   `paintWithColor`, `DEFAULT_SHAPE_FILL`.
-
+  
   `defaultNodeProperties` moves `data.fill` from a `color` leaf to a `paint` one
   — a color control pointed at a `FillStyle` reads `undefined` off a gradient and
   writes a bare string over it — and the `data.stroke` object leaf drops its
   `fromScalar`, which had nothing left to lift.
-
 - a37ee0b: Separate a text node's content from its typography, and draw depth only where a label marks it
-
+  
   The text schema put `data.text` in a group named Text, so the section read
   TEXT and the row inside it read Text — one word nested in itself — and the
   style groups below it read as fields of the content string rather than as its
   siblings. Content is its own section now, with the field full-width because
   the section already names it.
-
+  
   A group with an empty `name` renders no heading. That already worked for
   sections and is now documented on `ToolPrefGroup`, since it is how a schema
   says "this group organises, it doesn't name": `Character` and `Paragraph`
   carry the labels, and a `Typography` heading over them named nothing new.
   It stays opt-in rather than a rule that rolls up any all-group parent —
   a `Border` over `Top` / `Right` / `Bottom` needs its name.
-
+  
   Rows under a suppressed heading no longer indent. Depth drawn without a
   visible parent put `Character` a level deeper than `Content` while being its
   peer, which is the panel's own tree discipline broken by its own hand.
-
 - 611b30e: Layers and deps answer for the view they are drawn for
-
-  Nine lookups closed over the _surface's_ state at construction, so they answered
+  
+  Nine lookups closed over the *surface's* state at construction, so they answered
   for view zero in every view. `<CanvasView>` draws the surface's layer array
   unchanged and only the draw envelope differs, which makes a `draw: (_data, …)`
   a guarantee of answering for the wrong view rather than merely an unused
   argument. A drag in view B ghosted in view A, the marquee painted in the wrong
   view, chrome-caps resolved against the surface's selection, every Cmd+V centered
   on the wrong camera, and Escape in view B cancelled view A.
-
+  
   **New on `CanvasViewHelpers`** — `getPreviewSources()`, `getGestureOverlays()`
   and `getIsVisible()`. All three are **required members**: anyone hand-writing a
   `CanvasViewHelpers` (a test double, a wrapper) has to add them.
   `getIsVisible` **moves off `CanvasSurfaceHelpers`**, where it could only ever
   have answered for one view.
-
+  
   **New on `GestureSource`** — `previewSources()` and `overlays()`, also required,
   alongside the newly exported `GesturePreviewSource`. `toolPreviewSources(tools)`
   is the tool half.
-
+  
   **Layer options changed.** `createPathEditingOverlayLayer` and
   `createSlopsDebugLayer` take `getPose(id, previews)` and have lost their
   `isVisible` / `selectionRef` / `boundsOf` options — those come off the envelope
   now. `usePreviewGhostLayer` has lost `tools`. Both it and
   `useDispatcherOverlayLayer` keep `dispatcher` **only** to subscribe for repaint.
-
+  
   **Picking takes a camera.** `pickEvery`, `pickBest` and `makeGetNodeAtPoint`'s
   result accept an optional trailing `PickCamera`. A world point does not carry
   the scale it was produced under and picking has no draw envelope, so the caller
   that produced the point supplies it; omitting it keeps the surface camera.
-
+  
   `useHoverTracking` took a `clientToWorld` thunk beside a world-space
   `getNodeAtPoint` — the first resolved the view and the second did not, so hover
   picked at the surface's scale inside a panel. It takes one
   `nodeAtClientPoint(clientX, clientY)` now.
-
+  
   Anchor-editing target state stays surface-wide; only the preview resolution on
   that path is per-view.
-
 - 9ad8cb2: Picking answers for what was painted
-
+  
   Three defects in `<SceneCanvas>`'s hit paths, all one shape — a pick answering
   from something other than what the renderer drew.
-
+  
   **Pose overrides were painted through and picked around.** `PoseOverride.pose`
-  is documented as replacing the document pose _everywhere the render and
-  hit-test paths read one_, and `sceneAdapter.getPose` honored it. But
+  is documented as replacing the document pose *everywhere the render and
+  hit-test paths read one*, and `sceneAdapter.getPose` honored it. But
   `<SceneCanvas>` supplies its own `pickEvery`, which read `node.pose` raw — as
   did the bounds resolver feeding selection chrome and the affordance
   `ChromeState`, and the marquee/lasso scan. A consumer animating nodes through
   overrides painted them at one place and picked them at another. `effectivePose`
   is now the single rule and every one of those reads through it.
-
+  
   **A clipped-away child was still clickable.** A container clips its subtree and
   the renderer honors it, so a child outside the clip is not painted.
   `useSelectTool`'s own walk has rejected those since clipping shipped; the walk
   `<SceneCanvas>` installs instead had no clip term at all. The new
   `passesAncestorClips` walks the parent chain per surviving candidate, so a flat
   render-order scan can apply the same test.
-
+  
   **The marquee's fast-reject used the unrotated pose box.** A 100×20 rect turned
   45° puts a corner 32 units above that box; a rubber-band over that corner was
   rejected before the rotation-correct silhouette test ran, while a click on the
   same pixel selected the shape.
-
 - c1b8511: Repaint the scene-graph side-scroller demo's world from `data.fill`. Its
   tiles, coins, enemies and flagpole still declared `data.color`, the alias
   removed when node paint became an object, so every one of them rendered in
   the default gray — the demo whose whole point is being the visual twin of the
   immediate-mode load test.
 - d793d3c: Flip negates rotation; alignment guides and `gaps` distribute measure ink
-
+  
   Three paths read a pose's stored, unrotated box where the rotated extent was
   wanted.
-
+  
   `flipPoseAboutBounds` carried rotation through untouched, so a mirrored shape
   came back turned the same way — invisible on a rectangle, whose AABB is
   symmetric under a sign flip, and plainly wrong on an asymmetric one, which
   translated instead of mirroring. It now negates the pose's rotation.
-
+  
   `deriveAlignmentGuides` advertised a stationary rotated sibling's lines at its
   stored edges, while the dragged selection matched against them by its ink.
   `RECT_ALIGN_PROJECTION.boundsOf` now returns the rotated AABB and
   `deriveAlignmentGuides` reads its targets through the same projection — a new
   `projection` option defaulting to the rect one, so existing callers get the fix
   without a change.
-
+  
   `useDistribute`'s `gaps` mode divided the leftover span by stored widths, so a
   rotated member ended up with a gap short by the difference; `centers` shared the
   line and the blind spot. Both now measure with `visualBoundsViaDescriptor`.
   `distributeHorizontalAction` / `distributeVerticalAction` also take
   `params.mode`, so `gaps` is reachable from a binding rather than only from the
   hook.
-
+  
   Flip and distribute return different poses than before for rotated shapes.
   That is the fix, but it is a behavior change for anything depending on the
   old output.
-
 - 3386d64: `@weasel-js/core/routing` exports the route-string projection
-
+  
   Anything rendering a `GestureSpec` as a route string had to re-implement the
   projection, and the copy in WeaselDraw's registry inspector had drifted three
   ways: it answered `drop` and `paste` with no gesture name, so every binding of
   either vanished from the route list; its argument lookup missed a spec field;
   and it gated targets on a hand-listed set of kinds, dropping them for
   `pointerDown`, `longPress` and `wheel`.
-
+  
   New from the routing subpath: `routesForSpec(spec)` — every route string one
   spec declares — plus `routeGestureForSpecKind(kind)` over the single spec-kind
   map, and `PREDICATE_TARGET`, which `registry.ts` already exported but the
   subpath index did not, so consumers reading `RegistryEntry.target` had no way
   to compare against the sentinel its own docs name.
-
 - ce2b5c7: Make the inline run grammar a parameter instead of a hardcoded branch.
-
+  
   `runsToMarkdown` and `markdownToRuns` each had the markdown subset spelled out
   in their control flow — `***`/`**`/`*` and a two-character escape set — so
   reading or writing any other spelling meant forking both. They now take a
   `RunGrammar`: a table of markers pairing a repeated delimiter with the run
   flags it toggles, defaulting to `MARKDOWN_RUN_GRAMMAR`, which is exactly
   today's behavior. Escaping follows the grammar's own delimiters.
-
+  
   Nothing changes for a caller that passes no grammar. `underline` and
   `strikethrough` still have no markdown spelling and are still dropped by
   `runsToMarkdown` — a grammar that wants `~~struck~~` now adds one marker
   rather than editing the parser.
-
 - 2ea772f: `createSelectionOutlineLayer` and `createSelectionHandlesLayer` now do what the overlay layer does
-
+  
   `createSelectionOverlayLayer` documents itself as equivalent to stacking the
   other two, and it was not. It reads `ChromeState` off the draw envelope,
   resolves the synthetic multi-resize id to the union AABB, honors chrome-caps
@@ -4136,27 +3249,25 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   knew nothing about the multi-selection union — so a consumer who stacked them,
   on the wrapper's own promise, got chrome in the wrong place with no way to
   tell.
-
+  
   All three now run one body and differ only in which passes they enable, so the
   promise holds by construction. `SelectionOutlineLayerOpts` and
   `SelectionHandlesLayerOpts` become the overlay's option set minus the visuals
   that don't apply, which makes `getSelection` and `getPose` optional on both and
   adds `getOutlineIds` and `getSuppressedIds`. Handle visuals are now the named
   `SelectionHandleStyle`.
-
 - 3fb3a46: Key `usePublishSelection` on the publish callback, not the context value
-
+  
   The effect depended on the whole selection-context value, and the provider
   mints a new value object on every publish. So one publisher publishing refired
   the effect for every other publisher in scope, each of which republished its
   own ids — a newer selection got stomped back to an older one, and two
   publishers holding different ids under one provider never settled at all.
-
+  
   `publishSelection` is already a stable `useCallback`, so the effect now depends
   on it directly. No provider change and no API change.
-
 - 84db1f6: Close four gaps that produced wrong answers with no error
-
+  
   Three path walkers — `pathToMultiPolygon` in core and in `@weasel-js/geom`, and
   `enumerateAnchors` behind the bezier-edit overlay — handled M/L/C/Q/Z with no
   `default:` arm, so a command code they did not know fell out of the switch
@@ -4164,31 +3275,30 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   wrong floats. They now throw, matching the six sibling walkers. This is a
   behavior change for anyone feeding these a path built with an opcode outside
   `PATH_COMMANDS`: what used to come back subtly wrong now raises.
-
+  
   A `<CanvasView>` built its affordance hit-test without a device profile, so a
   nested view resolved fine-pointer radii even under a coarse pointer — 8px grab
   zones against the 14px chrome the surface paints. It reads the profile
   `<SceneCanvas>` publishes.
-
+  
   `moveGestureAdapter`'s `insertNode` took no `index`, and the adapter carried
   neither `getChildren` nor `setChildOrder`, so the sibling slot a delete op
   records had nowhere to land: undoing a delete through the move pipeline
   appended the node to the end of its parent instead of putting it back where it
   was. All three are there now.
-
+  
   The dev inspector's gesture panel formatted bindings with a private formatter
   that reported only modifiers set to `true`. The `ingest` action marks every
   modifier `'optional'`, so its drop and paste bindings rendered blank and the
   action was invisible on both gestures. Both of the panel's plain-text
   formatters now go through the kit's `routesForSpec`.
-
 - 3386d64: Undoing a multi-node delete or group restores document order
-
+  
   Restoring by stored index cannot survive replay: history runs a batch's
   inverses in reverse, while indices captured before the mutation are only
   correct in ascending order. Deleting `b, c, d` from `[a, b, c, d, e]` and
   undoing gave `a, b, e, c, d`; Cmd+G on the same three did the same.
-
+  
   Ops now record a `Slot` — an ordinal plus the id of the following sibling at
   capture. The anchor is the source of truth whenever it resolves, and it
   resolves whatever else the batch has already restored. The ordinal remains as
@@ -4196,23 +3306,22 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   children. `before: null` means "last" and needs no sibling list; an absent
   `before` means "unobserved", and the two survive `History.serialize` because
   `undefined` drops out of JSON and `null` does not.
-
+  
   The ops observe their own slot during `apply()` rather than taking one from the
   caller, so every existing emitter gets this without a call-site change.
   `createDeleteOp`'s `index` argument is now a seed that `apply` supersedes; its
   docstring said it was sufficient on its own, which it never was.
-
+  
   Adapters without an ordering seam still append, as they did before:
   `arrayAdapter` has no `setChildOrder`, and the move gesture's adapter has
   neither that nor an `index` parameter on `insertNode`.
-
 - 7a746df: A stroke's dash is edited as a style, not as an array
-
+  
   `Stroke.dash` already rendered, imported and exported; it had no control,
   because a `number[]` has no leaf kind. It doesn't need one — the thing a person
   chooses is a style, and the array is how it is stored. The stroke block gains a
   Solid / Dashed / Dotted / Custom bar under cap, join and align.
-
+  
   `ToolPrefEnum` gains `encoding`: `read`/`write` between the stored value and
   the option string, the counterpart of the `unit` a number leaf already has for
   a value stored in a canonical unit. Both directions are handed the object the
@@ -4224,9 +3333,8 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   a new `disabled` option — one a control reports but refuses to author, since
   there is no array behind it. `solid` is stored as no dash at all, and an object
   leaf's field written as `undefined` is now removed rather than left holding it.
-
 - 4f19274: Cap, join and align are chosen by glyph, and the stroke block drops its labels
-
+  
   Nine option glyphs and four category glyphs join the icon set. The option
   glyphs are filled silhouettes — the glyph is the ink, so a choice reads as a
   shape rather than as a diagram of one. `align` is a circle zoomed until the
@@ -4234,31 +3342,29 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   the box's complement of it, and `center` is the annulus straddling the path,
   so the three are one band at three offsets. The categories are the bare path
   each row treats, drawn in the outlined register.
-
-  A schema carries a glyph _id_, not a component: `ToolPrefEnum`'s options gain
+  
+  A schema carries a glyph *id*, not a component: `ToolPrefEnum`'s options gain
   `icon`, and every leaf gains one for rows whose own label is spent on a
   `pair`. Core ships no icon set and cannot depend on one, so the field is a
   plain string; weasel-ui resolves it against `ICON_PATHS` and falls back to
   `short` where it names no glyph.
-
+  
   `SelectionPanel` now honours `block` inside an object leaf, not only at the
   section level. A row whose fields are all `block` drops the 64px label column
   and spans the block. The default stroke schema uses both: paint and width
   share one label-less row, and cap/join/align share the next.
-
+  
   `align`'s options run inner, center, outer — the order the ink moves outward.
-
 - 94f2446: Add stroke markers — arrowheads and other line terminators as stroke style.
-
+  
   `markerStart` / `markerMid` / `markerEnd` on `Stroke` take a key resolved
   through a new registry (`registerMarker`), shipping eight built-in shapes.
   Unlike SVG, the stroke stops short of a filled head rather than running under
   it to the tip; the distance is declared per marker, so an open V still reaches
   the vertex. Round-trips through `@weasel-js/svg` as `marker-*` attributes plus
   `<marker>` defs.
-
 - 07fd2de: `setStroke` takes a whole paint, so a gradient or pattern stroke is writable.
-
+  
   It accepted `{ color }` only, and merged through `paintWithColor`, which
   supersedes a non-solid paint with a solid one — a gradient stroke was
   unreachable even though `setStrokeOpacity` could already reach its alpha.
@@ -4266,42 +3372,40 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   an earlier paint, and the stroke's width, cap, join, dash and align survive
   either. New `strokeWith(paint, width?)` is `strokeOf`'s sibling for a paint
   that has no color to pass.
-
+  
   Two fixes alongside it: `setFill` started with no `color` and no `paint` seeded
   from `DEFAULT_STROKE_COLOR`, painting the selection black where
   `setFillOpacity` seeds the same slot from `DEFAULT_FILL_COLOR`; and
   `gradientForBounds`'s doc comment claimed a corner-to-corner linear gradient
   where the body builds a left-edge-to-right-edge one.
-
+  
   `@weasel-js/ui` no longer exports `strokeWithColor`. It shared a name with
   core's and disagreed with it — core's keeps the paint's opacity, ui's dropped
   it — and nothing imported it.
-
 - 81213fc: Edit a node's stroke as the union it is
-
+  
   `data.stroke` holds `string | Stroke`, and the schema described it with a
   `color` leaf — which reads `undefined` off the object form, shows its own
   default, and writes a bare hex back over the stroke's width, cap, join and
   dash on the first edit. The same trap `ToolPrefPaint` was introduced to avoid
   for `FillStyle`.
-
+  
   A `stroke` pref kind now describes it, and `defaultNodeProperties` uses it.
   Its control shows whichever color the value has — the string itself, or a
   solid paint's color — gives a gradient stroke the indeterminate chip rather
   than claiming a color it doesn't have, and preserves the form on write.
-
+  
   `PrefsForm` gained the `stroke` case and the `paint` case it never had; a
   `paint` leaf used to render as the literal text `(paint: no renderer)`.
   `solidColorOf`, `strokeColorOf`, `strokeWithColor` and `isStrokeObject` are
   exported from `@weasel-js/ui` for consumers writing their own property
   renderers against either union.
-
+  
   Cap, join and dash are not editable from a panel yet, and `data.strokeWidth`
   remains its own leaf — see `docs/proposals/2026-08-26-node-stroke-union.md`
   for why that waits on the SVG mapping.
-
 - 2f225d7: A thick stroke is clickable across its whole width
-
+  
   `shapeCoversPoint` grants a grab out to a stroke's outward reach — a full
   stroke width for an `outer` align — but the AABB pre-filter that runs before it
   grew only by the pointer slop. So half a thick outer stroke's ink was
@@ -4310,25 +3414,24 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   was at least as generous as the refinement, which it cannot be on its own,
   since it never sees the stroke. That budget is the caller's, and the comment
   says so now.
-
+  
   `ShapeCoversPointOptions.scale` was never passed either, so a stroke width
   declared in `px` resolved as world units and the reach was wrong at every zoom
   but 1 — while the caller computed `meanScale(view.scale)` one line above.
-
 - 68069dc: Right-to-left text lays out in visual order
-
+  
   `LayoutRunsOpts` takes an optional `bidi` engine. Given one, `layoutRuns`
   analyses the paragraph, reorders each line after the wrap, and mirrors brackets
   in right-to-left runs. Given none, nothing changes: text lays out logically,
   exactly as before.
-
+  
   `@weasel-js/text` declares the `BidiResolver` interface and does not depend on
   `@weasel-js/bidi` — the dependency runs the other way from the usual, so a
   consumer who renders no right-to-left text never installs the Unicode tables,
   and a different implementation can be substituted. `@weasel-js/bidi` is a
   devDependency here only, for a test that drives real Hebrew through the real
   engine; types lining up is not evidence the semantics do.
-
+  
   `LaidOutCell` gains `advance` and `level`, and **`x` is no longer monotonic
   across `cells`**. Cells stay in logical order — slot `i` is still character `i`
   — while their x values follow the reordering. Sort on `x` for visual order, and
@@ -4336,26 +3439,25 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   cell's `x`. Hit-testing was doing exactly that and now sweeps in visual order
   against each cell's own extent, taking a right-to-left cell's visually-leading
   half as the character's logical end.
-
+  
   Kerning is a gap between two adjacent characters, and the wrap measures it
   logically. Reordering can put a different pair side by side, so the gap taken
   is the one belonging to whichever of the two is logically second, and none at
   all across a direction boundary — where the pair never touched in the source.
-
+  
   Laying out right-to-left text with no engine now warns once, naming the import.
   The alternative is glyphs silently appearing reversed, which is the one real
   hazard of making this opt-in.
-
 - 5d0ff9c: Every code point on a line gets a cell
-
+  
   `LaidOutLineBox` replaces its `caretXs` / `caretIndices` pair with
   `cells: LaidOutCell[]` plus a `srcEnd` closing offset. A cell carries
   `srcIndex`, `srcEnd`, `cp`, `x` and `drawsInk`, so slot `i` is `cells[i]` and
   a consumer indexing per character no longer has to reconcile a sparse array
   against the source string.
-
+  
   The old arrays were documented as non-contiguous, and two causes were real:
-
+  
   - A code point no tier could serve was dropped outright, taking its caret stop
     with it. It now occupies a zero-advance cell. This is reachable whenever the
     dynamic canvas fallback is off — which is the normal configuration for a
@@ -4364,34 +3466,33 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   - A space opening a line — at the start of the text, or after a newline — was
     discarded. It now keeps its cell and still consumes no width, so a line is
     addressable per character without gaining an indent. A space that opens a
-    _wrapped_ line was never affected: the wrap leaves it as a trailing cell on
+    *wrapped* line was never affected: the wrap leaves it as a trailing cell on
     the line before.
-
+  
   Neither changes any geometry: both cells carry zero advance, zero tracking and
   no kerning, so bounds, line widths and glyph positions are unchanged.
-
+  
   A newline still has no cell, since it separates cells rather than being one.
   `srcEnd` is what a blank line carries in its place.
-
+  
   `drawsInk` is a property of the code point and the face, not of the call that
   produced it: it does not flip when a dynamic bake lands or the outline
   threshold is crossed, so the same text reports the same slots every time. A
   zero-advance combining mark is `true` — it inks without advancing.
-
 - c1b8511: **Breaking:** paint leaves `TextStyle`. A text node's color and outline are
   `data.fill` and `data.stroke` — the same two leaves every other node kind
   paints from — and `TextStyle` holds typography only. `TextStyle.fill` and
   `TextStyle.stroke` are gone, with no compatibility read: a document that put
   its color in `style.fill` now renders in the default black rather than
   erroring, so check documents that predate this.
-
+  
   This fixes a real asymmetry rather than only moving fields. `data.stroke`
   already reached text through a fold in the painter, but `data.fill` did not:
   picking a fill color with a text node selected wrote a field nothing read, so
   the canvas did not change. `setFill`, `setFillOpacity`, the opacity scrub and
   the Appearance leaf now all mean the same thing on text as on a rect. The
   duplicate `data.style.fill` control is gone from the text schema with them.
-
+  
   `resolveTextStyle(style, paint)` takes the node's paint as a second argument
   and is what derives the caret and selection colors, so the edit overlay
   matches the glyphs it sits on; `useTextEdit` gained a `getPaint` option for
@@ -4402,105 +3503,100 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   style. `StyledRun.fill` and `.stroke` are unchanged and still override the
   node's per range — which is also where a caller with no node at all, a HUD
   widget or a debug overlay, now states its color.
-
+  
   `textCommandFromRuns` is exported from the package root.
-
 - 546f67d: Draw text from a ring of reused vertex buffers instead of minting a vertex
   array and two buffers per draw. `drawTextGroup` and `drawTextDecorations` were
   the last paths still doing what `drawImage` stopped doing; text now costs
   **3.3 us/command, down from 6.65** at 512 commands a frame on an M2 Max via
   ANGLE (`tests/perf/transition-matrix.spec.ts`), which puts it level with an
   image draw. No other command kind moved.
-
+  
   A text group is as many quads as it has glyphs, so unlike the image ring a
   slot's buffer grows to the largest run it has seen rather than being fixed at
   four vertices. The quad index pattern is a pure function of the quad count —
   the pattern for N quads is a prefix of the pattern for any larger N — so one
   index buffer serves every slot, grown the same way and written only when it
   grows.
-
 - c2ffa49: Alignment can resolve against reading direction
-
+  
   `align` gains `start` and `end` alongside `left` / `center` / `right`, and
   `TextStyle` gains `direction: 'ltr' | 'rtl'`. The split is CSS `text-align`'s:
   the relative pair resolves against the direction, the absolute pair ignores it.
   `resolveAlign(align, direction)` collapses one to the other and is exported for
   consumers that need an edge rather than an intent.
-
+  
   Direction is an input, not something this package discovers. `@weasel-js/text`
   has no DOM, so a consumer that reads `getComputedStyle(box).direction` passes
   what it found; nothing here sniffs an environment.
-
+  
   Defaults are unchanged — `align: 'left'`, `direction: 'ltr'` — so no existing
   layout moves. Making `start` the default alignment is a separate call.
-
+  
   `@weasel-js/svg` carries the direction through: `direction` joins the
   inheritable presentation properties, and `text-anchor` is now written and read
   against it. Two things were wrong before and are worth naming, because both
   rendered plausible output:
-
+  
   - `align: 'start'` serialized to `text-anchor="end"` — the opposite edge — via
     a mapping that assumed three values and read the fourth as its `else`.
   - SVG's initial `text-anchor` is `start`, which under `direction="rtl"` is the
     right edge, while this model's default `align` is `left`. They agree under
     `ltr` and only there, so an RTL document with no explicit anchor imported as
     left-aligned.
-
+  
   This is alignment and round-tripping only. Layout still walks code points in
   logical order with the pen always increasing: there is no bidi reordering and
   no shaping, so a Hebrew or Arabic string aligns to the correct edge and still
   renders in logical order, and Arabic still renders unjoined.
-
 - 4c097ef: Sit every run on a line on one baseline
-
-  Mixed-size text hung each run off the _line top_ at its own ascent instead of
+  
+  Mixed-size text hung each run off the *line top* at its own ascent instead of
   off a shared baseline, so a 16-unit run beside a 40-unit run floated up level
   with the big run's cap rather than standing on the line with it. Two faces with
   different ascents at the same size diverged the same way. Baseline alignment is
   what inline text does everywhere else, and the module header already claimed
   this behavior — the walk just never implemented it.
-
+  
   A line now sinks one baseline far enough to clear its tallest run's ascent and
   places every glyph against it. Glyph quads derive their top from that baseline
   rather than from the pen's line top, which is the whole of the change:
   `qy0 = baselineY + (yoffset - metrics.base) * scale`.
-
+  
   Uniform-size text — nearly all text — is unchanged, since the maximum over one
   value is that value. Only lines that actually mix sizes or faces move, and they
   move to where they always should have been.
-
+  
   The test named "mixed-size runs share a baseline on the same line" asserted only
   a quad count and passed throughout; it now asserts the baselines.
-
 - 2b86e00: A text node's style is one value, not ten sibling paths
-
+  
   `data.style.fontSize`, `.fontWeight`, `.align` and the rest addressed into one
   `TextStyle` from ten independent leaves, each control writing a field of a
   value it could only half see. `data.style` is an object leaf now, with
   Character and Paragraph as groups inside it — groups head their fields and
   contribute nothing to the path, so a field is still a field of the style and
   one commit writes the whole thing.
-
+  
   An object leaf whose fields are entirely grouped no longer prints its own
   heading, which would stack straight onto the first group's, and a group's
   fields sit under a rule so the nesting reads. WeaselDraw's inspector descends
   into an object leaf when listing what a kind exposes — the fields are the
   editable surface; the leaf is the container.
-
+  
   `SelectionPanel` has a story now, which is how the two layout defects above
   were found.
-
 - d933a89: Superscript, subscript and overline for styled runs
-
+  
   `StyledRun` gains `script: 'super' | 'sub'` — a raised or lowered baseline and
   a smaller size together, the pair `<sup>` and `<sub>` imply. It is a preset
   over two new primitives rather than a mechanism of its own:
-
+  
   - `baselineShift` — raise (positive) or lower (negative) a run off the line's
     shared baseline, in ems of the inherited font size.
   - `fontScale` — a multiplier on the inherited font size, the relative
     counterpart to `fontSize`. An absolute `fontSize` still wins over it.
-
+  
   Naming either directly overrides that half of `script` and leaves the other
   alone. The preset's numbers are exported as `SCRIPT_METRICS` (58.3% size,
   ±33.3% position — Adobe's defaults, so a character panel can show percentages
@@ -4508,28 +3604,27 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   carries real `ySuperscript*` metrics but the baked atlas tier has no slot for
   them, and metrics that applied on one glyph tier and not the other would
   reflow text as it crossed the size threshold.
-
+  
   `resolveRuns` folds all of it into one world-unit `baselineShift` and a final
   `fontSize`, so layout never learns superscripts exist — it places a run against
   a baseline and an offset. The shift moves a run's glyphs, its outline geometry
   and its own decoration rules together, and deliberately does not feed back into
   the line's baseline or height: a superscript rides the line rather than
   reflowing it.
-
+  
   `overline` joins `underline` and `strikethrough` on both `TextStyle` and
   `StyledRun`, additive over the node style like the other two, and is now
   available to a custom `RunGrammar` as a `RunFlag`. The default markdown grammar
   is unchanged — it stays silent on the decorations, as it always has been.
-
 - 5923c8b: `Animator.tween` no longer fires `onDone` for a tween that was cancelled during
   its own final `onTick`. The last tick emitted the value and completed in one
   pass, so a write made from that tick — cancelling the tween — still got the
   completion callback, against the documented "not called on cancel" contract.
 - 2ea772f: Undo of a delete restores the subtree; undo of a group restores the slot
-
+  
   Two ops inverted to something narrower than what they applied, so undo
   silently lost data.
-
+  
   `createDeleteOp.invert()` re-inserted a single node while `apply()` called
   `removeNode`, which cascades the whole subtree. Delete a container with two
   children, undo, and the container came back with `children: []` while both
@@ -4539,7 +3634,7 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   re-inserts each descendant at its captured slot. A flat adapter's `removeNode`
   does not cascade, so the inverse skips any descendant the adapter still reports
   as live rather than duplicating it.
-
+  
   `createReparentOp` carried only the parent ids, so undoing a Cmd+G appended
   instead of restoring the sibling slot and paint order changed. `ReparentArgs`
   now carries `fromIndex` / `toIndex` and places through the existing
@@ -4547,39 +3642,42 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
   `setParent`'s signature is unchanged. Adapters without that seam no-op as
   before. `groupAction` captures each member's index before mutating; `move` and
   `snapToContainer` pass none and are byte-identical.
-
+  
   `ops/delete.test.ts` stubbed `removeNode` as a one-id delete that did not
   cascade, which is why nothing caught the first bug. It now runs against a
   tree-backed fake.
-
 - 2ea772f: Selection chrome, gesture bounds and SVG export fold rotated ink, not pose boxes
-
-  Every union a user looks at or clicks folded each member's _unrotated_ box.
+  
+  Every union a user looks at or clicks folded each member's *unrotated* box.
   Select two shapes, rotate one, and the multi-selection frame and its handles
   sat inside the rotated shape's ink — affordances hand `ChromeState.unionBounds`
-  out as the target bounds for paint _and_ hit-test, so the handles were both
+  out as the target bounds for paint *and* hit-test, so the handles were both
   drawn and grabbable in the wrong place, while `getGestureBounds()` reported the
   correct larger box.
-
+  
   `unionAABB` expands each rotated member via `axisAlignedBounds` before folding
   and is now the one implementation. It lives in `core/geometry/unionBounds.ts`
   beside the rotation-free `unionBounds`, which stays correct for commit-time
   actions that write poses back in the unrotated frame; the module says which to
   reach for. `unionGestureBounds` is **removed** — it was `unionAABB` under
   another name. Both new functions are exported from the package root.
-
+  
   Moved onto it: `ChromeState.unionBounds`, the selection overlay's
   container-to-leaves resolver, the multi-rotate pivot (which put the pivot in
   the wrong place whenever a member was rotated), and WeaselDraw's export
   viewBox, which clipped rotated shapes out of the copied SVG.
-
 - 3fb3a46: Warn in dev when `useAction` finds no `ActionsProvider`
-
+  
   `useAction` returned early on a null registry, so an action registered above
   the provider — or with no provider mounted — silently never fired its
   bindings. It now warns in dev, naming the action id. Runtime behavior in
   production builds is unchanged.
-
+- Updated dependencies [5c8e9e6]
+- Updated dependencies [2621cbf]
+- Updated dependencies [0f936da]
+- Updated dependencies [4180095]
+- Updated dependencies [9977908]
+- Updated dependencies [52c7b2a]
 - Updated dependencies [3386d64]
 - Updated dependencies [c6c499d]
 - Updated dependencies [20097e6]
@@ -4591,13 +3689,13 @@ strokeWidth }`: `align: 'inner'` puts no ink outside the silhouette and
 - Updated dependencies [c2ffa49]
 - Updated dependencies [4c097ef]
 - Updated dependencies [d933a89]
-  - @weasel-js/geom@2.0.0-pre.0
-  - @weasel-js/text@2.0.0-pre.0
-  - @weasel-js/gestures@2.0.0-pre.0
-  - @weasel-js/history@2.0.0-pre.0
-  - @weasel-js/modes@2.0.0-pre.0
-  - @weasel-js/paint@2.0.0-pre.0
-  - @weasel-js/font@2.0.0-pre.0
+  - @weasel-js/text@1.3.0
+  - @weasel-js/geom@1.3.0
+  - @weasel-js/font@1.3.0
+  - @weasel-js/gestures@1.3.0
+  - @weasel-js/history@1.3.0
+  - @weasel-js/modes@1.3.0
+  - @weasel-js/paint@1.3.0
 
 ## 1.2.0