@weasel-js/core 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,609 @@
 # Changelog
 
+## 1.0.2
+
+### Patch Changes
+
+- 28710f2: The renderer's solid batch is drained at the sites that decide routing or
+  change stencil state, instead of at each emitter that happened to remember.
+  Geometry that cannot join a run now goes through `tryStageSolid`, which returns
+  `false` only after flushing — so the only way an emitter earns permission to
+  draw for itself is to have called the function that drained the batch. `pushClip`
+  and `popClip` flush as their first statement, since rasterizing into the stencil
+  is what creates the obligation.
+
+  Nothing about the drawn result changes; this removes a way for a future draw
+  path to paint under geometry staged before it.
+
+- 2e3fea2: The `routing` namespace is gone from the main barrel, and the reflection
+  surface exports only what a consumer can use.
+
+  `export * as routing` made tool authoring reachable two ways — `core.routing.defineTool`
+  and the `@weasel-js/core/routing` subpath — and no consumer ever used the first.
+  It survived as the unfinished half of the 2026-05-12 declarative-routing work,
+  whose Phase 6 was to move `defineTool` out of `routing/` entirely. **Removing
+  it is a breaking change for anyone importing the namespace form**; the subpath
+  is unchanged and is what every known consumer already uses.
+
+  `tools/routing/reflection` now exports `buildRouteRegistry`, `findConflicts`,
+  `RegistryEntry` and `Conflict` — the four an external inspector needs.
+  `PREDICATE_TARGET`, `findScopedConflicts`, `formatConflict`,
+  `reportRouteConflicts` and `ToolScopes` are still there and still used; they
+  are just no longer public, since their only caller is inside the kit.
+
+- 75ba7b1: Three fixes found by re-checking backlog entries against the code.
+
+  SVG gradients survive a round trip. The parser now reads `gradientUnits`
+  (`objectBoundingBox` → `units: 'bounds'`, `userSpaceOnUse` → `'world'`) and the
+  serializer writes back whichever the paint declares, instead of hardcoding
+  `userSpaceOnUse` on the way out — which had been reading a box-relative
+  gradient's `0..1` geometry as page coordinates, i.e. a gradient the size of a
+  pixel.
+
+  `unpackSvgFiles` keeps gradient fills instead of flattening them to a solid.
+  The reason recorded for the flattening — that the `kit:path` painter has no
+  gradient slot — had not been true for some time; `NodeFill` is
+  `string | FillStyle`, now exported. A `userSpaceOnUse` gradient is normalized
+  against the leaf's own box on the way in, so it survives the fit-clamp and
+  drop-point placement that move the geometry out from under it. Gradient
+  _strokes_ still flatten: `data.stroke` genuinely is a color string.
+
+  `extractUniformNames` skips precision and interpolation qualifiers. `uniform
+highp float u_t;` — the common spelling in hand-written GLSL — matched nothing
+  at all, so the uniform got no location and every write to it was dropped in
+  silence. Comma-separated declarator lists (`uniform float a, b;`) read too.
+
+  Also adds `tests/visual/text-decoration.spec.ts`, a baseline-free assertion
+  that underline and strikethrough sit `0.40 em` apart and span only their own
+  runs. It measures the gap between two gap-free horizontal ink runs, which is
+  something `text.spec.ts`'s 5% diff tolerance cannot see move.
+
+- e4a6ec4: Tool authoring moved out of `routing/` and onto the main barrel. `defineTool`,
+  `defineViewportTool`, `ToolDef`, `ViewportToolDef` and `ToolKeybinding` now come
+  from `@weasel-js/core`:
+
+  ```ts
+  import { defineTool, type ToolDef } from "@weasel-js/core";
+  ```
+
+  **This is a breaking change for anyone importing them from
+  `@weasel-js/core/routing`.** That subpath keeps the route grammar (`parseRoute`,
+  `formatRoute`, `describeRoute`, the gesture descriptors) and the reflection
+  consumers (`buildRouteRegistry`, `findConflicts`) — it is now only the surface
+  that _reads_ routes back, matching its name.
+
+  Finishes Phase 6 of the 2026-05-12 declarative-routing work. Source layout
+  follows: the factory and its `ToolDef` types sit at the top of `src/tools/`
+  alongside `useTools` and `useKeybindings`, with `routing/types.ts` renamed
+  `routeTypes.ts` to clear the existing `tools/types.ts`. Behavior and runtime
+  contract are unchanged.
+
+- d2a9049: Six backlog entries, all in the input and hit-test layers.
+
+  Tool overlays can say where they sit. `Contribution.overlay` takes a
+  `RenderLayer` or an array of them, and a new `overlayPosition` (`'top'` — the
+  default — / `'before-selection'` / `'after-selection'`) anchors them against
+  the selection chrome instead of always landing on top; with no selection layer
+  in the stack the anchored positions fall back to the tail.
+  `getActiveOverlays(position?)` partitions, and `placeToolOverlays` in
+  `canvas/layerOrder.ts` does the splice, so the ordering is testable without a
+  GL context.
+
+  `drop` and `paste` are route-grammar gesture names. They shipped without them,
+  so the inspector reported `undefined` for every ingestion binding. Both are
+  targetless and carry the spec's MIME-glob filter as their arg — `drop(image/*)`.
+
+  An unhandled paste stays the page's. `onPaste` now dispatches first and calls
+  `preventDefault` only on `'handled'`, the shape `onWheel` already used.
+  Clipboard items materialize synchronously, so unlike `onDrop` the result is
+  known while the default can still be suppressed.
+
+  Marquee and lasso see the shape a node actually draws. `hitTestArea` asked the
+  _pose_ for a silhouette, which meant the kit's own inserted shapes — geometry
+  on `node.data.path` behind a plain `{x,y,w,h}` pose — took the AABB path and
+  kept every false positive the silhouette test exists to drop. It now asks
+  `findShapeSilhouette` for the drawn world-frame boundary. Paying for that is a
+  containment short-circuit: a node the rect marquee swallows whole is a hit no
+  silhouette can overturn, so neither the kernel nor the painter runs. Net
+  against the committed bench baseline, polygon-pose scenes gain (1.25x at 1000
+  nodes / 100% area) and plain-rect scenes lose ~8% on the two rows that scan
+  everything. The short-circuit is marquee-only, behind `hitTestAreaPolygon`'s
+  `areaIsRect` flag, because a node inside a lasso hull's bounding box can still
+  miss the hull.
+
+  Layout siblings reflowing mid-drag render opaque. `OngoingHandle.previewOpaqueIds()`
+  names the subset of `previewIds()` that skips the ghost alpha; `moveAction`
+  fills it from the destination and source reflow ids. A ghost means "in flight
+  under the pointer", which a sibling settling into its destination slot is not.
+
+  `LayoutStrategy.acceptsDrop(container, dragged)` rejects a drag before any
+  drop-target work, so a type-aware container falls through to whatever sits
+  under it rather than swallowing everything in its bounds.
+
+  `flipAction` reads `params.pivot`. `'each'` (the default, unchanged) mirrors
+  every pose about its own AABB; `'union'` mirrors about the selection envelope
+  so items swap sides, and the `geometryProjection` data op follows the same
+  pivot.
+
+- 5f05431: `viewport.pinchZoom` now pans as well as zooms. It anchored `zoomAt` on the
+  current gesture centroid and never translated by the centroid delta, so two
+  fingers travelling together — spread unchanged, zoom factor 1 — moved the view
+  not at all.
+
+  Each frame now anchors the zoom on the previous centroid and then translates by
+  how far the centroid travelled. Together those pin the world point under the
+  gesture midpoint as the midpoint moves, which is what makes a pinch feel
+  attached to the fingers.
+
+  The action's id and label are unchanged (`viewport.pinchZoom` / `Pinch Zoom`).
+  Consumers who bound it get panning with no wiring change.
+
+- 5fea43d: Five unrelated small fixes.
+
+  A tapered stroke with `align: 'inner'` or `'outer'` on a polygon path painted
+  at half its requested widths. That alignment renders by tessellating at twice
+  the width and stencilling half away, and the doubling reached `stroke.width`
+  but not `vertexWidths`. The doubled array is memoized per source array, since
+  the ribbon cache compares it by reference.
+
+  An image insert previews the decoded bitmap inside the drag bounds instead of
+  committing on release with no preview at all. It falls back to the bare
+  outline until the image decodes, and `useImageTool({ preview: 'outline' })`
+  opts out of the bitmap entirely.
+
+  A HUD widget that claims the pointer reports a `'pointer'` cursor without
+  implementing anything — hovering one while a drawing tool was active used to
+  keep showing that tool's cursor. The rule is keyed on the `claims` every
+  widget already declares, so it covers consumer-authored widgets too;
+  decoration claims nothing and the hit walk descends past it. A widget's own
+  `cursorAt` still wins, and `button` takes a `cursor` option that feeds it.
+
+  `composeAffordanceLayer`'s `hitTest` returns a `LayerHit`, carrying the hit
+  region's declared cursor and claim instead of dropping them. `AffordanceRegion`
+  gains optional `strength` / `claimedKinds` to declare that claim.
+
+  `ToolPalette` uses the shared `useRovingTabIndex` rather than its own container
+  handler, so arrow keys skip tools that are ineligible in the current mode and
+  the tab stop no longer sits on one. `ToolButton` takes an `onKeyDown`.
+
+- 443d74e: Stroke ribbons are tessellated once per stroke configuration instead of once
+  per frame. The renderer rebuilt every stroked path's ribbon geometry on every
+  frame and discarded it; it now caches the result on `Path` identity, keyed by
+  the parameters that change the ribbon — width, cap, join, miter limit,
+  alignment, dash, and flatten tolerance. Paint and vertex colors are not in the
+  key, since both are applied over the same triangles at draw time.
+
+  A ribbon that survives a frame also stops paying for a fresh VAO and two
+  buffers on every subsequent frame. One whose path or stroke parameters change
+  each frame keeps the transient upload it had before, freed at end of frame —
+  so an animated or freshly drawn path never accumulates GL resources waiting on
+  garbage collection.
+
+  Nothing about the drawn result changes. The cache is keyed on object identity,
+  matching the fill cache: a `Path` rebuilt with equal coordinates is a distinct
+  entry and re-tessellates.
+
+- 7decec1: Four more backlog fixes.
+
+  `@weasel-js/svg` reads and writes `<image>`. A new `SvgImageNode` holds the
+  `href` verbatim — an external URL or a `data:` URI, with `xlink:href` accepted
+  on the way in — plus a box that inherited transforms collapse onto and an
+  element-local rotation. `unpackSvgFiles` maps it onto the `kit:image` painter's
+  `data.image.src`, so a dropped SVG carrying raster content now keeps it instead
+  of dropping the element on parse. `preserveAspectRatio` is not modeled: the box
+  is taken literally and written back as `none`, and a non-`none` source warns.
+
+  `pickTopMostHit` resolves sibling z-order. An adapter can supply `getZIndex(id)`
+  or `compareZ(a, b)`; both compose with the existing parent/child collapse rather
+  than replacing it, so a child still beats its own ancestor whatever z the two
+  report. Without either, the hit list's own order decides, as before.
+
+  `useSceneTextEdit` supplies `setStyle`. Clearing a style flag that the _node_
+  sets is the one edit the additive run algebra can't express, and `useTextEdit`
+  declines it without a writer — so every scene-wired consumer silently refused
+  that toggle. Override the projection with `setStyle(data, style)` for a
+  non-default data shape.
+
+  The slops debug overlay draws handle halos at the real hit radius. Affordance
+  regions moved to screen-pixel radii, but this layer still scaled its circles by
+  the view, so at 4x zoom it drew a 32px halo over an 8px target — the one thing
+  a hit-test overlay must not do. Anchor slops now read the anchor radius rather
+  than the handle radius.
+
+- 24daa08: Five unrelated backlog fixes.
+
+  The specificity tuple's `phase` dimension is graded rather than binary: an
+  atom scores 2 when both its channel and its lifecycle state are concrete, 1
+  when one axis is wildcarded, and 0 for `*:*`, which matches everything an
+  undeclared phase would have matched. An atom list takes the minimum, since
+  `matchPhase` is a union. No existing binding reorders — the four ambient
+  actions hold at 1, and the polygon and star tools' `phase: 'engaged'` wheel
+  bindings rise to 2, widening a gap they already won.
+
+  The loupe's pixel mode no longer drops the end of a fast drag: a readback
+  requested while `createImageBitmap` is in flight is remembered and re-run when
+  that one settles, instead of being discarded.
+
+  SVG unpack applies the fit-clamp to text on both axes. `fontSize` now scales
+  with the file, and a text node's box width is estimated from its longest line
+  instead of inheriting the parser's unbounded-width wrap sentinel — which,
+  folded into the union AABB, had been clamping any external SVG containing
+  text down to a speck. That sentinel is now the exported `UNBOUNDED_TEXT_WIDTH`
+  rather than a bare `99999`, so a consumer reading `SvgTextNode.width` can tell
+  a measurement from a placeholder.
+
+  The debug overlay takes per-feature line widths and dashes through
+  `DebugConfig.strokes`, alongside the colors `DebugConfig.theme` already
+  carried. Defaults are unchanged.
+
+  A `.dfont` face declines the outline tier by name. Datafork TrueType holds its
+  sfnt tables inside a Macintosh resource map, which is still not unpacked, but
+  it is now recognized before parsing and reported as itself rather than dying
+  on an unrecognized-signature message that never says which format it saw.
+
+- f79e4b2: Viewport layers can now answer where a screen point lands inside them.
+  `createViewportLayer` returns a `ViewportLayer`, adding:
+
+  ```ts
+  layer.reproject(outer, dims, screen); // → inner-world point, or null if outside
+  viewportsAt(layers, outer, dims, screen); // → topmost viewport containing it
+  ```
+
+  `bounds` is already a pure function of `(outer, dims)`, so re-projection
+  recomputes the exact rect the frame painted rather than a remembered one — no
+  stored state and nothing to go stale. Right and bottom edges are exclusive, so
+  adjacent viewports never both claim a pixel.
+
+  This deliberately does **not** touch the dispatcher, which the previous
+  docstring promised it would. Tools still target the outer view; a consumer that
+  wants a click inside a viewport to mean something calls `reproject` from its own
+  handler. Making tools work _inside_ a viewport raises questions this primitive
+  does not answer — which view a pinch zooms, what a drag leaving the rect does —
+  and is tracked as its own item.
+
+- Updated dependencies [d2a9049]
+- Updated dependencies [24daa08]
+  - @weasel-js/gestures@1.0.2
+  - @weasel-js/font@1.0.2
+  - @weasel-js/geom@1.0.2
+  - @weasel-js/history@1.0.2
+  - @weasel-js/modes@1.0.2
+
+## 1.0.1
+
+### Patch Changes
+
+- d6c2eff: Take the id→node lookup off the render and hit-test paths.
+
+  Six call sites walked `scene.renderOrder()` and immediately resolved each id
+  back through `scene.get` — a map lookup per node, per call, for nodes the
+  traversal had already held. They now read `scene.renderOrderNodes()` directly:
+  `sceneToAdapter.getNodes`, the move gesture adapter and the default commit
+  adapter, `useSceneSelectTool`'s `hitTestArea` and default `pickEvery`, and the
+  text-edit hit test. Adapter `getNodes` runs on the render path once a frame.
+
+  Building the node list is about twice as fast (`npm run bench`, `min`, Apple M2
+  Max / Node v26.1.0):
+
+  | nodes  | via `renderOrder` + `get` | via `renderOrderNodes` |
+  | ------ | ------------------------- | ---------------------- |
+  | 1,000  | 0.031 ms                  | 0.011 ms               |
+  | 10,000 | 0.40 ms                   | 0.19 ms                |
+
+  `tests/bench/scene-ops.bench.ts` gains that comparison, and the committed
+  baseline is re-recorded.
+
+- d62dc17: Bake the rect batch's transform and alpha into its vertices, so a rotated or
+  partly-transparent node no longer breaks a run.
+
+  `RectBatch.push` now maps the four corners through the model matrix itself and
+  the flush draws at `u_model` identity — ~12 flops against the ~66 us a draw call
+  costs. An affine maps a rect to a parallelogram, so the two-triangle index
+  pattern still covers it. Group alpha multiplies into the vertex alpha the same
+  way fill opacity already did. Neither is batch state any more.
+
+  Frame cost for rects each wrapped in their own transform group — what
+  `wrapNodeOutput` emits for a rotated node — M2 Max via ANGLE at 800x600
+  (`npm run test:perf`, new `rotated` variant):
+
+  | rects | before    | after   |
+  | ----- | --------- | ------- |
+  | 400   | 24.94 ms  | 0.08 ms |
+  | 1,600 | 102.78 ms | 0.42 ms |
+  | 3,200 | 216.90 ms | 0.52 ms |
+
+  The color matrix stays a uniform and stays a barrier. The shader applies it and
+  its clamp to the straight-alpha source _before_ multiplying by `u_alpha`, so a
+  pre-multiplied vertex alpha is the same number only under an identity matrix —
+  which is every scene that does not use one. Alpha therefore folds only there,
+  and rides `u_alpha` otherwise.
+
+- 2604ce2: Merge consecutive solid-fill rects into one draw call.
+
+  The draw loop cost a flat ~66 us per draw call at every scene size, so a frame
+  of 3,200 rects took 212 ms. Solid-fill rects now append into a growable vertex
+  buffer and go out as a single `drawElements` at flush. Fill color rides the
+  vertices — the batch draws through the existing `pathFillVColor` program with
+  `u_color` held at white, which is bit-identical to the flat program's math.
+
+  Frame cost for a **flat** command stream, M2 Max via ANGLE at 800x600
+  (`npm run test:perf`):
+
+  | rects | before    | after   |
+  | ----- | --------- | ------- |
+  | 400   | 25.62 ms  | 0.03 ms |
+  | 1,600 | 105.63 ms | 0.11 ms |
+  | 3,200 | 211.78 ms | 0.15 ms |
+
+  Painter's order is unchanged. A run absorbs only consecutive commands and
+  flushes before anything it cannot express: another fill kind, a stroke, a clip
+  push or pop, or a group changing the transform, alpha, or color matrix.
+
+  That last barrier means `SceneCanvas` does not benefit yet — it emits one
+  wrapper group per node, which breaks every run. Consumers building flat command
+  streams get the numbers above today. See
+  `docs/handoffs/2026-08-14-batched-dispatch.md` for the plan to reach the scene
+  path. Nothing else in the loop got faster either: a frame alternating solid and
+  gradient rects still costs ~34 us per command, now almost entirely the gradient
+  half.
+
+- 24ae9f4: Batch solid-fill meshes and stroke ribbons alongside rects, so a stroked shape
+  costs one draw instead of two plus a fresh VAO every frame.
+
+  `RectBatch` becomes `SolidBatch`, with a `pushMesh` alongside `pushRect` that
+  appends transformed vertices and rebases the mesh's indices onto the staged run.
+  Solid path fills and solid stroke ribbons both take it, and land in the same
+  draw as each other: GL rasterizes a draw's primitives in index order, so staging
+  the ribbon after its own fill is what keeps the stroke on top.
+
+  Frame cost at 3,200 commands, M2 Max via ANGLE at 800x600 (`npm run test:perf`,
+  new `meshes` and `stroked` variants):
+
+  | variant                       | before    | after   |
+  | ----------------------------- | --------- | ------- |
+  | solid-fill octagons           | 5.63 ms   | 0.65 ms |
+  | stroked rects (fill + ribbon) | 243.80 ms | 9.41 ms |
+
+  The stroke figure is the interesting one, and not for the reason the plan
+  assumed. A draw call is ~1.8 us when nothing is touched between draws; what
+  costs is issuing a draw against a buffer minted that same frame, which is
+  exactly what a per-frame stroke ribbon did. Of the 9.41 ms left, 7.9 ms is
+  stroke tessellation, which batching does not address.
+
+  Excluded from a run: stencil fills, inner/outer-aligned polygon strokes, and
+  anything carrying per-vertex colors, all as before — plus meshes past a vertex
+  cap, since batching re-copies a mesh every frame where the persistent mesh cache
+  would not. Rects pay ~0.1 ms per frame at 3,200 for the index buffer becoming a
+  per-flush upload rather than a static pattern.
+
+- c2ebfdf: Break rect batches on group state rather than on tree shape, so `SceneCanvas`
+  gets the batching.
+
+  A group was a batch barrier because it _might_ move a uniform. `buildSceneTree`
+  gives every node its own group with no transform, alpha, colorMatrix or clip, so
+  in the scene shape every run broke after one rect and the previous release's
+  batching reached nothing the app renders. A run now carries the state it was
+  staged under and breaks only when the live state differs by value — which a
+  no-op wrapper never does.
+
+  Scene-shaped frame cost, M2 Max via ANGLE at 800x600 (`npm run test:perf`, new
+  `scene` variant — one wrapper group per command):
+
+  | rects | before    | after   |
+  | ----- | --------- | ------- |
+  | 400   | 26.32 ms  | 0.03 ms |
+  | 1,600 | 105.18 ms | 0.11 ms |
+  | 3,200 | 208.72 ms | 0.36 ms |
+
+  Clips stay hard flush points in both directions: the stencil is GL state that a
+  staged run cannot reconstruct, so the flush happens before `pushClip` and before
+  `popClip` rather than at group boundaries. Text, images, shaders, strokes and
+  non-solid fills flush as before.
+
+- dce3306: Cache `renderOrder()` and `renderOrderNodes()` between structural edits.
+
+  Both walk the whole tree, and both run per frame and per hit-test query, on a
+  sequence that only changes when something structural moves. They now build once
+  and are served from a cache until it does. On a 10,000-node, four-layer scene a
+  repeat call drains in 0.0033 ms against a 0.33 ms rebuild (`npm run bench`,
+  `min`).
+
+  Invalidation hangs off the four writers that can reorder the scene — `attach`,
+  `detach`, `kit:setLayer`, `rebuildLayerIndex` — plus `loadState`. Pose and data
+  edits do **not** invalidate: they change no order and fire every frame during a
+  drag, which is exactly when the cache earns its keep.
+
+  Repeat calls now return the same array instance rather than a fresh one. It is
+  still a snapshot — a structural edit builds a new array, so a reference taken
+  earlier keeps the order it was taken with — but callers must not mutate what
+  they get back. Both return types have always been `readonly`.
+
+- 69395b0: Detached scene renders honor pose rotation and per-node alpha.
+
+  Rotation and the per-id alpha multiplier were applied by `buildSceneLayer`,
+  the main canvas's scene walk. Every other way of painting a scene —
+  `<SceneViewCanvas>`, `<MinimapCanvas>`, and `renderSceneToPixels` — goes
+  through `buildSceneViewCommands` instead, which applied neither. A rotated
+  node came out upright in a minimap, a thumbnail, or a print export, and a
+  scene dimmed on screen exported at full strength.
+
+  Both wraps now live in one helper that both scene walks call, so the detached
+  renders match the canvas. Rotation needs nothing from the caller — it comes
+  off the pose. Dimming does: `alphaFor` is a new optional prop on
+  `<SceneViewCanvas>` and `<MinimapCanvas>`, and a new argument to
+  `renderSceneToCanvas`, `renderSceneToPixels`, `planPixelRender`, and
+  `buildSceneViewCommands`. Pass the same function `<SceneCanvas>` gets.
+
+  If you supply a `drawOne` to one of these that rotates its own output, it will
+  now rotate twice — emit unrotated geometry and let the pose drive it, which is
+  what the main canvas has always required.
+
+- 3d93f2e: Detached scene renders now honor layer visibility and container clips.
+
+  `buildSceneViewCommands` walked `scene.renderOrder()` and painted every node it
+  found. That walk knew nothing about scene layers or parentage, so
+  `<SceneViewCanvas>`, `<MinimapCanvas>` and `renderSceneToPixels` all painted
+  nodes on hidden layers and let a container's children spill past the container.
+  The main canvas got both right, because `buildSceneLayer` goes through
+  `buildSceneTree`.
+
+  The detached path now goes through `buildSceneTree` too, which is the dedupe the
+  detached-minimap spec called for. One walk, so the two surfaces cannot disagree
+  again.
+
+  Output nesting follows `buildSceneTree`: the view group holds one group per
+  **visible** scene layer, each holding one group per node. Code that indexed the
+  view group's children as one-per-node — `commands[0].children[i]` — now finds a
+  layer group there and needs a further hop. `extraCommands` still come last,
+  beside the layer groups.
+
+  A hand-written `Scene` stand-in must now supply `layers`, `roots`, and
+  `children` on containers; scenes from `createScene` and `sceneFromJSON` already
+  do.
+
+- e367165: One enumeration of the `TargetSpec` forms. `@weasel-js/gestures` now exports
+  `parseTargetSpec`, which resolves a target spec to a discriminated
+  `TargetSpecForm` (`body` / `kind` / `affordance` / `predicate`), and the three
+  places that used to re-derive the string prefixes independently — `matchTarget`,
+  and `targetRank` / `targetConsultsAffordance` in core's dispatcher matcher —
+  switch on it exhaustively. Adding a form to `TargetSpec` is now a compile error
+  at every site that has to handle it.
+
+  For consumers: `matchTarget`'s `specTarget` parameter and core's
+  `targetConsultsAffordance` take `TargetSpec | undefined` instead of `unknown`,
+  so a target string that is no known form is a type error rather than a silent
+  no-match. The predicate form has a name, `TargetPredicate`, carrying the
+  `readsAffordance` flag the exclusive-claim filter reads. Runtime behavior is
+  unchanged.
+
+- 52e9c57: Walk the scene once in `renderOrder()` instead of once per layer.
+
+  The generator behind `renderOrder()` and `toJSON()` was layer-major in the
+  literal sense: it ran a full DFS of the tree for every layer and yielded only
+  the nodes belonging to that pass, so producing N ids cost L×N work. A single
+  DFS now buckets each node by its layer and concatenates the buckets, which is
+  O(N + L). The emitted sequence is unchanged — same layer-major order, same
+  DFS-preorder within each layer, same skip for dangling child ids — and a
+  differential test holds the new implementation to a transcription of the old
+  one across 200 generated scenes plus mutation, layer-edit and undo sequences.
+
+  Over 10k nodes the layer sweep goes from 0.37 ms / 1.03 ms / 3.54 ms / 12.93 ms
+  at 1 / 4 / 16 / 64 layers to 0.30 / 0.35 / 0.40 / 0.42. The flat single-layer
+  case improves too, 0.37 ms → 0.33 ms at 10k nodes and 2.1x at 100 nodes, since
+  one pass replaces the per-yield generator overhead.
+
+  `renderOrder()` now returns an array rather than a generator, so a caller that
+  stops early no longer avoids the rest of the walk. Every caller in the repo
+  drains it fully except four test helpers reading the first id from a handful of
+  nodes. Its declared type stays `Iterable<NodeId>`.
+
+- d68e734: Memoize the per-node AABB in the area hit-test, for silhouette poses.
+
+  `hitTestArea` — the marquee and lasso dep source — recomputed every node's
+  bounding box on every query. For a polygon pose that means walking the whole
+  command stream and allocating a rect, per node, before the fast-reject could
+  discard it. The box is now cached through `nodeMemo`, keyed on the node's
+  `pose` and `data` references, so a repeat query over an unedited scene reuses
+  it and an edit through any scene op invalidates it.
+
+  Measured on 24-gon scenes (`npm run bench`, `min` column, same machine
+  back-to-back): 10,000 nodes 11.85 ms → 1.16 ms per query, 1,000 nodes
+  1.14 ms → 0.15 ms. Query-rect size now moves the number (0.117 ms at 17 hits
+  against 0.141 ms at 1,000 hits on a 1,000-node scene, previously flat at
+  ~1.15 ms either way) because the silhouette kernel, not the bounds
+  computation, is what survives the reject.
+
+  Rect-pose scenes pay 5–17% for it: `aabbOfPose` returns a rect pose
+  unchanged, so there is nothing to cache, and deciding that per node costs
+  more than the call it skips. 10,000 rect nodes go 0.76 ms → 0.85 ms.
+
+- ca9673a: Stop re-sending unchanged uniforms on every draw command.
+
+  `u_proj` is constant for a whole frame and `u_colorMatrix` is the identity in
+  every scene that does not use a color matrix, yet both were uploaded for every
+  command — along with a fresh `Float32Array(16)` and a transpose per draw to
+  build the color matrix, and a fresh `screenToClip` matrix per draw to build the
+  projection. GL holds uniform state per program object, so all of that was
+  buying nothing.
+
+  `draw.ts` now remembers what it last sent each program and skips the upload
+  when the value has not changed. On a frame of 1,000 solid rects that takes
+  `uniformMatrix4fv` from 1,000 calls to 1 and `uniformMatrix3fv` from 2,000 to
+  2, and removes two per-draw allocations.
+
+  The cache hangs off the `DrawContext`, which is rebuilt per frame, so it cannot
+  outlive a frame or go stale against GL state changed between frames. It covers
+  only the four uniforms this module is the sole writer of — `u_color` and
+  `u_alpha` have several writers and are still sent every draw.
+
+  This does not measurably change frame time on an M2 Max: the draw loop is bound
+  by per-draw-call cost (~68 us per command), not by uniform uploads. It removes
+  the calls and the allocations; `docs/TODO.md` tracks what the remaining cost
+  actually is.
+
+- fa1ed05: Dragging a text node no longer re-lays it out.
+
+  `layoutRuns` baked the text's position into every quad, decoration rule and
+  line box, so `layoutCache` had to carry that position in its key. Panning and
+  zooming still hit the cache, but _moving_ a text node missed on every frame —
+  at 500 wrapped glyphs a move cost 0.130 ms against a 1.7e-4 ms hit, which is
+  the same 0.134 ms a full miss cost. Moving text paid as if there were no cache
+  at all.
+
+  Layout now emits geometry relative to the text's own top-left and `drawText`
+  translates while packing vertices, alongside the `verticalAlign` offset it
+  already applied there. Position is out of the cache key, so a move is a hit:
+  median 0.130 ms → 0.000125 ms, min 0.123 ms → 0.000041 ms. The cold path is
+  unchanged (min 0.123 ms → 0.110 ms for a full miss).
+
+  This is not a rendering change. Alignment, wrapping, tracking, kerning and
+  decoration placement read widths and pen deltas, never an absolute coordinate,
+  and nothing in the walk rounds or snaps — checked over 247,572 coordinates
+  spanning three alignments, four wrap widths, mixed sizes, positive and negative
+  tracking, and fractional positions. The only differences were float64 rounding
+  from folding the position into the accumulator early, none of them survived the
+  conversion to the float32 vertex buffers, and they favor the new code: at a
+  position of 1e6 the old path computed 28.800000000046566 where this one gives
+  28.8. The 37-test Playwright visual suite is unchanged.
+
+  `layoutRuns` and `cachedLayoutRuns` lose their `origin` parameter, and the
+  `LayoutRunsOrigin` type is gone. Neither is exported from the package. Callers
+  of the public `textLineBoxes` and `measureTextBounds` see no change.
+
+- 0a40c29: Add `scene.renderOrderNodes()`, and scan it in the area hit-test.
+
+  `renderOrder()` hands back ids, and almost every caller immediately resolves
+  each one back to a node — a map lookup per node, per query, for a node the
+  traversal had in hand and dropped. `renderOrderNodes()` is the same
+  layer-major sequence as the nodes themselves. It is a snapshot, freshly built
+  per call, exactly like `renderOrder()`.
+
+  `hitTestArea` (marquee and lasso) now scans it, and reads `pose.kind` inline
+  instead of through the `isPathLike` predicate. Together those recover the
+  5–17% the AABB memo cost rect scenes and take a good deal more besides
+  (`npm run bench`, `min` column, three alternating runs per build on one
+  machine; run-to-run scatter on these was under 3%):
+
+  | 10,000 nodes, 25% query rect | before  | after   |
+  | ---------------------------- | ------- | ------- |
+  | rect poses                   | 0.94 ms | 0.53 ms |
+  | 24-gon silhouettes           | 1.21 ms | 0.78 ms |
+
+  `renderOrder()` itself gets a separate walk for the single-layer case, which
+  needs no per-layer buckets and can compare the layer id rather than index it:
+  10,000 nodes over one layer 0.27 ms → 0.19 ms, with multi-layer scenes
+  unchanged. `toJSON()` rides the nodes walk and skips its lookups too.
+
+  `Scene` gains a method, so a hand-written stand-in for a scene needs to
+  implement it; scenes from `createScene` and `sceneFromJSON` already do.
+
+- Updated dependencies [e367165]
+  - @weasel-js/gestures@1.0.1
+  - @weasel-js/font@1.0.1
+  - @weasel-js/geom@1.0.1
+  - @weasel-js/history@1.0.1
+  - @weasel-js/modes@1.0.1
+
 ## 1.0.0
 
 ### Minor Changes