@weasel-js/core 1.10.0 → 1.10.1

package/CHANGELOG.md

@@ -1,5 +1,173 @@
 # Changelog
 
+## 1.10.1
+
+### Patch Changes
+
+- 113c088: Every adapter carries the tree. `getParent` and `getChildren` are required on `MoveAdapter` (and so on `SelectAdapter`), `getNode`, `getParent`, and `getChildren` on `InsertAdapter`, both methods on `OrderedAdapter`, and `getParent` on `AlignAdapter`, `DistributeAdapter`, and `PickTopMostHitAdapter`. `BooleansAdapter` and `CreateOutlinesAdapter` require `getNode`, `getParent`, and `getChildren`, and `BooleansAdapter` requires `setChildOrder` too. The readers no longer carry a second path for an adapter that leaves one out: the default pick of `useSelectTool` walks `getChildren` and never `getNodes()`, and the insert, delete, reparent, and reorder ops call the tree reads without checking for them.
+  
+  Breaking: an adapter written by hand without these methods no longer compiles, and an op applied against an object without them throws where it used to skip the step. A store with no nesting answers as a tree of roots: `getParent: () => null` and `getChildren: (parentId) => (parentId === null ? ids : [])`. A node with no children must answer `[]`; an adapter that answers the whole list for every parent makes a delete op recurse until the stack overflows.
+  
+  Also breaking: `BooleansAdapter.getZOrder` is removed, since the slot it overrode is now always read through `getParent` and `getChildren`, and `pickTopMostHit` takes an adapter, no longer `null` or `undefined`.
+  
+  `sceneAdapter.ts` no longer imports React (`useSceneAdapter` lives in its own module, exported as before), and a detached scene view (`renderSceneToCanvas`, `renderSceneToPixels`) reads the scene through `sceneToAdapter`.
+- cbd5b4d: `@weasel-js/geom`'s six-number affine type is `Affine`, no longer `Mat3`. It sat one capital letter from `mat3`, the namespace over the nine-element column-major `GlMat3` a GL uniform takes, and the two are different matrices. `mat3.toAffine` and `mat3.fromAffine` already named the conversion this way.
+  
+  Breaking: `import type { Mat3 } from '@weasel-js/geom'` becomes `import type { Affine }`. The values are unchanged, and so are the free functions beside the type (`identity`, `multiply`, `invert`, and the rest).
+- d3b73b9: The text Align bar no longer lights Left for `align: 'start'` (or Right for `'end'`) when the style states no `direction`. An omitted direction is `auto`, each paragraph's own, so right-to-left text aligned `start` painted from the right under a bar reading Left. The bar now lights nothing for `start` / `end` unless `direction` is `ltr` or `rtl`, and resolves them to an edge as before when it is.
+- aaa2b4f: Path edit has two commands for the selected anchors' handles. `retractHandles` collapses them onto their anchors, making sharp corners; a segment whose ends both lose their handles turns straight. `makeHandlesSymmetric` gives each anchor two handles of equal length pointing opposite ways, making it smooth: the shared direction splits the difference between the two handles' own, the shared length is their mean, and an anchor with one handle mirrors it. The ends of an open path are skipped. Both are in the standard actions and the `paths` feature preset, in the `anchors` group, with icons `RetractHandlesIcon` and `SymmetricHandlesIcon`, and are disabled when they would change nothing.
+  
+  Dragging a control handle with Shift held keeps it at the angle it had at the press and changes only its length; it can shrink onto its anchor but not flip through it.
+  
+  `@weasel-js/geom` adds the edits underneath: `retractHandles(set, flatIndexes)`, `makeHandlesSymmetric(set, flatIndexes)`, and `handleAlongItsAngle(anchor, handle, to)`.
+- c7b7ed5: In path edit, dragging a segment bends it: the point pressed follows the pointer and the segment's two handles move to carry it, and a straight segment becomes a curve. An end anchor that was smooth stays smooth, its other handle turning at its own length. It is the `bendSegment` action, in the standard actions and the `paths` feature preset. A drag that starts on an anchor or off the path still moves anchors or draws the marquee, and on a canvas with no mode registry a drag that starts on the edge no longer moves the shape.
+  
+  Path edit now lays a `segment` affordance along the edited path's outline, under its anchors and controls, and `bendSegment` binds to it. Affordance regions take a new shape for it, `{ kind: 'outline', path, hitRadiusPx }`: hit within that many screen pixels of the path's outline. `@weasel-js/routing` adds `isSegment` for that hit and `isPathEditPart` for any anchor, control, or segment hit; `move` turns down a press on any of them.
+  
+  `bendSegment(set, grip, dx, dy)` (`@weasel-js/geom`) is the edit underneath, taking the `{ sub, segIdx, t }` that `segmentAt` reports.
+- faf8ff3: A kit canvas brings its own size rule. `<Canvas>`, `<SceneViewCanvas>`, and `<DrawCanvas>` used to take their CSS size from a class in `@weasel-js/core/style.css`, so a page that did not load that stylesheet showed each one at its drawing buffer's size, `dpr` times too large. Each canvas now adopts the one rule into the document or shadow root it mounts in, so a popout window and a shadow root are covered too. The rule keys on a `data-wzl-surface` attribute at zero specificity, as before, so a class passed to the canvas still resizes it. The rule is gone from `style.css`, and the canvas no longer carries the kit's `surface` class.
+- 8bee821: `SceneCanvasApi.ingest` works from the canvas's first render. It reached the action registry through a ref an effect filled, so a call made before that effect ran was dropped with a warning.
+- 67a7de8: On a controlled `<SceneCanvas>`, writing `view` in your own state now stops a camera glide in flight, the way `setView` and input already did; before, the glide's next frame overwrote the write. The canvas tells the write from your handling of the glide's own frames by order, not by value: a `view` prop that moves when the glide has written no frame since the prop last moved is yours. So a consumer who clamps or rounds inside `onViewChange` still gets a whole glide, and one who moves the prop a second time for one frame (from an effect, or a deferred value) stops it. A write that lands in the same render as a frame's is not seen, and the glide carries on. Behavior change.
+- f6e3e90: Duplicate and Alt-drag clone point a copied node's `dependsOn` list at the copy of each dependency that was copied with it, and at the original of each that was not. A copy used to follow the copies only when every dependency was copied, so duplicating an edge with one of its endpoints left the new edge on both original endpoints, drawn over the first. A copy none of whose dependencies were copied still follows the originals.
+  
+  Changes behavior: a copied derived node with some of its dependencies in the copy now derives from a mix of copies and originals.
+- 74ba77e: Additive: a document's pages as geometry. `layoutPages` places a list of `Page`s in one world space, in a row or a column; `pageAt` and `pageOfBounds` answer which page a point or an object is on; `pagesBounds` is the box around all of them; `adjacentPage` steps the page order, for a next-slide move; `pagesLayer` is a world-space render layer that paints each sheet; and `fitViewToPage` is the view that frames one.
+- a8e8048: A node that derives from a skinned path follows it as it bends. `DerivedDep.path` now answers the path a pose override shows the dependency by, ahead of one the dependency derives, so a `derivePose` or `derivePath` reading `deps[0].path` gets a skinned path as its rig bends it where it used to get `null`. A derivation is run again when that path is replaced, even inside the same bounds. The document reading (`documentPose`) and a lookup through a scene slot's `toPose` still answer the derived path alone.
+  
+  Changes behavior: a derivation that took a non-null `path` to mean "this dependency derives one" now also sees one on any node a pose override gives a `path`.
+- 755b7ff: A painter can draw over a container's children. `overChildren(commands)` wraps part of what a `drawOne` returns, and the scene walk (`buildSceneTree`, so `<SceneCanvas>` and `buildSceneViewCommands` alike) paints that part after the node's children, in the node's own layer, with the node's rotation, alpha, and clips. `defaultDrawOne` uses it for a container's `data.label`, which the container's children used to cover: a group made by Outline Stroke from a labeled rect shows its label again. Additive: `overChildren`, `isOverChildren`, and `splitOverChildren` are new exports, and outside a scene walk the wrapped part is an ordinary group painted where it sits.
+- 1d3ca5c: A drawn polygon or star stays editable as one. The `insert` dep stores the parameters it was drawn with on the node as `data.generator` (`{ kind: 'polygon', sides, rotation }` or `{ kind: 'star', points, innerRadiusRatio, rotation }`) beside `data.path`, which stays the geometry every reader uses. The `polygon`, `star`, and inferred `path` entries of `defaultNodeProperties` / `inferredNodeProperties` show Sides, or Points and Inner, for a node holding one, and changing one makes the shape again on the same circle, under the same rotation, in the same undo step.
+  
+  Editing the path in path edit drops the generator, leaving plain geometry; so does changing a parameter of a shape whose path no longer matches its generator.
+  
+  `NodePropertiesEntry` gains `settle(next, prev)`: what a property write stores, given the node as the write left it and as it was. `SelectionPanel` applies it to commits and to slider drafts. Core exports the generator helpers: `regenerateShape`, `settleShapeGenerator`, `shapeGeneratorOf`, `shapeGeneratorPath`, `clampShapeGenerator`, `isShapeGenerator`, `withoutShapeGenerator`, `SHAPE_COUNT_RANGE`, `STAR_RATIO_RANGE`, and the `ShapeGenerator` types.
+  
+  A committed polygon or star is no longer stretched: its pose was the box of its circle, and the stored path's own box was stretched to fill it, so a five-point star came out stretched 5% along one axis and 10% along the other, unlike its preview. The pose, and the insert's reported bounds, are now the box of the shape itself.
+- 566f15e: A double-click on a path with several nodes selected now opens the path under the pointer for anchor editing. Before, `enterPathEdit` opened the first editable path in the selection, which need not be the one double-clicked. It still falls back to that path when no editable path is under the pointer. The action now requires the `nodeAtPoint` dep, which `<SceneCanvas>` sources.
+- ee59ccd: Deleting an anchor keeps the curve's shape. The segment that replaces the two either side of it keeps the directions they left and arrived with, and its handle lengths are now fitted to them rather than set to a third of the chord, so deleting one anchor of a circle leaves a round arc instead of a flat lobe. An anchor that was inserted on a curve and then deleted gives back the original curve. A gap between two straight segments closes with a straight one.
+  
+  `fitCubicWithTangents` (`@weasel-js/geom`) is the fit underneath: the one cubic through a run of samples whose control points keep given end tangents.
+  
+  Breaking: `fitCubicThroughDeletion(prev, next)` becomes `fitCubicThroughDeletion(prev, removed, next)`, since the fit needs the anchor being removed.
+- f22f5ce: Resizing several nodes at once keeps a turned or skewed one's shape. A non-uniform resize makes a parallelogram of a turned box, and `remapRotatedLeaf` now writes that to the leaf's `pose.transform` where it used to drop it; it also reads a `transform` the leaf already carries, and a skewed leaf with no rotation goes through it too. Breaking for a caller that relied on the result never carrying a `transform`: a turned leaf resized unevenly now has one. A uniform resize, an upright plain leaf, and a leaf turned by a quarter turn still get none.
+- 92e6291: A container's layout is the one its scene node declares, and nothing else. The `layouts` prop of `<SceneCanvas>` and the `layouts` option of `sceneToAdapter` and `useSceneAdapter` are removed, along with `useLayoutArrivals`, `layoutArrivalHandler`, `LayoutSource`, and `LayoutArrivalOptions`, which existed to carry that map into the scene's layout pass.
+  
+  Breaking: declare the layout on the node (`scene.add({ kind: 'container', layout })`) or set it with `scene.setLayout(id, layout)`, which is undoable. The scene's own layout pass arranges it, measured by `useScene({ layoutFrame })`; a canvas's `poseDescriptor` no longer measures a layout, so a scene whose poses are not rects passes `layoutFrame`. `scene.setArrivalHandler` is unchanged.
+- 2216d1b: A marquee and a lasso now agree on a node whose pose descriptor bounds reach past what it draws. A marquee took such a node as soon as its bounds overlapped the rect, and an enclosing lasso refused it when its bounds poked out; both now decide by the drawn outline, as an `intersect` lasso already did.
+  
+  Changes behavior: a node whose descriptor (`forNode` included) reports a box larger than its painter's silhouette is no longer taken by a marquee over the part of that box where nothing is drawn. Give the node a painter whose `silhouette` covers what it draws.
+- a7144f4: Breaking: a move behavior moves the drag by returning `transform`, and nothing else. `BehaviorResult.pose`, the deprecated override that was turned into a translate for the first dragged id, is gone, and so is the deprecated `BehaviorMoveResult` alias of `BehaviorResult`. Return `{ transform: { kind: 'translate', dx, dy } }`.
+  
+  A move gesture's context carries `offset(from, to)`, the translation between two poses' bounds, so a behavior that knows where a node lands can return it as a `transform`. `snapToContainer` does.
+- 35c4879: One answer to "is a pointer held on this canvas". `heldPointers(element)` is new in `@weasel-js/gestures` (additive): it counts the pointers pressed on an element with any button and not yet released, and every reader of one element shares its listeners. The dispatcher's `hover` gesture and hover cursor, a layer's `onUncapturedMove`, and the `pointer` dep's published position all read it, where each used to track a press its own way.
+  
+  What changes: a move with a secondary or middle button held is no longer a `hover`; `onUncapturedMove` stays off until the last of several pointers is released, and through a `pointerleave` mid-press; and the `pointer` dep no longer reports a position for a drag that began outside the canvas and passed over the page.
+  
+  `giveKeys` (`@weasel-js/react/testing/giveKeys`) releases the middle-button press it makes.
+- 886380f: Each README's "API reference" link now opens the package's page on the site, `https://orochi235.github.io/weasel/#pkg/<name>`, where it used to open the TypeDoc site at `/weasel/api/`, which is no longer built. A file comment that sat on an `export { … }` list is now marked as the file's, so an entry's description no longer shows up as the summary of each function the entry re-exports. No code changed. `@weasel-js/labkit` drops `vitepress` from its devDependencies, which nothing used.
+- f8faa63: The default node properties show a typed number to at most two decimal places: position, size, font size, tracking, leading, and tab size. A node left at `123.45678901234567` by a drag read that way in the panel. Only the text changes; the stored value keeps its digits until someone types a new one.
+- 3bc85c9: Path commands as kit actions, in the `paths` feature preset. `simplifyPath` and `offsetPath` are ongoing actions driven by one number — `tolerance` and `distance` — so a slider can preview them live with `useOngoingAction` and commit once: Simplify refits each selected path in place, and Offset Path adds the grown or shrunk outline beside each, behind its source when grown and in front when shrunk, and selects the new paths. `snipAtCrossings` (Cut at Crossings) replaces each selected path with its pieces wherever another selected path crosses it. `joinPaths` (Cmd/Ctrl+J) closes a selected open path or joins two at their nearest open ends. In path edit, `joinAnchors` (Cmd/Ctrl+J) joins the two selected end anchors and `averageAnchors` (Cmd/Ctrl+Alt+J) moves the selected anchors to their mean, with variants that average one axis only. The object commands are in a new `path` group; the anchor ones join the `anchors` group.
+  
+  These commands drop a node's `skin` and shape generator, since the new geometry has neither the anchors the skin follows nor the shape the generator makes. The geometry behind them — `simplifyPath`, `offsetPath`, `snipPathsAtCrossings`, `averageAnchorsAt`, `joinAnchorsAt` — is exported too.
+- d0c3896: Delete, Backspace, and the arrow keys in path edit now act on the selected anchors in a `<SceneCanvas>` with no mode registry. They used to delete or nudge the whole shape, because the node-level `delete` and `nudge.*` actions were registered ahead of `deleteAnchors` and `nudgeAnchors.*` and took the keystroke. The anchor actions now register first and still decline when no anchor is selected, so the same keys reach the node then.
+- 3448831: The default node properties have a Skew row for `pose.transform`, in Layout under Rotation. It reads on while a node's pose carries a skew or a per-axis scale, and turning it off removes the transform, so `SelectionPanel` can show and clear one. Additive: the row is a switch, not a matrix editor, and turning it on writes nothing new.
+- 27fe0fb: `useRigNode` keeps a rig moving when its skeleton's joints are added, removed, or reordered. The rig still gets a new `target`, but that target takes over the placement and the committed pose of every joint the skeleton still names, where it used to start at the bind pose, and an animation that was running goes on running on the target it was started on and shows through the new one. A joint that was renamed is a different joint, and stops moving.
+- 8bbf878: `composeRigidPose` composes a container's `transform` into its children, and `decomposeRigidPose` takes it back out. A child under a skewed or unevenly scaled container now answers a world pose whose box center, rotation, and `transform` draw it where the container's frame puts it; what the child's box and rotation cannot hold of the result is written to the child's own `transform`. Breaking for a scene that set a `transform` on a container under `RIGID_POSE_COMPOSITION` and relied on its children ignoring it. `composeRectPose` is unchanged: under it a container's pose only offsets its children, so neither its rotation nor its `transform` reaches them.
+- b5267f9: The rotate cursor now turns with the pointer, so the opening of its arc faces the selection's pivot from wherever the pointer is: over the rotation ring, and through the rotate drag, which used to show no rotate cursor at all. It used to be turned to match the target's own rotation.
+  
+  Two new surfaces carry it. An `AffordanceRegion`'s `cursor` may be a function of the pointer's world point and the view, worked out on each hit and reported on `AffordanceRegionHit.cursor`; read the cursor there rather than off `region.cursor`, which may now be a function. An `OngoingHandle` may declare `cursor()`, read after every move and ahead of its action's `activeCursor`.
+- 62e766c: Editing the points of a skinned path keeps its weights with its points. Inserting, deleting, cutting, nudging, and dragging anchors, and continuing or joining the path with the pen, now write the node's `data.skin` in the same undo entry as its path, so one undo restores both. Before, the weight arrays kept their old numbering and every point after the edit followed the wrong joints. A new point takes weights between those of the anchors either side of it, by its distance to each; a point drawn past an end takes the end's. Hand-painted weights are kept: nothing is weighed again from the bones.
+  
+  Adds API: `editAnchorSetTracked(path, edit)` is `editAnchorSet` that also answers `origins`, where each point of the new path came from in the old one, and `remapPointValues(values, origins)` carries an array kept per point through that edit. `remapSkin(skin, origins)` does the same for a skin. `EditAnchorsDep.applyEdit` and `editOps` take `origins` as an optional fourth argument; a dep of your own that ignores it leaves a skin as it was.
+- 5485d35: The slice tool declares a palette icon: `SliceIcon`, a knife, exported from `@weasel-js/core` and `@weasel-js/ui` beside the other tool icons. A `ToolPalette` drew its placeholder `?` for the tool before. Additive.
+- 690ea72: Hold Space while drawing a rectangle, ellipse, line, polygon, or star to move the shape instead of resizing it; let go and the drag resizes again from where the shape now sits. It is the `insert.reposition` action, which each kit shape tool binds through `INSERT_REPOSITION_BINDING` (a Space hold gated to the tool's own engaged phase), so a consumer's own drag-to-draw tool can bind it the same way. A grid-snapped start stays on the grid as it moves.
+  
+  An offhand tool now engages only between gestures: `buildToolOffhandBindings` gates its key-held specs to `[{ channel: '*', phase: 'initial' }]`. Before, pressing Space mid-drag pushed the hand tool, and the tool switch canceled the drag.
+- e962494: New package, `@weasel-js/symmetry`: live symmetry groups. A group's copies (a mirror at any angle, both axes, a point, radial, kaleidoscope, or a repeat with an optional glide) are drawn from its real children. Every edit to a child therefore reaches every copy, a click on a copy selects the child it copies, and `bakeSymmetry` turns the copies into real nodes. `createSymmetry(scene).contribution` draws the guide with draggable center, axis, and step handles, sends every tool's shapes into the active group, and keeps a path that is its own image under its group symmetric while its anchors are dragged or nudged.
+  
+  Core gains what the package is built on, and each piece is usable on its own:
+  
+  - `ContainerNode.copiesFromPose`: a container draws its subtree again under each affine it returns. Hit tests reach into the copies, and the clip travels with each one. Additive.
+  - The `insertInto` dep: the container the `insert` dep puts new nodes into.
+  - The `pathSymmetry` dep: transforms that anchor drags and nudges keep a path symmetric under.
+  
+  `@weasel-js/geom` adds `anchorSymmetry`, `anchorSymmetries`, `translateAnchorsSymmetric`, and `moveHandleSymmetric`. `@weasel-js/svg` writes a container's copies as transformed groups.
+- bad37cf: `useSceneTextEdit` edits text where it is drawn. The overlay and the double-click test both read the pose a node is painted at, so text inside a container whose pose is a frame (`RIGID_POSE_COMPOSITION`) opens over the turned or skewed text and takes a click there; it used to open where the text would sit without the container. Under a view whose `scale.x` and `scale.y` differ, the overlay is stretched to match the canvas, where it used to scale both axes by `scale.x`.
+- 9e84e5d: Additive: `useTextEdit` and `useSceneTextEdit` take `onStart(id)` and `onEnd(id)`. `onStart` is called as an edit opens, whichever way it was started (`startEdit`, a double-click, the `textEdit` dep). `onEnd` is called as it closes, however it does: a commit, a cancel, Escape, a click away, or another edit opening over it, and after any commit has been written. Both are called from the call that changes the edit, not from an effect, so state that follows the edit is never a render behind it. Neither is called when the hook unmounts with an edit open.
+- ef29364: A scene slot's `toPose` is handed each node as the scene shows it: its `pose` is a pose override's or a derived one, where it used to be the stored pose. A view drawn through a `toPose` now shows a drag in flight, a rig's bound nodes, and a skinned path, whose override `path` is carried from the box the scene shows the node at into the box `toPose` answers. A dependency read through such a slot answers the carried path too, and so does one in a scene that composes frames. Breaking for a `toPose` that relied on seeing the document's pose mid-gesture; one that places a node from its data alone, ignoring `node.pose`, still shows no motion.
+- 2f48645: Cmd/Ctrl+D is now Transform Again: it repeats the last move, nudge, rotate, resize, duplicate, or Alt-drag clone on whatever is selected, as one undo entry. A rotate repeats about the new selection's center and a resize repeats as the same scale held at the same handle's opposite corner. Duplicating and then moving the copies makes the copies' offset the step, so pressing Cmd+D again lays down another copy one step further each time. With nothing to repeat it duplicates, as Cmd+D did before.
+  
+  Duplicate moves to Cmd/Ctrl+Shift+D. This changes a default binding: an app relying on Cmd+D to duplicate after a move now gets the move repeated.
+  
+  The kit keeps the last transform per scene: `lastTransform(scene)`, `recordTransform(scene, transform, selectedIds)`, and `forgetTransform(scene)`, with the `RepeatableTransform` type. The action is `transformAgain` in the standard actions and the `edit` feature preset, in the `edit` group with a new `TransformAgainIcon`.
+- 92c2e8e: `<SceneCanvas tune>` changes a built-in action on one canvas without restating it. Keyed by action id, an entry sets `params` every invocation starts from (a thunk is read on each call, so a value changed mid-drag reaches an ongoing action) and adds `bindings` beside the action's own. A binding's or a `trigger` call's own params are laid over the tuned ones. The tuning applies to whichever descriptor holds the id, from a preset or a tool, so setting a param no longer means copying the gesture that reaches the action. Additive: `ActionsRegistry.tune(id, tuning)` underneath it, `tuneAction`, the types `ActionTuning`, `ActionTunings`, `ActionParams` and `TunedBinding`, and `ActionParamSchema`, which types params by action id for the kit's parametric actions and takes an app's own entries by declaration merging, as `DepSchema` does. `BoundGesture` is no longer marked experimental.
+  
+  `SceneCanvasViewport` names the type of `<SceneCanvas viewport>`.
+- 711ae46: While a scene has an active journal (`getActiveJournal` / `setActiveJournalAccessor`), `scene.undo`, `scene.redo`, `canUndo`, and `canRedo` (and the same on `scene.history`) now step that journal, the same place `applyBatch` sends edits. Before, undo stepped the scene's own history and skipped the journal's edits entirely: the `undo` action took back whatever came before the journal opened instead of the edit just made. Once the journal is suspended, committed, or canceled, undo steps the scene's history again. `historyEntries`, `historyIndex`, and `jumpToHistoryIndex` still read the scene's own history.
+- 365eae0: A linear unit stores a decimal typed at a decimal `scale` as the decimal the two multiply to: 33.3 at a scale of 0.01 is 0.333, where it was 0.33299999999999996. Nothing is rounded away, and a scale that is no short decimal (degrees over radians) converts as before.
+  
+  The text tool's percent unit for `fontScale` and `baselineShift` is that data now (`{ scale: 0.01, precision: 1, suffix: '%' }`) and no longer a pair of functions, so the run properties print as a literal. Breaking in one detail: a percentage typed to more than three places is stored as typed, where it was cut to five places of the stored fraction.
+  
+  labkit's one-line summary of a compound leaf writes each number that has a unit as its field shows it, in an object's fields, a list's and a map's entries, and a union's variant, and writes a list of objects entry by entry where it wrote `[object Object]`. Additive: `summarizeLeaf(leaf, value)` is exported beside `summarizeValue`, and `inDialog`'s default summary is the leaf's.
+- 781a15e: A canvas's `clientToWorld` override reaches the views declared on it. Which `<CanvasView>` a client point is in, where it lands in that view's world, and the `pointer` dep's position over a view were all worked out from the element's bounding rect, so a canvas under a CSS transform routed a press to the wrong view or converted it wrong.
+  
+  Breaking, in the experimental view resolver: `createViewResolver` takes `toLocal(clientX, clientY)`, a client point in the canvas's own pixels, where it took `canvasOrigin`; and a `ViewTarget` carries `world`, the point in the resolved view's world, where it carried `origin`.
+- a092978: Zoom can be held to one axis. `viewport={{ zoom: { axis: 'x' } }}` makes the wheel, the trackpad pinch, and Cmd+=/- scale only x, leaving y's scale and translation alone; `pinchZoom: { axis }` does the same for a two-finger pinch, which still pans on both. `makeViewportZoomAction` and `makePinchZoomAction` take the same option, and `axisZoomFactor` and the `ZoomAxis` type are exported for a host calling `zoomAt` itself. Additive.
+- Updated dependencies [b6e04e2]
+- Updated dependencies [cbd5b4d]
+- Updated dependencies [aaa2b4f]
+- Updated dependencies [c7b7ed5]
+- Updated dependencies [3fda6e6]
+- Updated dependencies [906fd19]
+- Updated dependencies [7c5af8a]
+- Updated dependencies [ee59ccd]
+- Updated dependencies [789e80d]
+- Updated dependencies [924edc4]
+- Updated dependencies [b8bfb2d]
+- Updated dependencies [35c4879]
+- Updated dependencies [b67b6cd]
+- Updated dependencies [9eefcc7]
+- Updated dependencies [886380f]
+- Updated dependencies [0db6d9a]
+- Updated dependencies [d8b51a4]
+- Updated dependencies [10449af]
+- Updated dependencies [e05a5f9]
+- Updated dependencies [d30823f]
+- Updated dependencies [0be7a53]
+- Updated dependencies [b5267f9]
+- Updated dependencies [9253a8b]
+- Updated dependencies [62e766c]
+- Updated dependencies [f4100e9]
+- Updated dependencies [690ea72]
+- Updated dependencies [ab9ea7a]
+- Updated dependencies [e962494]
+- Updated dependencies [8a9ed26]
+- Updated dependencies [9e84e5d]
+- Updated dependencies [f5870a4]
+- Updated dependencies [bd6c203]
+- Updated dependencies [92c2e8e]
+- Updated dependencies [365eae0]
+- Updated dependencies [10c5d41]
+  - @weasel-js/prefs@1.10.1
+  - @weasel-js/geom@1.10.1
+  - @weasel-js/stroke@1.10.1
+  - @weasel-js/text@1.10.1
+  - @weasel-js/routing@1.10.1
+  - @weasel-js/animator@1.10.1
+  - @weasel-js/renderer@1.10.1
+  - @weasel-js/gestures@1.10.1
+  - @weasel-js/history@1.10.1
+  - @weasel-js/select@1.10.1
+  - @weasel-js/cursor@1.10.1
+  - @weasel-js/react@1.10.1
+  - @weasel-js/font@1.10.1
+  - @weasel-js/modes@1.10.1
+  - @weasel-js/paint@1.10.1
+  - @weasel-js/quantity@1.10.1
+  - @weasel-js/registry@1.10.1
+  - @weasel-js/simulation@1.10.1
+  - @weasel-js/text-dom@1.10.1
+
 ## 1.10.0
 
 ### Patch Changes

package/README.md

@@ -102,6 +102,39 @@ An `Action` is a named operation — `delete`, `duplicate`, `group`, `insert`, `
 
 `<SceneCanvas>` mounts a provider when none is above it and registers the kit-standard actions its `features` presets name — under `draw`, all of them: escape, select-all, delete, duplicate, group and ungroup, undo and redo, flip, nudge, reorder, align, distribute, the pathfinder booleans, path-anchor editing, fill and stroke, clipboard, and the pointer-driven move, resize, rotate, clone, area-select and lasso. `FEATURE_ACTION_IDS` lists which preset registers which, and `COMPOSITE_FEATURES` what `pick`, `transform` and `draw` abbreviate. `insert` comes with the shape tools that bind it.
 
+### Tuning an action
+
+`tune` changes a built-in action on one canvas without restating it. Each entry, keyed by action id, can carry:
+
+| Field | What it does |
+|---|---|
+| `params` | Params every invocation of the action starts from. Whatever a binding or a `trigger(id, params)` call passes is laid over them, so these fill in only what the call leaves out. A thunk is read on every call, so a value that changes mid-drag reaches an ongoing action the next time it reads its params. |
+| `bindings` | Gestures added beside the action's own `defaultBinding`, each a `GestureSpec` or `{ spec, opts: { params } }`. |
+
+A tuning applies to whichever descriptor holds the id, whether a preset or a tool registered it, and whether it registered before the tuning or after. Changing `params` never requires knowing what gesture reaches the action.
+
+```tsx
+const radius = useRef(8);
+const tune = useMemo<ActionTunings>(() => ({
+  brushDeleteAnchors: { params: () => ({ radiusPx: radius.current }) },
+  cycleCornerStyle: { bindings: [{ kind: 'key', key: 'k' }] },
+}), []);
+
+<SceneCanvas scene={scene} features={['paths']} tune={tune} />
+```
+
+`ActionParamSchema` types `params` for the kit actions that read them (`flip`, `align.*`, `distribute.*`, `reorder.*`, `nudge.*`, `tool.activate`); any other id takes a plain record. An action of your own declares its params the way `DepSchema` takes deps:
+
+```ts
+declare module '@weasel-js/core' {
+  interface ActionParamSchema { 'app.stamp': { size: number } }
+}
+```
+
+Pass `tune` a stable object — a module constant or a `useMemo` — since a new one re-applies every tuning. The registry underneath is `ActionsRegistry.tune(id, tuning)`, which returns its release.
+
+### Replacing actions (`@experimental`)
+
 ```tsx
 <SceneCanvas
   width={W}

package/dist/affordances/composeAffordanceLayer.js

@@ -2,30 +2,30 @@ import { viewToTransform as e } from "../core/viewport/view.js";
 import { worldToScreen as t } from "../core/viewport/viewTransform.js";
 import { angleOf as n, isRigid as r, localToWorld as i, pxExtentIn as a, targetCorners as o } from "../core/geometry/targetFrame.js";
 import { annulusSemiAxes as s, hitAffordanceRegions as c, pointRegionAnchor as l, pointRegionFrame as u, pointRegionScreenQuad as d, transformOf as f } from "./hitAffordanceRegions.js";
-import { PATH_L as p, PATH_M as m, PATH_Z as h } from "@weasel-js/geom";
+import { PATH_L as p, PATH_M as m, PATH_Z as h, boundsOfPath as g } from "@weasel-js/geom";
 //#region src/affordances/composeAffordanceLayer.ts
-function g(t, n, r) {
+function _(t, n, r) {
 	return {
 		id: t,
 		label: n,
 		space: "screen",
 		draw: (t, n, i) => {
-			let a = _(t), o = v(t), s = y(t), c = [], l = e(n);
+			let a = v(t), o = y(t), s = b(t), c = [], l = e(n);
 			for (let e of r) if (!s || s(e.id)) {
 				for (let t of e.regions(a)) {
 					let r = f(a, t.targetId);
-					t.paint && S(t, r, n, a, l, c), o && b(o, e.id, t, r, n);
+					t.paint && C(t, r, n, a, l, c), o && x(o, e.id, t, r, n);
 				}
 				if (e.decorate) for (let t of e.decorate(a, n)) c.push(t);
 			}
 			return c;
 		},
 		hitTest: (e, t, n, i, a, o) => {
-			let s = _(n);
+			let s = v(n);
 			if (!s) return null;
-			let l = c(r, e, t, s, i, o ?? y(n) ?? void 0);
+			let l = c(r, e, t, s, i, o ?? b(n) ?? void 0);
 			if (!l) return null;
-			let { cursor: u, strength: d, claimedKinds: f } = l.region;
+			let { cursor: u } = l, { strength: d, claimedKinds: f } = l.region;
 			return {
 				...l.binding,
 				...u === void 0 ? {} : { cursor: u },
@@ -35,19 +35,19 @@ function g(t, n, r) {
 		}
 	};
 }
-function _(e) {
+function v(e) {
 	let t = e;
 	return typeof t?.getChromeState == "function" ? t.getChromeState() : e;
 }
-function v(e) {
+function y(e) {
 	let t = e;
 	return typeof t?.getDebug == "function" ? t.getDebug() : null;
 }
-function y(e) {
+function b(e) {
 	let t = e;
 	return typeof t?.getIsVisible == "function" ? t.getIsVisible() : null;
 }
-function b(e, t, n, r, i) {
+function x(e, t, n, r, i) {
 	if (n.shape.kind === "point") {
 		let a = u(n.shape, r, i), o = d(n.shape, r, i, (e, t) => [e, t]);
 		e.recordHitbox(t, "handle", {
@@ -61,7 +61,7 @@ function b(e, t, n, r, i) {
 	}
 	if (n.shape.kind === "annulus") {
 		let a = n.shape, { rx: o, ry: c } = s(a, i, r);
-		x(e, t, r, {
+		S(e, t, r, {
 			x: a.cx - o,
 			y: a.cy - c,
 			width: 2 * o,
@@ -69,9 +69,9 @@ function b(e, t, n, r, i) {
 		});
 		return;
 	}
-	x(e, t, r, n.shape);
+	S(e, t, r, n.shape.kind === "outline" ? g(n.shape.path) : n.shape);
 }
-function x(e, t, a, s) {
+function S(e, t, a, s) {
 	if (!r(a)) {
 		e.recordHitbox(t, "handle", {
 			kind: "polygon",
@@ -89,7 +89,7 @@ function x(e, t, a, s) {
 		...a.identity ? {} : { rotation: n(a) }
 	});
 }
-function S(e, n, r, i, o, c) {
+function C(e, n, r, i, o, c) {
 	let l = e.paint;
 	if (l.kind === "square") {
 		if (e.shape.kind !== "point") return;
@@ -138,13 +138,13 @@ function S(e, n, r, i, o, c) {
 	}
 	if (l.kind === "annulus") {
 		if (e.shape.kind !== "annulus") return;
-		let t = e.shape, i = a(l.insetPx ?? 0, r.scale, n), u = C(t, s(t, r, n), i, n, o, l.fill, l.stroke);
+		let t = e.shape, i = a(l.insetPx ?? 0, r.scale, n), u = w(t, s(t, r, n), i, n, o, l.fill, l.stroke);
 		u && c.push(u);
 		return;
 	}
 	if (l.kind === "custom") {
 		let t = {
-			world: w(e, n, r),
+			world: T(e, n, r),
 			local: e.shape,
 			view: r,
 			state: i
@@ -153,7 +153,7 @@ function S(e, n, r, i, o, c) {
 		return;
 	}
 }
-function C(e, n, r, a, o, s, c) {
+function w(e, n, r, a, o, s, c) {
 	let l = n.rx - r.x, u = n.ry - r.y;
 	if (l <= 0 || u <= 0) return null;
 	let d = e.cx, f = e.cy, g = e.innerWidth / 2 + r.x, _ = e.innerHeight / 2 + r.y, v = _ < u, y = g < l;
@@ -191,7 +191,7 @@ function C(e, n, r, a, o, s, c) {
 		...c ? { stroke: c } : {}
 	};
 }
-function w(e, t, n) {
+function T(e, t, n) {
 	if (e.shape.kind === "point") {
 		let r = l(e.shape, t, n);
 		return {
@@ -208,7 +208,7 @@ function w(e, t, n) {
 			height: 2 * m
 		};
 	}
-	let r = e.shape, a = i(t, r.x, r.y), o = i(t, r.x + r.width, r.y), c = i(t, r.x, r.y + r.height), u = i(t, r.x + r.width, r.y + r.height), d = Math.min(a.x, o.x, c.x, u.x), f = Math.min(a.y, o.y, c.y, u.y), p = Math.max(a.x, o.x, c.x, u.x), m = Math.max(a.y, o.y, c.y, u.y);
+	let r = e.shape.kind === "outline" ? g(e.shape.path) : e.shape, a = i(t, r.x, r.y), o = i(t, r.x + r.width, r.y), c = i(t, r.x, r.y + r.height), u = i(t, r.x + r.width, r.y + r.height), d = Math.min(a.x, o.x, c.x, u.x), f = Math.min(a.y, o.y, c.y, u.y), p = Math.max(a.x, o.x, c.x, u.x), m = Math.max(a.y, o.y, c.y, u.y);
 	return {
 		x: d,
 		y: f,
@@ -217,6 +217,6 @@ function w(e, t, n) {
 	};
 }
 //#endregion
-export { g as composeAffordanceLayer };
+export { _ as composeAffordanceLayer };
 
 //# sourceMappingURL=composeAffordanceLayer.js.map

package/dist/affordances/composeAffordanceLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"composeAffordanceLayer.js","names":["composeAffordanceLayer","state","asChromeState","data","debug","asDebugSink","isVisible","asIsVisible","out","t","viewToTransform","view","a","affordances","region","xf","transformOf","paintRegion","recordRegionHitbox","cmd","hit","hitAffordanceRegions","wx","wy","cursor","strength","claimedKinds","maybe","f","pointRegionFrame","quad","pointRegionScreenQuad","x","y","affordanceId","q","s","annulusSemiAxes","rx","ry","recordLocalRect","isRigid","targetCorners","r","w","localToWorld","angleOf","paint","sx","sy","worldToScreen","viewT","half","fill","stroke","c","sn","coords","u","v","i","PATH_M","PATH_L","PATH_Z","insetLocal","pxExtentIn","annulusCommand","ctx","worldOf","semiAxes","cx","shape","cy","rectHW","rectHH","haveTopBottom","haveLeftRight","xT","yR","cmds","localPts","appendPetal","t0","t1","pointRegionAnchor","ma","mb","mc","md","hw","hh","b","d","minX","minY","maxX","maxY"],"sources":["../../src/affordances/composeAffordanceLayer.ts"],"sourcesContent":["import type { RenderLayer } from 'core/layers/render';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { isRigid, pxExtentIn, targetCorners } from 'core/geometry/targetFrame';\nimport type { DebugSink } from '../debug/types';\nimport type { CommandFill, CommandStroke } from '@weasel-js/paint';\nimport { PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';\nimport {\n  angleOf,\n  annulusSemiAxes,\n  hitAffordanceRegions,\n  localToWorld,\n  pointRegionAnchor,\n  pointRegionFrame,\n  pointRegionScreenQuad,\n  transformOf,\n  type TargetTransform,\n} from './hitAffordanceRegions';\nimport type {\n  Affordance,\n  AffordanceRegion,\n  CustomPaintContext,\n  LayerHit,\n} from './types';\n\n/**\n * @experimental\n * Bundle a list of Affordances into a single RenderLayer.\n *\n * Paint order matches array order (first → last = bottom → top). Hit-test walks affordances in\n * reverse and stops at the first that claims the point; within it the nearest region wins.\n *\n * `decorate(state, view)` runs *after* a given affordance's regions, for paint only.\n */\nexport function composeAffordanceLayer(\n  id: string,\n  label: string,\n  affordances: readonly Affordance[],\n): RenderLayer<ChromeState> & {\n  hitTest(\n    wx: number,\n    wy: number,\n    state: unknown,\n    view: View,\n    dims: { width: number; height: number },\n    isVisible?: (id: string) => boolean,\n  ): LayerHit | null;\n} {\n  return {\n    id,\n    label,\n    space: 'screen',\n    draw: (data, view, _dims): DrawCommand[] => {\n      const state = asChromeState(data);\n      const debug = asDebugSink(data);\n      const isVisible = asIsVisible(data);\n      const out: DrawCommand[] = [];\n      const t = viewToTransform(view);\n      for (const a of affordances) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(state)) {\n          const xf = transformOf(state, region.targetId);\n          if (region.paint) paintRegion(region, xf, view, state, t, out);\n          if (debug) recordRegionHitbox(debug, a.id, region, xf, view);\n        }\n        if (a.decorate) {\n          for (const cmd of a.decorate(state, view)) out.push(cmd);\n        }\n      }\n      return out;\n    },\n    // The walk lives in `hitAffordanceRegions` so this layer and `buildAffordanceAt` share one\n    // implementation. This wrapper lifts the region's declared cursor and claim onto the binding.\n    hitTest: (wx, wy, data, view, _dims, isVisible): LayerHit | null => {\n      const state = asChromeState(data);\n      if (!state) return null;\n      const hit = hitAffordanceRegions(\n        affordances, wx, wy, state, view, isVisible ?? asIsVisible(data) ?? undefined,\n      );\n      if (!hit) return null;\n      const { cursor, strength, claimedKinds } = hit.region;\n      return {\n        ...hit.binding,\n        ...(cursor !== undefined ? { cursor } : {}),\n        ...(strength !== undefined ? { strength } : {}),\n        ...(claimedKinds !== undefined ? { claimedKinds } : {}),\n      };\n    },\n  };\n}\n\n// `draw` is called by Canvas with `CanvasHelpers` and by tests with a bare `ChromeState`.\nfunction asChromeState(data: unknown): ChromeState {\n  const maybe = data as { getChromeState?: () => ChromeState };\n  if (typeof maybe?.getChromeState === 'function') return maybe.getChromeState();\n  return data as ChromeState;\n}\n\nfunction asDebugSink(data: unknown): DebugSink | null {\n  const maybe = data as { getDebug?: () => DebugSink | null };\n  if (typeof maybe?.getDebug === 'function') return maybe.getDebug();\n  return null;\n}\n\n/** The chrome-caps visibility predicate off the data envelope. When absent (tests passing\n *  bare state), every affordance renders. */\nfunction asIsVisible(data: unknown): ((id: string) => boolean) | null {\n  const maybe = data as { getIsVisible?: () => (id: string) => boolean };\n  if (typeof maybe?.getIsVisible === 'function') return maybe.getIsVisible();\n  return null;\n}\n\nfunction recordRegionHitbox(\n  debug: DebugSink,\n  affordanceId: string,\n  region: AffordanceRegion,\n  xf: TargetTransform,\n  view: View,\n): void {\n  if (region.shape.kind === 'point') {\n    // The hit square is a square on *screen* — turned with the target when the\n    // region asks — so in world it is a parallelogram, recorded as one.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const quad = pointRegionScreenQuad(region.shape, xf, view, (x, y) => [x, y]);\n    debug.recordHitbox(affordanceId, 'handle', {\n      kind: 'polygon',\n      points: quad.map((q) => ({\n        x: f.x + (q.x - f.x) / view.scale.x,\n        y: f.y + (q.y - f.y) / view.scale.y,\n      })),\n    });\n    return;\n  }\n  if (region.shape.kind === 'annulus') {\n    // Approximated as the outer ellipse's AABB: the DebugSink's hitbox primitives don't\n    // model ring shapes.\n    const s = region.shape;\n    const { rx, ry } = annulusSemiAxes(s, view, xf);\n    recordLocalRect(debug, affordanceId, xf, { x: s.cx - rx, y: s.cy - ry, width: 2 * rx, height: 2 * ry });\n    return;\n  }\n  recordLocalRect(debug, affordanceId, xf, region.shape);\n}\n\n/** A rect of the target's own frame as a debug hitbox: the unturned box plus\n *  the rotation while the frame only turns it, and the quad it lands on once\n *  the frame skews or stretches it. */\nfunction recordLocalRect(\n  debug: DebugSink,\n  affordanceId: string,\n  xf: TargetTransform,\n  r: { x: number; y: number; width: number; height: number },\n): void {\n  if (!isRigid(xf)) {\n    debug.recordHitbox(affordanceId, 'handle', { kind: 'polygon', points: targetCorners(r, xf) });\n    return;\n  }\n  const w = localToWorld(xf, r.x + r.width / 2, r.y + r.height / 2);\n  debug.recordHitbox(affordanceId, 'handle', {\n    kind: 'rect',\n    x: w.x - r.width / 2,\n    y: w.y - r.height / 2,\n    width: r.width,\n    height: r.height,\n    ...(xf.identity ? {} : { rotation: angleOf(xf) }),\n  });\n}\n\nfunction paintRegion(\n  region: AffordanceRegion,\n  xf: TargetTransform,\n  view: View,\n  state: ChromeState,\n  viewT: ReturnType<typeof viewToTransform>,\n  out: DrawCommand[],\n): void {\n  const paint = region.paint!;\n  if (paint.kind === 'square') {\n    if (region.shape.kind !== 'point') {\n      // 'square' only makes sense over a point shape.\n      return;\n    }\n    // Same frame the hit-test reads, at the paint's own size.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const [sx, sy] = worldToScreen(f.x, f.y, viewT);\n    const half = paint.sizePx / 2;\n    const fill = paint.fill ? { fill: paint.fill } : {};\n    const stroke = paint.stroke ? { stroke: paint.stroke } : {};\n    if (f.angle === 0) {\n      out.push({\n        kind: 'path',\n        path: { kind: 'rect', x: sx - half, y: sy - half, width: paint.sizePx, height: paint.sizePx },\n        ...fill, ...stroke,\n      });\n      return;\n    }\n    const c = Math.cos(f.angle) * half, sn = Math.sin(f.angle) * half;\n    const coords = new Float32Array(8);\n    [[-1, -1], [1, -1], [1, 1], [-1, 1]].forEach(([u, v], i) => {\n      coords[i * 2] = sx + c * u - sn * v;\n      coords[i * 2 + 1] = sy + sn * u + c * v;\n    });\n    out.push({\n      kind: 'path',\n      path: { kind: 'polygon', commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]), coords, fillRule: 'nonzero' },\n      ...fill, ...stroke,\n    });\n    return;\n  }\n  if (paint.kind === 'annulus') {\n    if (region.shape.kind !== 'annulus') return; // type mismatch — silent skip\n    const s = region.shape;\n    // The screen-px inset in target-local units, so it visually matches at any zoom.\n    const insetLocal = pxExtentIn(paint.insetPx ?? 0, view.scale, xf);\n    // Same `minBandPx` clamp the hit-test applies, so the ring you can see is\n    // the ring you can grab.\n    const cmd = annulusCommand(s, annulusSemiAxes(s, view, xf), insetLocal, xf, viewT, paint.fill, paint.stroke);\n    if (cmd) out.push(cmd);\n    return;\n  }\n  if (paint.kind === 'custom') {\n    const ctx: CustomPaintContext = {\n      world: worldOf(region, xf, view),\n      local: region.shape,\n      view,\n      state,\n    };\n    for (const cmd of paint.draw(ctx)) out.push(cmd);\n    return;\n  }\n}\n\n/** Build a screen-space DrawCommand for an annulus region: the area\n *  inside the (contracted) outer ellipse but outside the (expanded)\n *  inner rect. Renders as four disjoint petal subpaths — one per rect\n *  edge — so the visible fill is true `ellipse \\ rect`. A naive\n *  ellipse + rect even-odd path would also fill the rect's corner\n *  triangles where they poke past the contracted ellipse. Returns null\n *  when the band collapses on both axes. */\nfunction annulusCommand(\n  shape: Extract<AffordanceRegion['shape'], { kind: 'annulus' }>,\n  semiAxes: { rx: number; ry: number },\n  insetLocal: { x: number; y: number },\n  xf: TargetTransform,\n  viewT: ReturnType<typeof viewToTransform>,\n  fill: CommandFill | undefined,\n  stroke: CommandStroke | undefined,\n): DrawCommand | null {\n  const rx = semiAxes.rx - insetLocal.x;\n  const ry = semiAxes.ry - insetLocal.y;\n  if (rx <= 0 || ry <= 0) return null;\n  const cx = shape.cx;\n  const cy = shape.cy;\n  // Expanded inner rect (still in target-local coords).\n  const rectHW = shape.innerWidth / 2 + insetLocal.x;\n  const rectHH = shape.innerHeight / 2 + insetLocal.y;\n  // A petal exists only when its rect edge intersects the ellipse interior — otherwise the\n  // rect already extends past the ellipse on that axis.\n  const haveTopBottom = rectHH < ry;\n  const haveLeftRight = rectHW < rx;\n  if (!haveTopBottom && !haveLeftRight) return null;\n  const xT = haveTopBottom ? rx * Math.sqrt(1 - (rectHH / ry) ** 2) : 0;\n  const yR = haveLeftRight ? ry * Math.sqrt(1 - (rectHW / rx) ** 2) : 0;\n\n  // Line segments per petal arc; 24 is smooth at typical zooms.\n  const SAMPLES = 24;\n  const cmds: number[] = [];\n  const localPts: { x: number; y: number }[] = [];\n\n  function appendPetal(t0: number, t1: number): void {\n    cmds.push(PATH_M);\n    localPts.push({ x: cx + rx * Math.cos(t0), y: cy + ry * Math.sin(t0) });\n    for (let i = 1; i <= SAMPLES; i++) {\n      const t = t0 + (t1 - t0) * (i / SAMPLES);\n      cmds.push(PATH_L);\n      localPts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });\n    }\n    // PATH_Z closes along the rect edge: both endpoints share the rect-edge coord by\n    // construction, so the closing segment IS the chord.\n    cmds.push(PATH_Z);\n  }\n\n  if (haveTopBottom) {\n    // Top petal: y < cy. Arc from right endpoint over t = -π/2 to left.\n    appendPetal(\n      Math.atan2(-rectHH / ry, xT / rx),   // in (-π/2, 0)\n      Math.atan2(-rectHH / ry, -xT / rx),  // in (-π, -π/2), decreasing through -π/2\n    );\n    // Bottom petal: y > cy. Arc through t = +π/2.\n    appendPetal(\n      Math.atan2(rectHH / ry, xT / rx),    // in (0, π/2)\n      Math.atan2(rectHH / ry, -xT / rx),   // in (π/2, π), increasing through π/2\n    );\n  }\n  if (haveLeftRight) {\n    // Right petal: x > cx. Arc through t = 0.\n    appendPetal(\n      Math.atan2(-yR / ry, rectHW / rx),   // in (-π/2, 0)\n      Math.atan2(yR / ry, rectHW / rx),    // in (0, π/2)\n    );\n    // Left petal: x < cx. Arc through t = ±π. Shift the end angle by\n    // -2π so the parametric trace passes through the leftmost point\n    // monotonically instead of crossing the right side.\n    appendPetal(\n      Math.atan2(-yR / ry, -rectHW / rx),                  // in (-π, -π/2)\n      Math.atan2(yR / ry, -rectHW / rx) - 2 * Math.PI,     // in (-3π/2, -π), decreasing through -π\n    );\n  }\n\n  const coords = new Float32Array(localPts.length * 2);\n  for (let i = 0; i < localPts.length; i++) {\n    const w = localToWorld(xf, localPts[i].x, localPts[i].y);\n    const [sx, sy] = worldToScreen(w.x, w.y, viewT);\n    coords[i * 2] = sx;\n    coords[i * 2 + 1] = sy;\n  }\n  return {\n    kind: 'path',\n    path: { kind: 'polygon', commands: new Uint8Array(cmds), coords, fillRule: 'nonzero' },\n    ...(fill ? { fill } : {}),\n    ...(stroke ? { stroke } : {}),\n  };\n}\n\nfunction worldOf(region: AffordanceRegion, xf: TargetTransform, view: View): CustomPaintContext['world'] {\n  if (region.shape.kind === 'point') {\n    const w = pointRegionAnchor(region.shape, xf, view);\n    return { x: w.x, y: w.y };\n  }\n  if (region.shape.kind === 'annulus') {\n    // The outer ellipse's bounding box in world coords: each half-extent is\n    // the length of that row of the frame applied to the semi-axes.\n    const s = region.shape;\n    const { rx, ry } = annulusSemiAxes(s, view, xf);\n    const c = localToWorld(xf, s.cx, s.cy);\n    const [ma, mb, mc, md] = xf.toWorld;\n    const hw = Math.hypot(rx * ma, ry * mc);\n    const hh = Math.hypot(rx * mb, ry * md);\n    return { x: c.x - hw, y: c.y - hh, width: 2 * hw, height: 2 * hh };\n  }\n  // Rect: under rotation, width/height describe the AABB of the rotated rect. Affordances\n  // needing exact rotated geometry can read `local` and reapply the rotation themselves.\n  const r = region.shape;\n  const a = localToWorld(xf, r.x, r.y);\n  const b = localToWorld(xf, r.x + r.width, r.y);\n  const c = localToWorld(xf, r.x, r.y + r.height);\n  const d = localToWorld(xf, r.x + r.width, r.y + r.height);\n  const minX = Math.min(a.x, b.x, c.x, d.x);\n  const minY = Math.min(a.y, b.y, c.y, d.y);\n  const maxX = Math.max(a.x, b.x, c.x, d.x);\n  const maxY = Math.max(a.y, b.y, c.y, d.y);\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n// Hit-testing lives in `hitAffordanceRegions.ts` — see `hitRegion` there.\n"],"mappings":"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"}
+{"version":3,"file":"composeAffordanceLayer.js","names":["composeAffordanceLayer","state","asChromeState","data","debug","asDebugSink","isVisible","asIsVisible","out","t","viewToTransform","view","a","affordances","region","xf","transformOf","paintRegion","recordRegionHitbox","cmd","hit","hitAffordanceRegions","wx","wy","cursor","strength","claimedKinds","maybe","f","pointRegionFrame","quad","pointRegionScreenQuad","x","y","affordanceId","q","s","annulusSemiAxes","rx","ry","boundsOfPath","recordLocalRect","isRigid","targetCorners","r","w","localToWorld","angleOf","paint","sx","sy","worldToScreen","viewT","half","fill","stroke","c","sn","coords","u","v","i","PATH_M","PATH_L","PATH_Z","insetLocal","pxExtentIn","annulusCommand","ctx","worldOf","semiAxes","cx","shape","cy","rectHW","rectHH","haveTopBottom","haveLeftRight","xT","yR","cmds","localPts","appendPetal","t0","t1","pointRegionAnchor","ma","mb","mc","md","hw","hh","b","d","minX","minY","maxX","maxY"],"sources":["../../src/affordances/composeAffordanceLayer.ts"],"sourcesContent":["import type { RenderLayer } from 'core/layers/render';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { isRigid, pxExtentIn, targetCorners } from 'core/geometry/targetFrame';\nimport type { DebugSink } from '../debug/types';\nimport type { CommandFill, CommandStroke } from '@weasel-js/paint';\nimport { boundsOfPath, PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';\nimport {\n  angleOf,\n  annulusSemiAxes,\n  hitAffordanceRegions,\n  localToWorld,\n  pointRegionAnchor,\n  pointRegionFrame,\n  pointRegionScreenQuad,\n  transformOf,\n  type TargetTransform,\n} from './hitAffordanceRegions';\nimport type {\n  Affordance,\n  AffordanceRegion,\n  CustomPaintContext,\n  LayerHit,\n} from './types';\n\n/**\n * @experimental\n * Bundle a list of Affordances into a single RenderLayer.\n *\n * Paint order matches array order (first → last = bottom → top). Hit-test walks affordances in\n * reverse and stops at the first that claims the point; within it the nearest region wins.\n *\n * `decorate(state, view)` runs *after* a given affordance's regions, for paint only.\n */\nexport function composeAffordanceLayer(\n  id: string,\n  label: string,\n  affordances: readonly Affordance[],\n): RenderLayer<ChromeState> & {\n  hitTest(\n    wx: number,\n    wy: number,\n    state: unknown,\n    view: View,\n    dims: { width: number; height: number },\n    isVisible?: (id: string) => boolean,\n  ): LayerHit | null;\n} {\n  return {\n    id,\n    label,\n    space: 'screen',\n    draw: (data, view, _dims): DrawCommand[] => {\n      const state = asChromeState(data);\n      const debug = asDebugSink(data);\n      const isVisible = asIsVisible(data);\n      const out: DrawCommand[] = [];\n      const t = viewToTransform(view);\n      for (const a of affordances) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(state)) {\n          const xf = transformOf(state, region.targetId);\n          if (region.paint) paintRegion(region, xf, view, state, t, out);\n          if (debug) recordRegionHitbox(debug, a.id, region, xf, view);\n        }\n        if (a.decorate) {\n          for (const cmd of a.decorate(state, view)) out.push(cmd);\n        }\n      }\n      return out;\n    },\n    // The walk lives in `hitAffordanceRegions` so this layer and `buildAffordanceAt` share one\n    // implementation. This wrapper lifts the region's declared cursor and claim onto the binding.\n    hitTest: (wx, wy, data, view, _dims, isVisible): LayerHit | null => {\n      const state = asChromeState(data);\n      if (!state) return null;\n      const hit = hitAffordanceRegions(\n        affordances, wx, wy, state, view, isVisible ?? asIsVisible(data) ?? undefined,\n      );\n      if (!hit) return null;\n      const { cursor } = hit;\n      const { strength, claimedKinds } = hit.region;\n      return {\n        ...hit.binding,\n        ...(cursor !== undefined ? { cursor } : {}),\n        ...(strength !== undefined ? { strength } : {}),\n        ...(claimedKinds !== undefined ? { claimedKinds } : {}),\n      };\n    },\n  };\n}\n\n// `draw` is called by Canvas with `CanvasHelpers` and by tests with a bare `ChromeState`.\nfunction asChromeState(data: unknown): ChromeState {\n  const maybe = data as { getChromeState?: () => ChromeState };\n  if (typeof maybe?.getChromeState === 'function') return maybe.getChromeState();\n  return data as ChromeState;\n}\n\nfunction asDebugSink(data: unknown): DebugSink | null {\n  const maybe = data as { getDebug?: () => DebugSink | null };\n  if (typeof maybe?.getDebug === 'function') return maybe.getDebug();\n  return null;\n}\n\n/** The chrome-caps visibility predicate off the data envelope. When absent (tests passing\n *  bare state), every affordance renders. */\nfunction asIsVisible(data: unknown): ((id: string) => boolean) | null {\n  const maybe = data as { getIsVisible?: () => (id: string) => boolean };\n  if (typeof maybe?.getIsVisible === 'function') return maybe.getIsVisible();\n  return null;\n}\n\nfunction recordRegionHitbox(\n  debug: DebugSink,\n  affordanceId: string,\n  region: AffordanceRegion,\n  xf: TargetTransform,\n  view: View,\n): void {\n  if (region.shape.kind === 'point') {\n    // The hit square is a square on *screen* — turned with the target when the\n    // region asks — so in world it is a parallelogram, recorded as one.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const quad = pointRegionScreenQuad(region.shape, xf, view, (x, y) => [x, y]);\n    debug.recordHitbox(affordanceId, 'handle', {\n      kind: 'polygon',\n      points: quad.map((q) => ({\n        x: f.x + (q.x - f.x) / view.scale.x,\n        y: f.y + (q.y - f.y) / view.scale.y,\n      })),\n    });\n    return;\n  }\n  if (region.shape.kind === 'annulus') {\n    // Approximated as the outer ellipse's AABB: the DebugSink's hitbox primitives don't\n    // model ring shapes.\n    const s = region.shape;\n    const { rx, ry } = annulusSemiAxes(s, view, xf);\n    recordLocalRect(debug, affordanceId, xf, { x: s.cx - rx, y: s.cy - ry, width: 2 * rx, height: 2 * ry });\n    return;\n  }\n  const box = region.shape.kind === 'outline' ? boundsOfPath(region.shape.path) : region.shape;\n  recordLocalRect(debug, affordanceId, xf, box);\n}\n\n/** A rect of the target's own frame as a debug hitbox: the unturned box plus\n *  the rotation while the frame only turns it, and the quad it lands on once\n *  the frame skews or stretches it. */\nfunction recordLocalRect(\n  debug: DebugSink,\n  affordanceId: string,\n  xf: TargetTransform,\n  r: { x: number; y: number; width: number; height: number },\n): void {\n  if (!isRigid(xf)) {\n    debug.recordHitbox(affordanceId, 'handle', { kind: 'polygon', points: targetCorners(r, xf) });\n    return;\n  }\n  const w = localToWorld(xf, r.x + r.width / 2, r.y + r.height / 2);\n  debug.recordHitbox(affordanceId, 'handle', {\n    kind: 'rect',\n    x: w.x - r.width / 2,\n    y: w.y - r.height / 2,\n    width: r.width,\n    height: r.height,\n    ...(xf.identity ? {} : { rotation: angleOf(xf) }),\n  });\n}\n\nfunction paintRegion(\n  region: AffordanceRegion,\n  xf: TargetTransform,\n  view: View,\n  state: ChromeState,\n  viewT: ReturnType<typeof viewToTransform>,\n  out: DrawCommand[],\n): void {\n  const paint = region.paint!;\n  if (paint.kind === 'square') {\n    if (region.shape.kind !== 'point') {\n      // 'square' only makes sense over a point shape.\n      return;\n    }\n    // Same frame the hit-test reads, at the paint's own size.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const [sx, sy] = worldToScreen(f.x, f.y, viewT);\n    const half = paint.sizePx / 2;\n    const fill = paint.fill ? { fill: paint.fill } : {};\n    const stroke = paint.stroke ? { stroke: paint.stroke } : {};\n    if (f.angle === 0) {\n      out.push({\n        kind: 'path',\n        path: { kind: 'rect', x: sx - half, y: sy - half, width: paint.sizePx, height: paint.sizePx },\n        ...fill, ...stroke,\n      });\n      return;\n    }\n    const c = Math.cos(f.angle) * half, sn = Math.sin(f.angle) * half;\n    const coords = new Float32Array(8);\n    [[-1, -1], [1, -1], [1, 1], [-1, 1]].forEach(([u, v], i) => {\n      coords[i * 2] = sx + c * u - sn * v;\n      coords[i * 2 + 1] = sy + sn * u + c * v;\n    });\n    out.push({\n      kind: 'path',\n      path: { kind: 'polygon', commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]), coords, fillRule: 'nonzero' },\n      ...fill, ...stroke,\n    });\n    return;\n  }\n  if (paint.kind === 'annulus') {\n    if (region.shape.kind !== 'annulus') return; // type mismatch — silent skip\n    const s = region.shape;\n    // The screen-px inset in target-local units, so it visually matches at any zoom.\n    const insetLocal = pxExtentIn(paint.insetPx ?? 0, view.scale, xf);\n    // Same `minBandPx` clamp the hit-test applies, so the ring you can see is\n    // the ring you can grab.\n    const cmd = annulusCommand(s, annulusSemiAxes(s, view, xf), insetLocal, xf, viewT, paint.fill, paint.stroke);\n    if (cmd) out.push(cmd);\n    return;\n  }\n  if (paint.kind === 'custom') {\n    const ctx: CustomPaintContext = {\n      world: worldOf(region, xf, view),\n      local: region.shape,\n      view,\n      state,\n    };\n    for (const cmd of paint.draw(ctx)) out.push(cmd);\n    return;\n  }\n}\n\n/** Build a screen-space DrawCommand for an annulus region: the area\n *  inside the (contracted) outer ellipse but outside the (expanded)\n *  inner rect. Renders as four disjoint petal subpaths — one per rect\n *  edge — so the visible fill is true `ellipse \\ rect`. A naive\n *  ellipse + rect even-odd path would also fill the rect's corner\n *  triangles where they poke past the contracted ellipse. Returns null\n *  when the band collapses on both axes. */\nfunction annulusCommand(\n  shape: Extract<AffordanceRegion['shape'], { kind: 'annulus' }>,\n  semiAxes: { rx: number; ry: number },\n  insetLocal: { x: number; y: number },\n  xf: TargetTransform,\n  viewT: ReturnType<typeof viewToTransform>,\n  fill: CommandFill | undefined,\n  stroke: CommandStroke | undefined,\n): DrawCommand | null {\n  const rx = semiAxes.rx - insetLocal.x;\n  const ry = semiAxes.ry - insetLocal.y;\n  if (rx <= 0 || ry <= 0) return null;\n  const cx = shape.cx;\n  const cy = shape.cy;\n  // Expanded inner rect (still in target-local coords).\n  const rectHW = shape.innerWidth / 2 + insetLocal.x;\n  const rectHH = shape.innerHeight / 2 + insetLocal.y;\n  // A petal exists only when its rect edge intersects the ellipse interior — otherwise the\n  // rect already extends past the ellipse on that axis.\n  const haveTopBottom = rectHH < ry;\n  const haveLeftRight = rectHW < rx;\n  if (!haveTopBottom && !haveLeftRight) return null;\n  const xT = haveTopBottom ? rx * Math.sqrt(1 - (rectHH / ry) ** 2) : 0;\n  const yR = haveLeftRight ? ry * Math.sqrt(1 - (rectHW / rx) ** 2) : 0;\n\n  // Line segments per petal arc; 24 is smooth at typical zooms.\n  const SAMPLES = 24;\n  const cmds: number[] = [];\n  const localPts: { x: number; y: number }[] = [];\n\n  function appendPetal(t0: number, t1: number): void {\n    cmds.push(PATH_M);\n    localPts.push({ x: cx + rx * Math.cos(t0), y: cy + ry * Math.sin(t0) });\n    for (let i = 1; i <= SAMPLES; i++) {\n      const t = t0 + (t1 - t0) * (i / SAMPLES);\n      cmds.push(PATH_L);\n      localPts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });\n    }\n    // PATH_Z closes along the rect edge: both endpoints share the rect-edge coord by\n    // construction, so the closing segment IS the chord.\n    cmds.push(PATH_Z);\n  }\n\n  if (haveTopBottom) {\n    // Top petal: y < cy. Arc from right endpoint over t = -π/2 to left.\n    appendPetal(\n      Math.atan2(-rectHH / ry, xT / rx),   // in (-π/2, 0)\n      Math.atan2(-rectHH / ry, -xT / rx),  // in (-π, -π/2), decreasing through -π/2\n    );\n    // Bottom petal: y > cy. Arc through t = +π/2.\n    appendPetal(\n      Math.atan2(rectHH / ry, xT / rx),    // in (0, π/2)\n      Math.atan2(rectHH / ry, -xT / rx),   // in (π/2, π), increasing through π/2\n    );\n  }\n  if (haveLeftRight) {\n    // Right petal: x > cx. Arc through t = 0.\n    appendPetal(\n      Math.atan2(-yR / ry, rectHW / rx),   // in (-π/2, 0)\n      Math.atan2(yR / ry, rectHW / rx),    // in (0, π/2)\n    );\n    // Left petal: x < cx. Arc through t = ±π. Shift the end angle by\n    // -2π so the parametric trace passes through the leftmost point\n    // monotonically instead of crossing the right side.\n    appendPetal(\n      Math.atan2(-yR / ry, -rectHW / rx),                  // in (-π, -π/2)\n      Math.atan2(yR / ry, -rectHW / rx) - 2 * Math.PI,     // in (-3π/2, -π), decreasing through -π\n    );\n  }\n\n  const coords = new Float32Array(localPts.length * 2);\n  for (let i = 0; i < localPts.length; i++) {\n    const w = localToWorld(xf, localPts[i].x, localPts[i].y);\n    const [sx, sy] = worldToScreen(w.x, w.y, viewT);\n    coords[i * 2] = sx;\n    coords[i * 2 + 1] = sy;\n  }\n  return {\n    kind: 'path',\n    path: { kind: 'polygon', commands: new Uint8Array(cmds), coords, fillRule: 'nonzero' },\n    ...(fill ? { fill } : {}),\n    ...(stroke ? { stroke } : {}),\n  };\n}\n\nfunction worldOf(region: AffordanceRegion, xf: TargetTransform, view: View): CustomPaintContext['world'] {\n  if (region.shape.kind === 'point') {\n    const w = pointRegionAnchor(region.shape, xf, view);\n    return { x: w.x, y: w.y };\n  }\n  if (region.shape.kind === 'annulus') {\n    // The outer ellipse's bounding box in world coords: each half-extent is\n    // the length of that row of the frame applied to the semi-axes.\n    const s = region.shape;\n    const { rx, ry } = annulusSemiAxes(s, view, xf);\n    const c = localToWorld(xf, s.cx, s.cy);\n    const [ma, mb, mc, md] = xf.toWorld;\n    const hw = Math.hypot(rx * ma, ry * mc);\n    const hh = Math.hypot(rx * mb, ry * md);\n    return { x: c.x - hw, y: c.y - hh, width: 2 * hw, height: 2 * hh };\n  }\n  // Rect: under rotation, width/height describe the AABB of the rotated rect. Affordances\n  // needing exact rotated geometry can read `local` and reapply the rotation themselves.\n  const r = region.shape.kind === 'outline' ? boundsOfPath(region.shape.path) : region.shape;\n  const a = localToWorld(xf, r.x, r.y);\n  const b = localToWorld(xf, r.x + r.width, r.y);\n  const c = localToWorld(xf, r.x, r.y + r.height);\n  const d = localToWorld(xf, r.x + r.width, r.y + r.height);\n  const minX = Math.min(a.x, b.x, c.x, d.x);\n  const minY = Math.min(a.y, b.y, c.y, d.y);\n  const maxX = Math.max(a.x, b.x, c.x, d.x);\n  const maxY = Math.max(a.y, b.y, c.y, d.y);\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n// Hit-testing lives in `hitAffordanceRegions.ts` — see `hitRegion` there.\n"],"mappings":"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"}