@weasel-js/core 1.4.2 → 1.4.4

package/CHANGELOG.md

@@ -1,5 +1,747 @@
 # Changelog
 
+## 1.4.4
+
+### Patch Changes
+
+- 9ce6f00: Fix solid fills coming out multiplied by whatever bitmap shared their batch.
+  A solid vertex carried the UV of a 1x1 white texel, but the flush bound the
+  run's *image*, so any solid staged alongside an image quad sampled that bitmap
+  at its middle texel instead. A wall of thumbnails is a ground rect under an
+  atlas quad per cell — the shape the merged batch exists for — so its grounds
+  came out tinted by the atlas: white drew olive. Reported from outside the repo
+  against a canvas2d reference; no visual baseline caught it, because in every
+  demo the quad covers its ground.
+  
+  Every batch vertex now names the texture slot it samples. Slot 0 is always the
+  white texel, so a solid's `texture() * a_vertexColor` is the vertex color
+  exactly whatever else joins its run, and bitmaps take the slots above it.
+  
+  That also lets one run hold up to seven distinct bitmaps. A document with a
+  handful of loose images used to break its run on every change of bitmap; now it
+  breaks only when the slots run out, or when one bitmap is drawn at two
+  MAG_FILTERs, which is state on the texture object and cannot be had both ways
+  in one draw.
+  
+  `tests/visual/batch-pixels.spec.ts` reads the framebuffer channel by channel
+  rather than diffing a screenshot, which is what it takes to see a run's
+  composition at all.
+- 6f876a7: Two canvases under one `DepRegistryProvider` no longer take each other's deps
+  down.
+  
+  `register` set one source per name and its release did a bare `delete`. Mount a
+  second canvas under a shared provider and it displaced the first's `view` /
+  `scene` / `selection`; unmount either one and the name went dark for the canvas
+  still on screen.
+  
+  Sources now stack per name, newest live, and a release removes its own entry
+  wherever it sits — so a displaced source comes back when the one above it
+  leaves, and a displaced source leaving disturbs nothing. Same shape as the
+  `ActionsProvider` registrant stack, one layer down.
+- ed400a3: A derivation now receives its dependencies as `{ node, pose }` rather than as
+  bare poses. Breaking for anything with a `derivePath` or `derivePose`: read
+  `deps[0]?.pose` where it read `deps[0]`.
+  
+  A connector legitimately reads more than a box — one that thickens with its
+  endpoint's weight, or routes only to nodes on a given layer, is answering off
+  `data` and `layer`. The scene has invalidated dependents on `kit:setData` and
+  `kit:setLayer` since those landed, and `scene.ts` said in a comment that a
+  derivation "is handed its dependencies' nodes, not only their poses". It was
+  not: the invalidation was paying for a read the signature could not perform.
+  
+  `scenePoseLookup` is now `sceneDepLookup` and answers `DerivedDep` for the same
+  reason. `DerivedDep` is exported.
+- fc00dae: Hand a derivation its dependencies' paths, and label an edge with one.
+  
+  `DerivedDep` is now `{ node, pose, path }`. The path resolves on first read and
+  memoizes, so a route costs the same whether one node reads it or five, and a
+  dependency nobody asks about costs nothing. `resolveDerivedPath` moves beside
+  `derivedPose` in `core/scene` — a pose can now derive from a dependency's path —
+  and picks up the cycle guard the pose side already had.
+  
+  `pointAlongPath(path, t)` is the new geometry primitive underneath: where a path
+  is at a fraction of its length, and which way it heads there, measured along the
+  flattened arc.
+  
+  In `@weasel-js/diagram`, an edge label is an ordinary leaf node with
+  `dependsOn: [edge]` and `LABEL_DERIVE_POSE`. Its trait says where it sits —
+  `at: 'start' | 'mid' | 'end'` or a fraction, plus an `offset` perpendicular to
+  the route — and it reads the edge's resolved path rather than routing again, so
+  a label and its arrowhead can never disagree about where the edge went.
+- 730da55: A derived node now recomputes when a dependency's `data` or `layer` changes.
+  
+  `derivePath` is handed its dependencies' nodes, not only their poses — so a
+  connector that thickens with a node's weight, or draws only for nodes on a given
+  layer, is answering off `data` and `layer`. `kit:setPose` and `kit:move`
+  invalidated the dependent's memo; `kit:setData` and `kit:setLayer` did not, so
+  the derived geometry kept the old answer with nothing on screen to show it was
+  stale. Undo and redo were wrong the same way.
+  
+  Both ops now invalidate dependents on `apply` and on `revert`, matching the two
+  that already did.
+- 60ba9d9: A stroke marker on a derived path is drawn.
+  
+  `markerStart` / `markerMid` / `markerEnd` reached the `kit:derived` painter
+  intact and were then dropped: the painter emitted its stroke command and
+  returned, where `kit:path` follows with a marker pass. So an arrowhead on a
+  diagram edge — the whole reason markers and derived geometry landed in the same
+  release — silently drew nothing. Its own `ink` had been reserving the hit-test
+  reach for the marker all along, which is the shape of the bug: the pointer could
+  already grab past the end of a line with no head on it.
+  
+  A connect-authored edge now carries `markerEnd: 'arrow'` by default. An edge
+  runs *from* one node *to* another and a plain line does not say so;
+  `DEFAULT_EDGE_STROKE` is exported for a consumer overriding `commit` who wants
+  the rest of it.
+- 5732951: The minimap's scene fit and the scene text editor read a derived pose rather
+  than the placeholder a derived node authors. `computeFitView`'s `'scene'` fit
+  frames on `documentPose`, so a derived node is framed where it actually is
+  while a drag still leaves the framing alone; `useSceneTextEdit` resolves both
+  its double-click hit test and the overlay's own projection through
+  `effectivePose`, so double-clicking a derived label opens the editor on it and
+  the box lands on the text.
+  
+  Removes `UseMoveOptions.cascadeWorldPose`. Nothing has read it since the move
+  action started walking `scene.childrenOf` for its own cascade — it was a
+  documented option that silently did nothing, and two doc comments described the
+  behavior it used to drive.
+- 2ff4824: A scene node can now derive its **pose** from its dependencies, the way it
+  already derived its path. New API; a group's bounds change behavior.
+  
+  `Node.derivePose` takes the same `dependsOn` list as `derivePath`, serializes
+  through `SceneRegistry.derivePose` by key, and rides the same push
+  invalidation. Where a derived path is resolved at paint time and reaches only
+  the painter, a derived pose is what the node *is* at — it feeds bounds,
+  hit-testing, selection chrome, snapping and layout.
+  
+  `dependsOn` gains a second form, `'children'`: "my own children, in child
+  order", which a fixed id list cannot express because reparenting would have to
+  maintain it. The two forms differ in lifetime as well as membership — deleting
+  a node still deletes everything that names it in `dependsOn`, but a container
+  outlives the children it derives from, because an emptied group is still a
+  group.
+  
+  `groupAction` uses it, which fixes the group-bounds defect: a container's union
+  AABB was computed once at creation and never re-derived, so moving a member
+  left the group's bounds, selection chrome and hit area behind. The kit
+  registers the union function under `kit:unionOfChildren` and merges its own
+  registry entries under the consumer's, so a grouped document round-trips
+  through `toJSON` in any scene.
+  
+  `effectivePose(scene, node)` is the one rule — override, else derived, else
+  authored — and now takes the scene rather than the override table alone. The
+  three render walks, the pick walk, and the scene, commit and gesture adapters
+  all resolve through it or through `documentPose`, the same answer minus the
+  override step for a reader that must not see an in-flight gesture. Both are
+  exported.
+  
+  `clipFromPose`, `derivePath` and `derivePose` now share one table-driven
+  serialization path (`core/scene/nodeFnFields.ts`) instead of a copy per field.
+- 3d89141: Layout: `layered`, `tree` and `force`, and the action that runs one.
+  
+  A layout is a plain function of the graph — no scene, no ops, no history. It
+  hands back the new top-left for every node that **moves**, and a node already
+  standing where the layout wants it is absent from the answer, so re-running a
+  layout on an arrangement it produced writes nothing and pushes no undo entry.
+  
+  Three rules keep a re-layout from scrambling a diagram someone has arranged.
+  There is no RNG anywhere in the path, so the same graph always lays out the same
+  way. Within-rank order is seeded from where the nodes already sit on the cross
+  axis rather than from crossing-minimization, so two branches an author dragged
+  into an order come back in it. And a node carrying `pinned: true` never moves,
+  with the rest of the layout translated to sit around it — with no pin, the
+  layout lands on the diagram's own bounding box rather than at the origin.
+  
+  `layered` ranks by longest path, breaking cycles with a depth-first walk in node
+  order so a loop draws as an edge running back up the page. `tree` centers a
+  parent over its children's block; a graph that is not a tree still lays out,
+  since roots are the nodes nothing points at and anything the walk cannot reach
+  becomes a root of its own. `force` is an iterative relaxation seeded from the
+  current positions — **the one layout that is not idempotent**, since re-running
+  it keeps relaxing.
+  
+  `buildGraph` reads the adjacency index from the same participant source the port
+  affordance takes, per invocation rather than maintaining one. `createLayoutAction`
+  rebuilds it on each press and writes the whole move as a single `scene.batch`,
+  carrying a container's whole subtree — `setPose` does not cascade, and a built
+  body would otherwise walk out from under its own label rows.
+  
+  In core, `createSimulation` is the velocity-Verlet integrator with no clock
+  attached: `tick()` is the only thing that moves a node, so a pure function can
+  run a whole relaxation and read the result. `useSimulation` is now that
+  integrator on a frame loop and is otherwise unchanged. `SimulationCore` and
+  `SimulationOptions` name the halves, and forces can be handed a seeded `random`
+  in place of `Math.random`.
+- 4a128c4: New package `@weasel-js/diagram` — the skeleton of weasel's node-link
+  diagramming: flowcharts, pipelines, code-flow diagrams, simple visual
+  programming. Arc 3 of the diagram design; edges, routing, the connect gesture
+  and layout are still to come.
+  
+  **`DiagramNode` is a trait on an existing scene node, not a node type the
+  package mints.** A text block, an image, a path, a group or a plain rect all
+  become participants by carrying it, and nothing has to be authored through this
+  package to take part. Two ways to attach it, both answered by the default
+  reader: on the node's own `data.diagram`, or by kind — `createDiagramNodes`
+  takes predicates over `data` the way `createNodeRouting` does, so a class of
+  node takes part without being stamped one at a time.
+  
+  **Ports default to the perimeter, so a node needs to say nothing to be
+  connectable.** `portsOf(node, pose)` resolves every port to a world point and
+  an outward normal, reading bounds through the pose descriptor and carrying the
+  node's rotation. Anchors are normalized against the bounds — `{ u, v }` from
+  the top-left — so a port stays where it was put when the node is resized.
+  
+  **The body builder is optional**, for nodes that should look like a flowchart
+  box: `rect`, `diamond`, `stadium` and `parallelogram` outlines plus a `Row[]`
+  body of labels, fields, port rows and slots. Rows measure a floor, and the
+  authored pose is maxed against it rather than set to it — adding a row can grow
+  a node, nothing shrinks one back — which is what keeps resize, align,
+  distribute, guides, snapping and undo free of a special case. Text measurement
+  is a seam rather than an import; `canvasMeasure` adapts a 2D context.
+  
+  Rows lay out in the shape's **content box**, not its bounding box.
+  `contentBox` reports the largest axis-aligned box inside an outline — a
+  diamond's inscribed rect, a parallelogram minus its lean, the flat span between
+  a stadium's ends — and `boxForContent` inverts it so the floor grows to suit.
+  Without it a diamond's label is placed against the bounding box, lands outside
+  the diamond, and the silhouette clip removes it: the label simply vanishes.
+  
+  `registerDiagramShape` paints a node whose trait names an outline, and reports
+  the outline as its silhouette so picking and clipping follow the diamond rather
+  than its box. Rows are not painted there — a built body's rows are ordinary
+  scene nodes, so the kit's own text painter draws them and text editing,
+  selection and styling work on them unchanged.
+  
+  Core exports `AUTO_POSE_DESCRIPTOR` and `isPathLike`, which were already
+  general-purpose but reachable only from inside the package. A peer package
+  computing a node's bounds needs the kit's own default descriptor rather than a
+  second copy of it.
+- aee9d92: `createPoseOverrides` is public.
+  
+  `Scene` is public and its `overrides: PoseOverrides<TPose>` is mandatory — and
+  load-bearing, since every ongoing gesture writes a frame to it. The factory that
+  builds one was internal, so a consumer assembling a scene-like object by hand
+  had to reimplement the table from its type. It is now exported alongside
+  `createScene`.
+- c067221: Put every baked gradient ramp in one texture, a row each, rather than a texture
+  each. `GradientRampAtlas` replaces `GradientRampCache`: a stop list is baked
+  once into a 256-texel strip and written to a row, and the fragment shader picks
+  its row with `u_rampV`. Every gradient in a frame now samples the same texture
+  unit, which is what a gradient needs before it can take a batch texture slot
+  the way a bitmap or a font atlas already does.
+  
+  The atlas doubles from 16 rows and stops at 1024, recycling the least recently
+  used row past that. An animating gradient mints a new stop list every frame, so
+  the old cache grew a GL texture per frame and freed none of them; the cap is
+  what bounds that.
+  
+  `PaintBindContext.bindRamp` now returns the `v` its ramp sits at. A registered
+  paint kind that samples the ramp at a constant `v` reads whatever gradient
+  happens to own that row, so it must sample at the returned value.
+- 26d40bf: Fold gradients into the shared batch. A gradient fill used to bind its own
+  program and break the run of solid geometry, image quads and glyphs around it;
+  now it stages alongside them, so a page of gradient-filled shapes is one draw
+  rather than one per shape.
+  
+  All three kinds go, and for the same reason — not that the ramp position is
+  affine in position, which is true only of a linear gradient, but that the
+  *coordinate* the ramp position is computed from is affine in all three. So a
+  vertex carries that and the rasterizer's interpolation across a triangle is
+  exact. A linear gradient's coordinate is the ramp position itself, which is why
+  it needs no paint mode of its own; a radial or conic one carries a
+  gradient-space point, with its atlas row where a plain vertex keeps its alpha,
+  and the shader takes a `length` or an `atan` of it behind a branch on the flat
+  paint mode. Fill opacity and group alpha ride the vertices the way a solid's
+  already did, and fills, stroke ribbons and glyph-outline meshes all take the
+  route.
+  
+  Per-vertex-colored and even-odd fills still take their own draw, as do patterns
+  and shaders.
+  
+  The ramp atlas is what makes the slot arithmetic work: every gradient in a run
+  shares one texture slot, so a document full of them costs the same one slot a
+  single gradient does. Growing the atlas moves every row, so a bake that would
+  grow it — or recycle a row — flushes the run first.
+  
+  Gradient fills now apply the group's color matrix. `gradFill` was the only
+  paint program that did not, and since the batch program applies it to
+  everything in a run, leaving it out would have made a linear gradient and a
+  radial one under the same group paint differently.
+- b8d2940: Layout you can watch, and push against.
+  
+  `usePoseRun` is the transport: each frame it asks a producer for poses,
+  publishes them to the scene's ephemeral override channel — the one a drag
+  already writes to, which `effectivePose`, derived geometry and the pick source
+  read — and commits the lot as one batch when the producer says it is done or
+  the consumer stops it. Cancel drops the frames and the document is untouched.
+  It runs behind `useVisibleRaf`, and it knows nothing about layout.
+  
+  A node carrying an override the run did not publish belongs to another gesture:
+  the run never writes it, never commits it, and reports it to the producer as
+  pinned. Dragging a box mid-run is therefore the consumer's ordinary move tool,
+  with no gesture contributed by the diagram package.
+  
+  `useLiveLayout` in `@weasel-js/diagram` drives it. `force` relaxes one tick a
+  frame off the same force list the one-shot `force` runs, holding a pinned node
+  with `fx`/`fy` while its neighbors answer; `layered` and `tree` ease into a
+  target computed once. A node or edge appearing or disappearing re-heats the run.
+  
+  `SceneNode.pickable: false` makes a node transparent to the hit-test walk, so a
+  press lands on what is behind it. Without it the innermost hit wins and dragging
+  a labeled box pulls the label out of the box.
+- b5e2cd9: Solid geometry and image quads now share one batch, so a wall of thumbnails —
+  a ground rect under an atlas quad, per cell — draws in one call rather than
+  one per command. The two batches used to be exclusive: staging a solid drained
+  the image run and staging an image drained the solid one, so a shape that
+  batches perfectly in either half alone paid a flush per command. Solid vertices
+  carry the UV of a 1x1 white texel, which makes `texture() * a_vertexColor` the
+  vertex color exactly, so the merge is pixel-identical rather than close.
+  
+  Measured over a viewport-filling grid of those cells on an M2 Max via ANGLE
+  (`tests/perf/atlas-wall.spec.ts`): 600 draw commands 2.83 -> 0.10 ms, 1,650
+  11.37 -> 0.20, 5,400 40.50 -> 0.58, 15,000 126.15 -> 1.50. A run still breaks
+  on what a run cannot carry — a second bitmap, a different MAG_FILTER, a clip
+  depth, a color matrix.
+- 89276ee: `usePoseRun` and `useSimulation` hand their injected clock straight to
+  `useVisibleRaf` instead of defaulting it themselves. The gate already falls
+  back to `requestAnimationFrame`, so both were defaulting it twice — and the
+  copy in `usePoseRun` was a bare `requestAnimationFrame` in kit source, which
+  `check:frame-loops` fails the build on. The allowlist is back down to the gate
+  itself.
+- 36950d8: `scene.setDependsOn(id, dependsOn)` retargets a node's dependencies as one
+  undoable step, so dragging an existing edge's end onto a different node no
+  longer means removing the edge and adding another one. Switching a container
+  between an id list and `'children'` goes through the same call.
+  
+  Both indices move with it — the reverse dependents index that drives cascade
+  delete, and the `'children'` set that drives the ancestor walk — and the
+  retargeted node's own memo is dropped alongside its dependents', since its
+  derivation now reads different sources. Order is significant, because a
+  derivation reads its dependencies positionally; declaring what a node already
+  declares records no history entry.
+- 4f8c6b2: Text no longer breaks a batched run. Glyphs, the rules under underlined words,
+  and tessellated glyph outlines all stage into the same draw as the solid
+  geometry and image quads around them, so a wall of captioned thumbnails is one
+  draw where every label used to cost two.
+  
+  The batch shader carries the glyph math behind a paint mode, which packs into
+  the texture-slot attribute the vertex already had, so the vertex does not grow
+  and a wall of thumbnails costs what it did before. It runs that math on every
+  fragment, glyph or not, because `fwidth` in non-uniform control flow is
+  undefined and the derivative has to be taken before anything selects on the
+  mode — priced at about 1.4% of a fragment that is not a glyph. A synthetic
+  oblique now shears on the CPU as the batch places its corners, rather than in a
+  vertex shader that read the baseline from a vertex attribute.
+  
+  Three things a run used to break on are gone: a second text color in the same
+  paragraph, a decoration whose fill differs from the glyphs it sits under, and
+  the difference between a baked MSDF atlas and a runtime canvas bake. What still
+  breaks a run is a change of synthetic-bold threshold, which is a uniform — that
+  one is a fallback path, since a registered bold face never sets it.
+  
+  **Breaking for anyone importing the text shader sources.** `TEXT_VERT_SRC`,
+  `TEXT_FRAG_SRC`, `TEXT_FRAG_R8_SRC`, `TEXT_SDF_UNIFORMS` and
+  `TEXT_SDF_ATTRIBUTES` are removed from `@weasel-js/font`: text has no program of
+  its own any more. What replaces them is `GLYPH_COVERAGE_GLSL`, the snippet a
+  program pastes in to turn an atlas sample into coverage, alongside
+  `GLYPH_MODE_MSDF` and `GLYPH_MODE_R8` naming the two channel layouts.
+- 1240956: `kit:text` nodes take a `verticalAlign`, and picking follows it.
+  
+  Centering a glyph in its box meant nudging `pose.y` by hand and re-deriving the
+  nudge whenever the font size changed. The painter forwarded the pose's height
+  but never an alignment, so the box the renderer aligned within was always
+  resolved as `'top'`.
+  
+  `data.verticalAlign` — `'top' | 'center' | 'bottom'`, the same spelling the draw
+  command already took — now reaches both halves: the paint command and the
+  silhouette `textLineBoxes` builds, so a centered block is grabbable where it
+  draws rather than where a top-aligned one would have. A node that names none
+  paints exactly where it did before.
+- Updated dependencies [4f8c6b2]
+  - @weasel-js/font@1.4.4
+  - @weasel-js/text@1.4.4
+  - @weasel-js/cursor@1.4.4
+  - @weasel-js/geom@1.4.4
+  - @weasel-js/gestures@1.4.4
+  - @weasel-js/history@1.4.4
+  - @weasel-js/modes@1.4.4
+  - @weasel-js/paint@1.4.4
+
+## 1.4.3
+
+### Patch Changes
+
+- 2de5a37: A canvas opting out of an action no longer takes it away from its siblings.
+  
+  `useViewportActions` answered `pinchZoom: false` with
+  `reg.unregister('viewport.pinchZoom')`, which drops *every* registrant of that
+  id — so one canvas opting out killed pinch-zoom on a sibling that asked for it,
+  and nothing put it back when the opting-out canvas unmounted.
+  `actions={{ id: null }}` went through the same door. Registration has been
+  per-registrant since the registrant stack landed; suppression was not, and a
+  shared registry had nowhere to hang "not for me".
+  
+  `ActionsScope` is that place. It is a view of the registry in scope with its own
+  mute set: `register`, `unregister` and the dispatcher / dep-registry slots pass
+  straight through to the shared store, so cross-canvas sharing is untouched,
+  while `list`, `trigger` and `begin` skip what this scope muted. Scopes nest.
+  `<ActionsProvider>` is itself a scope, so a lone canvas needs no wrapper, and a
+  `<SceneCanvas>` deferring to a host provider now mounts one.
+  
+  `ActionsRegistry.mute(id)` returns a release; a scope drops everything it muted
+  when it unmounts. `unregister` keeps its old meaning — "this action should not
+  exist" — and is unchanged.
+  
+  Breaking for anyone implementing `ActionsRegistry` themselves: `mute` is a new
+  required method.
+- 10e1ab6: A bare `<Canvas>` now repaints when its selection changes, without a wrapper
+  asking it to.
+  
+  The redraw tripwire — the layout effect whose dep array is meant to name every
+  paint input that arrives on a render — did not name the overlay-aware state the
+  layer helpers expose. Selection, preview poses and the chrome derived from them
+  were written during render into a ref, so changing the selection prop repainted
+  nothing. It looked correct only because `<SceneCanvas>` calls `requestRedraw()`
+  by hand for its own data sources.
+  
+  The tripwire now carries the memoized chrome state, which re-derives on exactly
+  the selection, bounds and preview inputs the helpers read, plus the chrome-caps
+  predicate. A render that changed none of them still paints nothing.
+- eb0d6ce: Undo of a Delete now brings back everything the delete cascaded — a node's
+  dependents, and their own subtrees — not just the node that was named.
+  
+  Deleting a node takes everything deriving from it, so deleting a box takes the
+  edges drawn from it. The delete op only ever snapshotted the subtree, so undo
+  re-inserted the box alone and the edges stayed gone. The op now snapshots the
+  whole set before removing, and re-inserts it parent-first, each node at the slot
+  it held.
+  
+  New public read: `scene.removalClosure(ids)` answers what `removeMany(ids)`
+  would take, without taking it. The scene owns the cascade relations, so a caller
+  that rebuilds the walk from `dependsOn` and `children` goes stale the moment a
+  relation is added — `buildDeleteOps` asked its own copy of that question and is
+  now on this one.
+  
+  The delete op reads it through an optional `getRemovalClosure(ids)` on the
+  adapter, alongside `getChildren`. An adapter that cascades along nothing but the
+  subtree can leave it out and behaves as before; one that cascades further has to
+  answer, or the nodes it takes are absent from the snapshot. The scene-backed
+  adapters answer it.
+  
+  `insertNode` on the scene-backed adapters now forwards the function-valued
+  fields — `dependsOn`, `derivePath` and `clipFromPose` — so a restored edge
+  derives again instead of coming back as a static path, and a restored container
+  still clips. The delete op's serialized `descendants` argument is now
+  `cascaded`, and carries the node itself alongside what went with it.
+- 75969f6: Full-screen effect passes: a group's children render into a texture, shader
+  passes run over it, and the result composites back where the group sits.
+  
+  Until now the renderer could draw over the frame but never transform it —
+  nothing sampled what had already been drawn, so blur, bloom and distortion were
+  unreachable and the only recourse was a CSS `filter` on the `<canvas>`, which is
+  the browser compositing on the kit's behalf.
+  
+  `GroupDrawCommand.effects` is the primitive. It is the one field there that does
+  not accumulate down the group stack: it is a render-target boundary. The
+  children draw into a buffer with a stencil of its own, each effect reads the
+  previous one's output, and the composite applies the group's `transform`,
+  `alpha` and `colorMatrix` plus whatever clip encloses it — so the enclosing clip
+  clips the result rather than the pixels an effect reads, and nested clips inside
+  start from a fresh depth budget.
+  
+  `RenderLayer.effects` is that field folded in at `drawOneLayer`, which is where
+  every layer already gets wrapped in a group. A blur there blurs one layer and
+  leaves the chrome drawn above it sharp, which is the thing the CSS filter cannot
+  do.
+  
+  `blur({ radius })` and `vignette({ amount })` ship as built-ins; both return
+  `Effect[]` because a separable blur is honestly two passes.
+  `registerEffect(id, frag)` registers your own — it is `registerProgram` with the
+  effect vertex shader, and using the custom-shader one instead compiles, runs,
+  and samples the source upside down.
+  
+  Nothing is allocated until a group declares an effect, so a canvas without them
+  carries no offscreen buffer. Buffers are drawing-buffer sized, pooled per
+  renderer, and dropped on resize, dispose and context loss.
+  
+  Demo: "Full-screen effect passes", with visual baselines blurred and sharp.
+- 0d40f94: A layer whose `draw` throws now paints nothing and names itself in the console,
+  instead of taking the frame down with it.
+  
+  The paint runs on the frame loop, so a throw out of `draw` surfaced as an
+  uncaught `requestAnimationFrame` error on the window: the canvas went blank and
+  stayed stale until something unrelated asked for a redraw. `drawOneLayer` — the
+  one path both the canvas and a viewport's inner pass go through — catches it,
+  drops that layer for the frame, and paints the rest.
+  
+  `drawLayers` and `drawOneLayer` take an `onLayerError` callback for a consumer
+  that wants to route the failure somewhere of its own; the default reports the
+  layer id and the error to `console.error`. The layer's cached commands are
+  dropped with it, so the next frame is a real re-attempt rather than a stale tree
+  served under fresh deps.
+- 713f98a: A layout strategy decides what happens to a child released outside every
+  container.
+  
+  When no container accepted a drag, the move action committed the child wherever
+  the pointer stopped, and the source layout had no say — a grid could not close
+  the gap, and a container that only means to arrange its own children could not
+  take one back.
+  
+  `LayoutStrategy.releaseDrop` is that say. It sees the source container, its
+  remaining children and the dragged child in world coordinates, and returns ops
+  that replace the free-space commit. An empty array leaves the container alone,
+  which snaps the child home, since the drag only ever wrote previews. `null` —
+  and a strategy that does not implement the method — leaves the drop where the
+  pointer left it, exactly as before.
+- 85f4a21: Dragging several selected nodes into a layout container now runs the layout,
+  instead of falling through to a plain translate. Three nodes dropped on a grid
+  fill three cells.
+  
+  The selection lands as a unit. One container is chosen, from the center of the
+  whole dragged group rather than each child's own — hit-testing per child would
+  scatter a selection straddling two containers — and it has to accept every
+  member: `acceptsDrop` is asked once per dragged child, and one refusal takes the
+  container out of the running. The children are then placed one at a time, in
+  selection order, and each placement sees the container state the previous one
+  produced. A strategy that packs, stacks or displaces therefore sees the group
+  arrive the same way it would see three separate drags. If any child has no
+  target, the whole drop is refused rather than split between two homes.
+  
+  Each child is snapped at its own position, displaced by however far the pointer
+  sits from the selection's center, so the group keeps its shape as it lands. A
+  single-node drag still probes at the pointer exactly as before.
+  
+  The rest follows the selection: the live preview reflows the destination and
+  every source container the selection left, one pass per container with all of
+  its departing children withdrawn at once; and the commit emits a reparent op per
+  child that changed parent, every reparent before every drop.
+  
+  `releaseDrop` — a container's say over its own child released into open space —
+  is now per source container too, so a mixed selection resolves per child: the
+  grid's own child goes home, and a free node in the same selection keeps the
+  translate it would have had on its own.
+- 4bb0341: A parallax plane draws its source layers through `drawOneLayer`, so their
+  `space` means something.
+  
+  `createParallaxLayer` called `layer.draw(...)` directly where every other path
+  through a view — the canvas itself, a viewport node's inner pass — goes through
+  `drawOneLayer`. A `space: 'world'` source therefore came out unprojected, and the
+  only way to see anything was for the source to pre-project by hand while
+  declaring a space it did not draw in. ParallaxDemo's four layers did exactly
+  that, and their labels were lies.
+  
+  Now a world-space source is wrapped in the plane's inner view and a screen-space
+  one is passed through, the same rule that holds everywhere else. The plane
+  itself stays `space: 'screen'` — its children carry whatever transform they
+  need, and the outer canvas must add none.
+  
+  The demo drops its `project` helper and emits world coordinates; the committed
+  `parallax` visual baseline passes unchanged.
+- e0d5580: `pathHitTest` reads curves and holes instead of throwing on one and ignoring
+  the other.
+  
+  Its vertex extractor walked `M` and `L` only and threw on any bezier command,
+  and it stopped at the first `Z`, so a path's second contour was never
+  considered. The throw was reachable in ordinary use: `sceneAdapter`'s
+  `nodeBoundsPassClips` calls `pathIntersectsRect` on every ancestor clip, so a
+  container with a curved `clipFromPose` crashed the hit-test walk.
+  
+  `pathContainsRect`, `pathIntersectsRect`, `pathContainsPolygon` and
+  `pathIntersectsPolygon` now treat a `PolygonPath` as its filled region. Whether
+  a point is inside comes from `pointInPath`, so beziers flatten and `fillRule`
+  decides — a donut's hole is outside the shape under `evenodd` and inside it
+  under `nonzero`, and the four predicates agree with `pathContainsPoint` on
+  which. Each takes the same optional flattening tolerance `pointInPath` does.
+  
+  Two answers change for paths that already worked. A rect sitting in a hole is
+  no longer reported as contained or intersecting, and containment now fails when
+  a contour reaches into the rect at all rather than only when it crosses an
+  edge.
+- edf99d5: Undoing a removal from a persisted history brings `derivePath` and
+  `clipFromPose` back.
+  
+  `kit:remove`'s snapshot cloned each node with its function-valued fields
+  attached, which works in-session and disappears the moment the history is
+  serialized. `dependsOn` survived the round-trip and repopulated the dependency
+  index, so a restored derived node looked wired up and never painted; a
+  container came back unclipped the same way.
+  
+  The snapshot now carries the registry keys beside the nodes, and revert
+  re-resolves them exactly as `kit:add` does — warning, not throwing, when a key
+  is absent from the scene's registry.
+- 2723cc7: `selectAll` no longer selects nodes on a hidden layer, so Cmd+A then Delete
+  cannot take content the user cannot see.
+  
+  It walked `renderOrder()`, which is every node in the scene regardless of what
+  its layer's `visible` flag says. It now walks `renderOrderNodes()` when any
+  layer is hidden — the same sequence, carrying the layer each node sits on — and
+  keeps the cheaper id walk when every layer is visible.
+  
+  A `scene` dep that answers neither `layers` nor `renderOrderNodes` behaves
+  exactly as before.
+- 0ca0aca: Layer groups: several consecutive layers render into one buffer and share one
+  effect pass.
+  
+  `RenderLayer.effects` runs over a single layer, which is the wrong picture as
+  soon as a pass reads neighboring pixels — `blur(A over B)` is not `blur(A) over
+  blur(B)` — and it costs a buffer and a pass chain per layer. A consumer wanting
+  the world blurred and the HUD sharp had no way to say that the world was more
+  than one layer.
+  
+  `LayerGroup` is that surface: `{ id, layers, effects?, alpha?, colorMatrix? }`,
+  passed to `<Canvas>` / `<SceneCanvas>` as `layerGroups`. Members are named by
+  `RenderLayer.id`, the same names `layerOrder` and `layerVisibility` use, so a
+  group can take in kit-built layers as readily as consumer ones. `drawLayers`
+  brackets each run of consecutive members in one `kind: 'group'` command; the
+  renderer's existing offscreen path does the rest.
+  
+  Only consecutive members share a buffer, because anything drawn between two of
+  them has to land between them. A group split across the render order is drawn as
+  one bracket per run, with a warning — the picture is right, the declaration
+  probably is not. A hidden member, and a member that paints nothing this frame,
+  break no run.
+  
+  `effects` also accepts a thunk, re-read on every frame the canvas paints, so an
+  animating radius costs no React render. A group that declares no effects, alpha
+  or color matrix emits no wrapper at all, and a frame with no groups allocates
+  nothing.
+  
+  The side-scroller load test now blurs its six world layers on a head knock and
+  leaves its HUD, callouts and ending card sharp; the CSS `filter` it used to
+  reach for is gone.
+- 3583ca3: `useStandardActions` takes an `exclude` list, so a consumer can bind its own.
+  
+  The hook registered a fixed descriptor list, which left no way to suppress an
+  individual kit action. A consumer wanting its own align or distribute
+  keybindings got the kit's as well, and the two competed for the same keys.
+  
+  `exclude` names ids to leave unregistered; an id naming no kit action is
+  ignored, and changing the list re-registers. `KIT_STANDARD_ACTION_IDS` is the
+  full list in registration order, so the ids are discoverable rather than
+  something to read out of the source.
+- fc16cac: `Stroke.paint` is optional, and a stroke without one paints nothing everywhere
+  rather than throwing.
+  
+  Such a stroke is real: a property panel that writes one field onto a node with
+  no stroke — a width, a cap — materializes a whole stroke around it, and
+  documents written before that was fixed still hold them. The painters already
+  read one as no stroke. Every other reader dereferenced `paint` unguarded, so a
+  document holding one threw on SVG export, on copy, and out of any consumer
+  painter or overlay whose command reached the renderer directly.
+  
+  The type says so now, which is what stops the next reader from assuming
+  otherwise. What each one does with an unpainted stroke:
+  
+  - The renderer skips the stroke pass and paints the fill.
+  - The SVG serializer emits no `stroke` attributes at all, the way it already
+    does for an absent or zero-width stroke.
+  - Text layout keys it as no stroke, so an unpainted run groups with unstroked
+    ones instead of splitting a draw call, and does not get pulled onto the
+    outline tier to stroke nothing.
+  - `setStrokeOpacity` seeds the default stroke color to have something to set an
+    opacity on, keeping the width and joins already there.
+- 6d4bbeb: WeaselDraw's SVG export drops what a hidden layer holds, matching what the
+  pixel path draws. It walked the whole container tree with no visibility gate,
+  so hiding a layer and exporting produced a file with the hidden content in it.
+  
+  `SceneSource` gains an optional `isPainted(id)`; a node it refuses is skipped
+  along with everything under it, under an explicit `roots` override too — a
+  selection naming a hidden node still must not export it. A source that omits
+  the predicate emits everything, exactly as before.
+- 995fde2: A text node's `data.fill: null` is now an explicit no-fill, so stroked-but-
+  unfilled text — outline-only display type — renders as such.
+  
+  Every other node kind already read `null` that way. Text resolved it back to the
+  default black, because a `ResolvedRun` had to name a concrete `FillStyle` and
+  nothing downstream could skip the fill pass. `ResolvedRun.fill`,
+  `ResolvedTextStyle.fill` and `LaidOutGroup.fill` are now `FillStyle | null`, and
+  `TextPaint.fill: null` carries through to all three. Absent still means the
+  default black.
+  
+  An unfilled run paints through its stroke alone, which only the outline tier can
+  lay down, so layout emits no atlas quads for one and the renderer skips the
+  glyph-fill mesh — an unfilled, unstroked run emits nothing at all, not even its
+  outline geometry. Underline, strikethrough and overline follow the fill: a rule
+  is a solid rect with no stroked counterpart, so an unfilled run draws none.
+  Nothing changes for text that has a fill.
+  
+  Picking deliberately does not follow. `kit:text` still reports `filled: true`
+  for `fill: null`, because a text node's silhouette is its line boxes rather than
+  its glyph ink — reporting it unfilled would leave a word grabbable within a
+  stroke width of a box edge and nowhere near the letters.
+  
+  `@weasel-js/svg` reads and writes SVG's own spelling of this: `<text
+  fill="none">` parses to `fill: null` instead of being dropped as absent, and a
+  text node with `fill: null` serializes as `fill="none"` rather than as SVG's
+  default black. `SvgTextNode.fill` widens to `FillStyle | null`.
+  
+  The "Text outlines" demo has a Fill checkbox alongside its Stroke one; the two
+  off together is a node with no glyph paint at all.
+- 6e4fb4d: A user layer survives `toJSON()` — its name, and the fact that it is a user
+  layer at all.
+  
+  Every layer was written to a snapshot as `{ id, visible, locked }` and read back
+  as `kind: 'system'`, so reloading a document renamed nothing, showed nothing in
+  a layer list, and made `renameLayer` throw "cannot rename system layer" on a
+  layer the user had just created.
+  
+  `SerializedLayer` is the snapshot's layer shape: the fields it always had, plus
+  an optional `kind` and `name`. A snapshot written before this carries neither
+  and loads as system layers, which is what every layer in it was.
+  
+  `sceneFromJSON` now builds an empty scene and calls `loadState`, so the layer
+  stack is rebuilt by the one reader that knows how instead of by `createScene`,
+  which mints system layers only.
+- b0fba6a: One wheel convention across the kit. Breaking: `computeWheelAction` changes
+  shape, and `useZoom` / `usePinchZoomTool` are gone.
+  
+  Three public entry points answered the wheel and disagreed with each other.
+  `viewport.wheelPan` + `viewport.zoom` panned on a bare wheel and zoomed on
+  Cmd/Ctrl+wheel; `computeWheelAction` did the opposite, zooming on a bare wheel
+  and treating Cmd+wheel as a vertical scroll; `useZoom` zoomed on a bare wheel
+  and never panned. The two reducers also panned in screen pixels against a
+  `{ zoom, panX, panY }` state that is not a `View` and cannot be handed to
+  `view.set`.
+  
+  The surviving convention is the one the dispatcher already ships: bare wheel
+  pans, shift+wheel pans horizontally, Cmd/Ctrl+wheel zooms under the pointer,
+  and a trackpad pinch (which browsers deliver as ctrl+wheel) zooms. Coordinates
+  are `View` throughout — a pan delta arrives in screen pixels and is divided by
+  `View.scale` before it lands, and a zoom anchor is canvas-local.
+  
+  `computeWheelAction(view, input, clamp?)` now takes and returns a `View`. Its
+  halves, `wheelPan` and `wheelZoom`, are exported alongside `wheelZoomFactor`,
+  and `viewport.wheelPan` / `viewport.zoom` call them rather than restating the
+  math — so the wired path and the pure one cannot drift again. `WheelState` and
+  `ZoomBounds` are removed; `WheelInput` names its anchor `x`/`y` instead of
+  `mouseX`/`mouseY` and reads `ctrlKey`. Zoom is now `1.1^(-deltaY/100)` on
+  every path, which is reciprocal: scrolling a distance and back returns to the
+  scale you started from, where the old `1.1`/`0.9` pair did not.
+  
+  A pinch anchors under the fingers in canvas-local coordinates. The dispatcher
+  converts the multitouch centroid the same way it already converted the wheel
+  anchor; on a canvas offset from the viewport top-left, `viewport.pinchZoom`
+  was anchoring on raw client coordinates and drifting by that offset.
+  
+  `useZoom`, `UseZoomOptions` and `UseZoomReturn` are removed. They were
+  deprecated, had no consumer, and were the third convention.
+  
+  `usePinchZoomTool` and `PinchZoomToolOpts` are removed, with the `viewport`
+  prop on the unexported `<Canvas>` primitive and the `ViewportConfig` type that
+  typed it. `viewport.pinchZoom` on `<SceneCanvas>` is unaffected — it is the
+  action, and it is now the kit's only pinch path. `usePinchGesture`, the raw
+  two-finger listener underneath, stays.
+- Updated dependencies [fc16cac]
+- Updated dependencies [995fde2]
+  - @weasel-js/paint@1.4.3
+  - @weasel-js/text@1.4.3
+  - @weasel-js/cursor@1.4.3
+  - @weasel-js/font@1.4.3
+  - @weasel-js/geom@1.4.3
+  - @weasel-js/gestures@1.4.3
+  - @weasel-js/history@1.4.3
+  - @weasel-js/modes@1.4.3
+
 ## 1.4.2
 
 ### Patch Changes