@weasel-js/core 1.9.4 → 1.10.1

package/dist/{types-k-5Oqh-U.d.ts → types-DBbbCy0i.d.ts}

@@ -1,6 +1,8 @@
 import { Op } from '@weasel-js/history';
-import { Path } from '@weasel-js/geom';
+import { Rect, Path } from '@weasel-js/geom';
 import { View } from '@weasel-js/routing';
+import { P as PoseDescriptor } from './poseDescriptor-Bqk-11Rl.js';
+import { Target } from '@weasel-js/animator';
 
 /** One value for both axes, or a separate value per axis. */
 type ScalarOrXY = number | {
@@ -66,12 +68,6 @@ declare function fromPlane(m: PlaneMap, p: {
     x: number;
     y: number;
 };
-interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
 /** A camera-world rect in the plane's world. The map is axis-aligned, so a
  *  rect stays a rect; a flipped axis is normalized back to a positive size. */
 declare function rectToPlane<R extends Rect>(m: PlaneMap, r: R): R;
@@ -109,11 +105,9 @@ interface DropTarget<TPose> {
         y: number;
     };
     /** Optional axis-aligned region (world units) used by region-aware snaps
-     *  (e.g. `containedThenNearest`). When present, a pointer inside this rect
-     *  is treated as a containment hit on this target. Strategies that emit
-     *  region-shaped targets (gutters, drop-zones) should populate this.
-     *  Strategies whose targets are point-like (free-form, snap-point) can omit
-     *  it and rely on `origin`-distance snaps. */
+     *  (e.g. `containedThenNearest`): a pointer inside this rect is a
+     *  containment hit on this target. A point-like target can omit it and
+     *  rely on `origin`-distance snaps. */
     hitBounds?: {
         x: number;
         y: number;
@@ -153,16 +147,12 @@ type DropRegion = Path | ((point: {
 type LayoutDropTargetMode = 'innermost' | 'topmost' | 'region';
 /**
  * Carries a layout's sibling reflow to its targets over time rather than in
- * one frame. `moveAction` hands every sibling a drag displaces to `glide`
- * instead of snapping it, and `settle`s each one when it stops reflowing or
- * the gesture ends; the dragged nodes themselves settle from where they were
- * let go, and a node grabbed mid-glide is held where it is shown and dragged
- * from there. What the node shows meanwhile is published through the
- * scene's pose overrides; the document is never written.
- *
- * The scene's own reflows — the arrangement it re-applies after an insert,
- * delete, reorder or resize inside a laid-out container — are `settle`d from
- * the pose each child had before.
+ * one frame. A drag `glide`s every sibling it displaces and `settle`s each
+ * one when it stops reflowing or the gesture ends; the scene's own reflows
+ * (after an insert, delete, reorder, or resize inside a laid-out container)
+ * are `settle`d from the pose each child had before. What a node shows
+ * meanwhile is published through the scene's pose overrides; the document is
+ * never written.
  *
  * `useAnimatedReflow` builds one over the animator. Supply it through
  * `<SceneCanvas reflowTransition>` or `LayoutDep.reflow`.
@@ -218,12 +208,11 @@ interface LayoutDragged<TPose> {
  * How a container arranges its children, and what happens when one is dragged
  * into or around it.
  *
- * Declared on a container node (`ContainerNode.layout`). The four required
- * methods cover the whole cycle: `childPoses` is the resting arrangement,
- * which the scene re-applies whenever the container's children or size
- * change, `getDropTargets` enumerates where a drag could land,
- * `reflowPoses` is the live preview once a target is picked, and `commitDrop`
- * turns the result into ops so the drop is undoable.
+ * Declared on a container node (`ContainerNode.layout`). `childPoses` is the
+ * resting arrangement, which the scene re-applies whenever the container's
+ * children or size change, `getDropTargets` enumerates where a drag could
+ * land, `reflowPoses` is the live preview once a target is picked, and
+ * `commitDrop` turns the result into ops so the drop is undoable.
  */
 interface LayoutStrategy<TPose> {
     childPoses(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>): Map<string, TPose>;
@@ -231,11 +220,9 @@ interface LayoutStrategy<TPose> {
     reflowPoses(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, dragged: LayoutDragged<TPose>, target: DropTarget<TPose> | null): Map<string, TPose>;
     commitDrop(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, dragged: LayoutDragged<TPose>, target: DropTarget<TPose> | null): Op[];
     snap: LayoutSnap<TPose>;
-    /** Optional: predicate for whether a world-space point is inside this
-     *  container. When absent, callers fall back to an axis-aligned bounding-box
-     *  test on the container's pose. Strategies whose containers aren't
-     *  rectangular (circles, irregular zones) implement this to override the
-     *  AABB default. */
+    /** Optional: whether a world-space point is inside this container, for
+     *  containers that aren't rectangular. When absent, callers fall back to an
+     *  axis-aligned bounding-box test on the container's pose. */
     contains?(containerPose: TPose, point: {
         x: number;
         y: number;
@@ -246,8 +233,7 @@ interface LayoutStrategy<TPose> {
      *  past it — and it is what makes the container a candidate at all under
      *  `LayoutDropTargetMode` `'region'`. `null` or absent keeps the body. */
     dropRegion?(container: LayoutContainer): DropRegion | null;
-    /** Optional: reject a drag before any drop-target work happens. A type-aware
-     *  container (a palette that only takes swatches, say) returns `false` and
+    /** Optional: reject a drag before any drop-target work happens. On `false`
      *  the drag falls through to whatever container is under it next. When
      *  absent, every drag is considered — rejection is still possible later, by
      *  `snap.pickTarget` returning null. */
@@ -260,19 +246,15 @@ interface LayoutStrategy<TPose> {
      *  that finds no target. A drag onto the container arrives here too, after
      *  `commitDrop` has placed it, so a strategy leaves a child that already
      *  sits where it belongs alone. Absent, `childPoses` arranges them like
-     *  any other change to the container's children. Applied by the scene's
-     *  layout pass — for a layout the container declares, or one
-     *  `<SceneCanvas layouts>` / `useLayoutArrivals` installs. */
+     *  any other change to the container's children. */
     arrive?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, arrivals: ReadonlySet<string>): LayoutArrival<TPose> | null;
     /** Optional: rearrange a container that children left by an edit — a
      *  delete, or a reparent or drag out of it. `children` is what stays, in
      *  world poses, still where they were; `departed` is who went, so
-     *  `children.length + departed.size` is how many it held before. A
-     *  container that sizes itself to its children shrinks here, from the pitch
-     *  it had at that count. The edit's arrivals are placed afterward, by
-     *  `arrive`, or with `childPoses` when there is none. Absent, `childPoses`
-     *  arranges what stays like any other change. Applied by the scene's layout
-     *  pass, in the same undo step as the departure. */
+     *  `children.length + departed.size` is how many it held before. The
+     *  edit's arrivals are placed afterward, by `arrive`, or with `childPoses`
+     *  when there is none. Absent, `childPoses` arranges what stays like any
+     *  other change. Applied in the same undo step as the departure. */
     depart?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, departed: ReadonlySet<string>): LayoutArrival<TPose>;
     /** Optional: the world region the arrangement of `children` covers. Larger
      *  than `container.bounds` when children sit past it — a grid whose
@@ -294,12 +276,8 @@ interface LayoutStrategy<TPose> {
 }
 
 /**
- * Opaque clipboard payload. `items` is `unknown[]` so each app's clipboard
- * adapter stores whatever shape it wants; the kit never inspects entries.
- *
- * The adapter is responsible for both producing snapshots
- * (`snapshotSelection`) and consuming them (`commitPaste`). Type safety lives
- * at that boundary, not in the kit.
+ * Opaque clipboard payload: the kit never inspects entries. The adapter both
+ * produces snapshots (`snapshotSelection`) and consumes them (`commitPaste`).
  */
 interface ClipboardSnapshot {
     items: unknown[];
@@ -330,11 +308,9 @@ interface PasteCtx {
     onOmit?: (omission: PasteOmission) => void;
 }
 /**
- * SnapTarget — where a dragged node would re-parent to if released.
- *
- * `slotPose` is the pose (in world coordinates) the node should snap to
- * within the target. `metadata` is an opaque pass-through for app-specific
- * snap details (slot index, visual hint, etc.).
+ * Where a dragged node would re-parent to if released. `slotPose` is the pose
+ * (in world coordinates) the node should snap to within the target;
+ * `metadata` is an opaque pass-through for app-specific snap details.
  */
 interface SnapTarget<TPose = unknown> {
     parentId: string;
@@ -342,59 +318,28 @@ interface SnapTarget<TPose = unknown> {
     metadata?: unknown;
 }
 /**
- * Full scene adapter. Most consumers implement narrow per-hook subsets
- * (MoveAdapter, ResizeAdapter, ClipboardAdapter, ...) — TypeScript's
- * structural typing means a wider adapter satisfies any narrower interface.
+ * The contracts below are slices: each names what one reader asks of an
+ * adapter. The whole of it, as the kit builds it over a `Scene`, is
+ * `SceneCanvasAdapter` (`sceneToAdapter`).
  *
  * **Pose semantics:** `getPose` / `setPose` work in **local** coordinates —
  * relative to the node's direct parent (or world, for root-parented nodes).
- * `getWorldPose` is the composed reading, and is what the render walk, picking
- * and chrome consume. For the common axis-aligned rect pose, `composeRectPose`
- * (translation only) and `composeRigidPose` (a container's pose is a frame, so
- * its rotation reaches its children) ship as the two canonical strategies.
- */
-interface SceneAdapter<TNode extends {
-    id: string;
-}, TPose> {
-    getNodes(): TNode[];
-    getNode(id: string): TNode | undefined;
-    getSelection(): string[];
-    hitTest(worldX: number, worldY: number): string | null;
-    getPose(id: string): TPose;
-    /** The node's pose in world coordinates, with every ancestor's frame folded
-     *  in. Equal to `getPose` under the absolute-pose model; anything reasoning
-     *  about where a node actually is — picking, chrome, snapping, export —
-     *  wants this rather than `getPose`. */
-    getWorldPose?(id: string): TPose;
-    getParent(id: string): string | null;
-    setPose(id: string, pose: TPose): void;
-    setParent(id: string, parentId: string | null): void;
-    /** `index` is the node's z-position among its siblings. `createDeleteOp`
-     *  captures it and `invert()` forwards it, so an implementation that drops
-     *  it makes undo of a delete restore the node at the top instead of where
-     *  it was. Treat it as required-if-you-have-order; omit only for an
-     *  unordered store. */
-    insertNode(node: TNode, index?: number): void;
-    removeNode(id: string): void;
-    setSelection(ids: string[]): void;
-    applyOps?(ops: Op[], label?: string): void;
-}
-/**
- * Narrow adapter for `useMove`. Includes optional snap-target
- * lookup; apps without container-snapping leave it out.
+ * `getWorldPose`, where an adapter has it, is the composed reading.
+ *
+ * **Every adapter carries the tree:** `getNode`, `getParent`, and
+ * `getChildren`. A list with no nesting is a tree whose nodes are all roots:
+ * `getParent` answers `null` and `getChildren(null)` answers every id,
+ * bottom first.
  */
+/** Narrow adapter for move. Apps without container-snapping leave out `findSnapTarget`. */
 interface MoveAdapter<TNode extends {
     id: string;
 }, TPose> {
     getNode(id: string): TNode | undefined;
-    /** Enumerate all nodes. `<Canvas>` derives a default rect-pose `pickEvery`
-     *  and the scene-iteration loop from this. */
     getNodes(): TNode[];
     getPose(id: string): TPose;
-    /** Optional. Required only by hierarchy-aware paths: layout-pass drop
-     *  targeting (`getLayout` present), nested-hit collapse
-     *  (`pickTopMostHit`), and group-pose composition. Flat scenes may omit. */
-    getParent?(id: string): string | null;
+    /** The node's container, `null` for a root. */
+    getParent(id: string): string | null;
     /** Optional paint depth, read by `pickTopMostHit` to resolve two *siblings*
      *  whose bodies both cover the pointer. Without it the hit list's own order
      *  decides, which is right for a back-to-front walk and wrong for anything
@@ -402,55 +347,52 @@ interface MoveAdapter<TNode extends {
     getZIndex?(id: string): number | null | undefined;
     compareZ?(a: string, b: string): number;
     setPose(id: string, pose: TPose): void;
-    /** Optional. Used only by reparent ops (e.g. drag-into-container drops via
-     *  layout strategies). Flat scenes that never reparent may omit. */
+    /** Optional. Used only by reparent ops; an adapter that never reparents may omit. */
     setParent?(id: string, parentId: string | null): void;
-    /** Optional: see SceneAdapter.applyOps. */
+    /** Optional. The commit point of a gesture. When omitted, ops are applied
+     *  against the adapter one by one; an adapter with a history of its own
+     *  takes them here as one entry. */
     applyOps?(ops: Op[], label: string): void;
     /** Optional. Show each node at its pose without writing the document, so
      *  nothing is recorded; `null` withdraws a node's preview. What a behavior
      *  that keeps moving nodes after the gesture ends writes each frame. */
     previewPoses?(poses: ReadonlyMap<string, TPose | null>): void;
+    /** Optional. The animation target of node `id`'s pose, the same one on
+     *  every call, so everything animating the node adds; `descriptor` supplies
+     *  its axes the first time. `tweenPose`, `springPose`, and `momentum` move
+     *  it where it is there, and write `setPose` each frame where it is not or
+     *  it answers `undefined`. */
+    poseTarget?(id: string, descriptor?: PoseDescriptor<TPose>): Target<TPose> | undefined;
     findSnapTarget?(draggedId: string, worldX: number, worldY: number): SnapTarget<TPose> | null;
-    /** Optional: ordered children of `parentId`, `null` for the root siblings.
-     *  One contract with {@link OrderedAdapter.getChildren} — the two land on
-     *  the same adapter object, and an implementation that answers only node
-     *  ids returns `[]` for the root, which the ops read as "no siblings".
-     */
-    getChildren?(parentId: string | null): string[];
+    /** Ordered children of `parentId`, `null` for the root siblings, in
+     *  z-order: index 0 is the bottom. One contract with
+     *  {@link OrderedAdapter.getChildren} — the two land on the same adapter
+     *  object. Picking walks it, and the ops read a node's sibling slot from it.
+     *  A node with no children answers `[]`. */
+    getChildren(parentId: string | null): string[];
     /** Optional: layout strategy attached to a container, or null if the
-     *  container uses absolute positioning (default behavior). When present,
-     *  `useMove` uses the strategy to compute drop targets, sibling reflow,
-     *  and the commit op batch when a drag ends over the container. */
+     *  container uses absolute positioning. When present, a move uses it to
+     *  compute drop targets, sibling reflow, and the commit op batch. */
     getLayout?(containerId: string): LayoutStrategy<TPose> | null;
 }
-/**
- * Narrow adapter for `useResize`. Mirrors `MoveAdapter`'s shape
- * minus reparenting and snap-target lookup.
- * TPose is constrained to { x, y, width, height } inline to avoid a circular
- * import with interactions/types.ts.
- */
+/** Narrow adapter for resize. */
 interface ResizeAdapter<TNode extends {
     id: string;
 }, TPose> {
     getNode(id: string): TNode | undefined;
     getPose(id: string): TPose;
     setPose(id: string, pose: TPose): void;
-    /** Optional: see SceneAdapter.applyOps. */
+    /** Optional: see MoveAdapter.applyOps. */
     applyOps?(ops: Op[], label: string): void;
 }
-/**
- * Narrow adapter for `useRotate`. Mirrors `ResizeAdapter`'s shape — rotate
- * mutates pose only and never reparents. TPose is left fully generic so
- * non-rect rotated poses (e.g. a `RotatedPath`) compose without changes.
- */
+/** Narrow adapter for rotate, which mutates pose only and never reparents. */
 interface RotateAdapter<TNode extends {
     id: string;
 }, TPose> {
     getNode(id: string): TNode | undefined;
     getPose(id: string): TPose;
     setPose(id: string, pose: TPose): void;
-    /** Optional: see SceneAdapter.applyOps. */
+    /** Optional: see MoveAdapter.applyOps. */
     applyOps?(ops: Op[], label: string): void;
 }
 /** The view a region pick answers for. */
@@ -462,15 +404,12 @@ interface RegionPickView {
     layerIsPainted?(layer: string): boolean;
 }
 /**
- * Narrow adapter for `useAreaSelect`. Transient: no checkpoint, no
- * history. The hook calls `applyOps(ops)` instead of `applyOps(ops, label)`.
+ * Narrow adapter for marquee selection. Transient: no checkpoint, no
+ * history — `applyOps(ops)` is called with no label.
  *
- * All fields are **optional** — area-select is opt-in. `useSelectTool` only
- * wires the default marquee behavior when `hitTestArea`, `getSelection`,
- * `setSelection`, and `applyOps` are all present on the adapter; otherwise
- * the gesture short-circuits (empty-space drags do nothing, sub-threshold
- * empty clicks still clear selection via the tool's `onClick` path).
- * Demos that don't need marquee selection can omit these methods entirely.
+ * All fields are **optional**. `useSelectTool` only wires the default marquee
+ * behavior when `hitTestArea`, `getSelection`, `setSelection`, and `applyOps`
+ * are all present on the adapter; otherwise empty-space drags do nothing.
  */
 interface AreaSelectAdapter {
     /** Returns ids of nodes intersecting the world-space rect, as the view the
@@ -496,15 +435,12 @@ interface AreaSelectAdapter {
  *   - 'intersect' — the node's outline meets the polygon anywhere.
  *   - 'enclosed'  — the node's whole outline is inside the polygon.
  *
- * The outline is the drawn silhouette, rotation included. `arrayAdapter` asks
- * its `silhouette` option for it, since the painters sit above `core/`.
+ * The outline is the drawn silhouette, rotation included.
  */
 type LassoHitMode = 'centers' | 'intersect' | 'enclosed';
 /**
- * Narrow adapter for lasso selection. Extends `AreaSelectAdapter` with a
- * polygon hit-test method. Transient — uses `applyOps` like its rectangular
- * sibling. `hitTestLasso` is optional; `selectFromLasso` does nothing
- * without it.
+ * Narrow adapter for lasso selection: `AreaSelectAdapter` plus a polygon
+ * hit-test. `selectFromLasso` does nothing without `hitTestLasso`.
  */
 interface LassoSelectAdapter extends AreaSelectAdapter {
     /** Hit-test against a closed polygon. Vertex order may be CW or CCW; the
@@ -515,63 +451,57 @@ interface LassoSelectAdapter extends AreaSelectAdapter {
     }>, mode: LassoHitMode, view?: RegionPickView): string[];
 }
 /**
- * Narrow adapter for `useInsert` and `useClipboardOps`. The kit knows
- * nothing about what tool is active or what shape to construct; it asks the
- * adapter to produce node(s) given gesture or paste inputs.
- *
- * Drag-rectangle path: `commitInsert(bounds)` returns one new node or null.
- * Clipboard paste path: `commitPaste(clipboard, offset)` returns the array of
- *   newly-materialized nodes (in order). Both empty array and array of
- *   length N are valid; the kit wraps each entry in an `InsertOp`.
- *
- * `snapshotSelection(ids)` builds the payload that paste later consumes.
- * `getPasteOffset` is optional; the kit defaults to a fixed grid-cell offset
- * supplied by the consumer (passed to `useClipboardOps` options if needed; see
- * the hook for resolution order).
+ * Narrow adapter for insert and `useClipboardOps`. The kit knows nothing
+ * about what shape to construct; it asks the adapter to produce node(s) given
+ * gesture or paste inputs, and wraps each in an `InsertOp`.
  */
 interface InsertAdapter<TNode extends {
     id: string;
 }> {
+    getNode(id: string): TNode | undefined;
+    getParent(id: string): string | null;
+    /** Ordered children of `parentId`, `null` for the root siblings. An insert
+     *  resolves its sibling slot against it. */
+    getChildren(parentId: string | null): string[];
     /** Materialize a new node from drag-rect bounds (drag-to-insert tools).
-     *  Optional — hooks that don't drive insertion (e.g. `useClone`,
-     *  read-only clipboard) won't call it, and `sceneToAdapter` only fills
-     *  it in when `options.commitInsert` is supplied. Hooks that *do* call
-     *  it (insert tools) document the requirement at their own surface. */
+     *  Optional: `sceneToAdapter` only fills it in when `options.commitInsert`
+     *  is supplied. */
     commitInsert?(bounds: {
         x: number;
         y: number;
         width: number;
         height: number;
     }): TNode | null;
-    /** Materialize one or more new nodes from a clipboard snapshot. Optional
-     *  — required by `useClipboard.paste`, ignored by other consumers. */
+    /** Materialize the new nodes from a clipboard snapshot, in order.
+     *  Optional — required only for paste. */
     commitPaste?(clipboard: ClipboardSnapshot, offset: {
         dx: number;
         dy: number;
     }, ctx?: PasteCtx): TNode[];
     /** Snapshot the current selection into the clipboard payload shape.
-     *  Optional — required by `useClipboard.copy` / `cut` and `useClone`'s
-     *  ghost capture, ignored by other consumers. */
+     *  Optional — required only for copy, cut, and clone's ghost capture. */
     snapshotSelection?(ids: string[]): ClipboardSnapshot;
     getPasteOffset?(clipboard: ClipboardSnapshot): {
         dx: number;
         dy: number;
     };
-    /** Mutator wired by `insertNode`-using ops (kit-side InsertOp). `index`
-     *  carries the z-position a delete captured, so undo restores paint order;
-     *  see `SceneAdapter.insertNode`. */
+    /** Mutator wired by `insertNode`-using ops (kit-side InsertOp). `index` is
+     *  the node's z-position among its siblings. `createDeleteOp` captures it
+     *  and `invert()` forwards it, so an implementation that drops it makes
+     *  undo of a delete restore the node at the top instead of where it was.
+     *  Omit only for an unordered store. */
     insertNode(node: TNode, index?: number): void;
     /** Mutator wired by `setSelection` ops batched alongside paste. */
     setSelection(ids: string[]): void;
-    /** Optional: see SceneAdapter.applyOps. */
+    /** Optional: see MoveAdapter.applyOps. */
     applyOps?(ops: Op[], label: string): void;
     /** Returns the current selection. Used by clone behaviors. */
     getSelection(): string[];
 }
 /**
- * Optional surface that lets `buildSceneTree` walk the adapter by layer.
- * Adapters that don't implement this fall back to flat rendering in Canvas's
- * scene layer.
+ * The layer list of an adapter whose nodes sit on layers. The scene slot
+ * paints one canvas layer per entry; a pick over a bare adapter reads it for
+ * parallax planes where it is there.
  */
 interface LayerEnumerableAdapter<TLayer extends string = string> {
     getLayers?(): readonly {
@@ -579,30 +509,27 @@ interface LayerEnumerableAdapter<TLayer extends string = string> {
         visible: boolean;
         parallax?: ParallaxOpts;
     }[];
+    /** Call `listener` whenever the list `getLayers` answers may have changed.
+     *  A canvas reads the list at mount and again on each call, so an adapter
+     *  whose list never changes leaves this out. */
+    subscribeLayers?(listener: () => void): () => void;
 }
 /**
- * Optional adapter mixin for sibling z-order.
- *
- * Both methods are optional. Reorder ops and `useReorder` no-op when
- * either is absent — adopt z-order incrementally without breaking existing
- * adapters.
+ * Sibling z-order: what the reorder ops read and write.
  *
  * **Convention:** array order IS z-order. Index 0 is the bottom of the
  * stack, the last index is the top. Hit-testing should iterate the returned
  * list in REVERSE (top to bottom). Render layers iterate FORWARD (bottom to
  * top).
- *
- * For groups, `parentId` may be a group id; the group adapter routes
- * `getChildren`/`setChildOrder` to the group's `members[]` array.
  */
 interface OrderedAdapter {
     /** Ordered children of `parentId` (or root siblings if null), in z-order:
      *  index 0 is bottom, last index is top. The same contract
      *  {@link MoveAdapter.getChildren} declares — one method, two readers. */
-    getChildren?(parentId: string | null): string[];
+    getChildren(parentId: string | null): string[];
     /** Rewrite the order of `parentId`'s children. Length and contents must
      *  match the existing children — reorder only, no add/remove. */
-    setChildOrder?(parentId: string | null, ids: string[]): void;
+    setChildOrder(parentId: string | null, ids: string[]): void;
 }
 
-export { type AreaSelectAdapter as A, rectToPlane as B, type ContainerBounds as C, type DropRegion as D, toPlane as E, type InsertAdapter as I, type LayoutStrategy as L, type MoveAdapter as M, type OrderedAdapter as O, type PlaneMap as P, type RegionPickView as R, type SnapTarget as S, type ParallaxOpts as a, type SceneAdapter as b, type LayoutDropTargetMode as c, type ReflowTransition as d, type PasteOmission as e, type LayerEnumerableAdapter as f, type LassoHitMode as g, type ResizeAdapter as h, type RotateAdapter as i, type LassoSelectAdapter as j, type ClipboardSnapshot as k, type PasteCtx as l, type DropTarget as m, type LayoutArrival as n, type LayoutChild as o, type LayoutContainer as p, type LayoutDragged as q, type LayoutSnap as r, type ReflowGlideOptions as s, type ScalarOrXY as t, deriveParallaxView as u, fromPlane as v, planeMap as w, planeMatrix as x, planeToPlane as y, rectFromPlane as z };
+export { type AreaSelectAdapter as A, toPlane as B, type ContainerBounds as C, type DropRegion as D, type InsertAdapter as I, type LayoutStrategy as L, type MoveAdapter as M, type OrderedAdapter as O, type ParallaxOpts as P, type RegionPickView as R, type SnapTarget as S, type PlaneMap as a, type LayoutDropTargetMode as b, type ReflowTransition as c, type PasteOmission as d, type LayerEnumerableAdapter as e, type LassoHitMode as f, type ResizeAdapter as g, type RotateAdapter as h, type LassoSelectAdapter as i, type ClipboardSnapshot as j, type PasteCtx as k, type DropTarget as l, type LayoutArrival as m, type LayoutChild as n, type LayoutContainer as o, type LayoutDragged as p, type LayoutSnap as q, type ReflowGlideOptions as r, type ScalarOrXY as s, deriveParallaxView as t, fromPlane as u, planeMap as v, planeMatrix as w, planeToPlane as x, rectFromPlane as y, rectToPlane as z };

package/dist/util/paint.js

@@ -47,7 +47,7 @@ function f(e, t = 1) {
 		width: t
 	};
 }
-var p = { color: "#888" };
+var p = { paint: { color: "#888" } };
 function m(e) {
 	return e?.opacity ?? 1;
 }

package/dist/util/paint.js.map

@@ -1 +1 @@
-{"version":3,"file":"paint.js","names":["DEFAULT_FILL_COLOR","DEFAULT_STROKE_COLOR","srgb","hexToColorLiteral","hex","DEFAULT_PALETTE","cycleFill","palette","entry","entries","seq","color","resolvePaletteColor","colorLiteralToHex","fallback","GHOST_STROKE","solid","a","getAlpha01","rgb","strokeOf","strokeWith","DEFAULT_SHAPE_FILL","paintAlpha","paint","paintWithAlpha","alpha01","paintWithColor","next","alpha"],"sources":["../../src/util/paint.ts"],"sourcesContent":["/** Kit-shipped default paint constants.\n *\n *  Single source of truth for the colors the built-in tools and the default\n *  fill/stroke actions reach for. Consumers that want to match the kit's\n *  out-of-the-box look (e.g. seed their own active-paint state) should import\n *  these rather than re-declaring the literals.\n *\n *  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha\n *  helpers (`util/color`) without ambiguity.\n */\nimport {\n  colorLiteralToHex,\n  hexToColorLiteral,\n  resolvePaletteColor,\n  type ColorLiteral,\n  type CommandStroke,\n  type FillStyle,\n  type Palette,\n  type SolidFill,\n  type Stroke,\n} from '@weasel-js/paint';\nimport { getAlpha01 } from './color';\n\n/** Default fill paint for shapes and the fill action — opaque white. */\nexport const DEFAULT_FILL_COLOR = '#ffffffff';\n\n/** Default stroke paint for shapes and the stroke action — opaque black. */\nexport const DEFAULT_STROKE_COLOR = '#000000ff';\n\nconst srgb = (hex: string): ColorLiteral => hexToColorLiteral(hex) as ColorLiteral;\n\n/** Default fill palette cycled through for auto-generated shape nodes\n *  (the kit's built-in shape tools and the `insert` action). */\nexport const DEFAULT_PALETTE: Palette = {\n  entries: [\n    { name: 'sage', color: srgb('#7fb069') },\n    { name: 'tan', color: srgb('#d4a574') },\n    { name: 'lavender', color: srgb('#a48bd4') },\n    { name: 'sky', color: srgb('#7ab8d4') },\n    { name: 'rose', color: srgb('#d47a7a') },\n  ],\n};\n\n/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.\n *  An entry that resolves to nothing, or to a space with no hex form, gives\n *  `fallback`. */\nexport function cycleFill(seq: number, palette: Palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR): string {\n  const { entries } = palette;\n  const entry = entries[((seq % entries.length) + entries.length) % entries.length];\n  const color = entry && resolvePaletteColor(palette, { ref: entry.name });\n  return (color && colorLiteralToHex(color)) ?? fallback;\n}\n\n/** Preview / \"ghost\" stroke color used by drag-to-draw tool overlays and the\n *  selected-anchor highlight. Derived from the first palette entry so the\n *  preview chrome matches the default insert color. */\nexport const GHOST_STROKE: string = cycleFill(0);\n\n/**\n * A solid paint from a color string — the authoring shorthand for the one\n * shape a node's `data.fill` (and a `Stroke.paint`) may take.\n *\n * An alpha channel in `color` moves to `opacity`, because that is where every\n * paint kind carries its alpha; leaving it in the hex too would multiply the\n * two in the renderer.\n */\nexport function solid(color: string): SolidFill {\n  const a = getAlpha01(color);\n  const rgb = color.length === 9 && color.startsWith('#') ? color.slice(0, 7) : color;\n  return a === 1 ? { color: rgb } : { color: rgb, opacity: a };\n}\n\n/** A solid stroke of `color` at `width` world units. Authoring shorthand for\n *  `{ paint: solid(color), width }`. */\nexport function strokeOf(color: string, width = 1): CommandStroke & { paint: SolidFill } {\n  return { paint: solid(color), width };\n}\n\n/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling\n *  for a gradient or pattern, which has no color to pass. */\nexport function strokeWith(paint: FillStyle, width = 1): Stroke {\n  return { paint, width };\n}\n\n/** The kit's default node paint — what a shape with no declared fill paints. */\nexport const DEFAULT_SHAPE_FILL: FillStyle = { color: '#888' };\n\n/**\n * The 0..1 alpha a paint paints at.\n *\n * Every paint kind carries its alpha in `opacity` — that is the one slot a\n * gradient or a pattern has, so it is the slot all of them use.\n */\nexport function paintAlpha(paint: FillStyle | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: FillStyle, alpha01: number): FillStyle {\n  return { ...paint, opacity: Math.max(0, Math.min(1, alpha01)) };\n}\n\n/**\n * `paint` recolored to `color`, keeping everything else about it.\n *\n * A solid paint takes the new color; a gradient or a pattern has no single\n * color to replace, so it is superseded by a solid one — picking a color off\n * a swatch means \"paint this color\". An alpha channel in `color` wins;\n * without one, the paint's existing opacity carries over.\n */\nexport function paintWithColor(paint: FillStyle | undefined, color: string): FillStyle {\n  const next = solid(color);\n  const explicitAlpha = color.length === 9 && color.startsWith('#');\n  if (explicitAlpha || paint === undefined) return next;\n  const alpha = paintAlpha(paint);\n  return alpha === 1 ? next : { ...next, opacity: alpha };\n}\n"],"mappings":";;;AAwBA,IAAaA,IAAqB,aAGrBC,IAAuB,aAE9BC,KAAQ,MAA8BC,EAAkBC,CAAG,GAIpDC,IAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAOH,EAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAOA,EAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAOA,EAAK,SAAS;CAAE;AACzC,EACF;AAKA,SAAgBI,EAAU,GAAa,IAAmBD,GAAiB,IAAWL,GAA4B;CAChH,IAAM,EAAE,eAAYO,GACdC,IAAQC,GAAUC,IAAMD,EAAQ,SAAUA,EAAQ,UAAUA,EAAQ,SACpEE,IAAQH,KAASI,EAAoBL,GAAS,EAAE,KAAKC,EAAM,KAAK,CAAC;CACvE,QAAQG,KAASE,EAAkBF,CAAK,MAAMG;AAChD;AAKA,IAAaC,IAAuBT,EAAU,CAAC;AAU/C,SAAgBU,EAAM,GAA0B;CAC9C,IAAMC,IAAIC,EAAWP,CAAK,GACpBQ,IAAMR,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,IAAIA,EAAM,MAAM,GAAG,CAAC,IAAIA;CAC9E,OAAOM,MAAM,IAAI,EAAE,OAAOE,EAAI,IAAI;EAAE,OAAOA;EAAK,SAASF;CAAE;AAC7D;AAIA,SAAgBG,EAAS,GAAe,IAAQ,GAAyC;CACvF,OAAO;EAAE,OAAOJ,EAAML,CAAK;EAAG;CAAM;AACtC;AAIA,SAAgBU,EAAW,GAAkB,IAAQ,GAAW;CAC9D,OAAO;EAAE;EAAO;CAAM;AACxB;AAGA,IAAaC,IAAgC,EAAE,OAAO,OAAO;AAQ7D,SAAgBC,EAAW,GAAsC;CAC/D,OAAOC,GAAO,WAAW;AAC3B;AAGA,SAAgBC,EAAe,GAAkB,GAA4B;CAC3E,OAAO;EAAE,GAAGD;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGE,CAAO,CAAC;CAAE;AAChE;AAUA,SAAgBC,EAAe,GAA8B,GAA0B;CACrF,IAAMC,IAAOZ,EAAML,CAAK;CAExB,IADsBA,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,KAC3Ca,MAAU,KAAA,GAAW,OAAOI;CACjD,IAAMC,IAAQN,EAAWC,CAAK;CAC9B,OAAOK,MAAU,IAAID,IAAO;EAAE,GAAGA;EAAM,SAASC;CAAM;AACxD"}
+{"version":3,"file":"paint.js","names":["DEFAULT_FILL_COLOR","DEFAULT_STROKE_COLOR","srgb","hexToColorLiteral","hex","DEFAULT_PALETTE","cycleFill","palette","entry","entries","seq","color","resolvePaletteColor","colorLiteralToHex","fallback","GHOST_STROKE","solid","a","getAlpha01","rgb","strokeOf","strokeWith","DEFAULT_SHAPE_FILL","paintAlpha","paint","paintWithAlpha","alpha01","paintWithColor","next","alpha"],"sources":["../../src/util/paint.ts"],"sourcesContent":["/** Kit-shipped default paint constants.\n *\n *  Single source of truth for the colors the built-in tools and the default\n *  fill/stroke actions reach for. Consumers that want to match the kit's\n *  out-of-the-box look (e.g. seed their own active-paint state) should import\n *  these rather than re-declaring the literals.\n *\n *  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha\n *  helpers (`util/color`) without ambiguity.\n */\nimport {\n  colorLiteralToHex,\n  hexToColorLiteral,\n  resolvePaletteColor,\n  type ColorLiteral,\n  type CommandStroke,\n  type Fill,\n  type Paint,\n  type Palette,\n  type SolidPaint,\n  type Stroke,\n} from '@weasel-js/paint';\nimport { getAlpha01 } from './color';\n\n/** Default fill paint for shapes and the fill action — opaque white. */\nexport const DEFAULT_FILL_COLOR = '#ffffffff';\n\n/** Default stroke paint for shapes and the stroke action — opaque black. */\nexport const DEFAULT_STROKE_COLOR = '#000000ff';\n\nconst srgb = (hex: string): ColorLiteral => hexToColorLiteral(hex) as ColorLiteral;\n\n/** Default fill palette cycled through for auto-generated shape nodes\n *  (the kit's built-in shape tools and the `insert` action). */\nexport const DEFAULT_PALETTE: Palette = {\n  entries: [\n    { name: 'sage', color: srgb('#7fb069') },\n    { name: 'tan', color: srgb('#d4a574') },\n    { name: 'lavender', color: srgb('#a48bd4') },\n    { name: 'sky', color: srgb('#7ab8d4') },\n    { name: 'rose', color: srgb('#d47a7a') },\n  ],\n};\n\n/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.\n *  An entry that resolves to nothing, or to a space with no hex form, gives\n *  `fallback`. */\nexport function cycleFill(seq: number, palette: Palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR): string {\n  const { entries } = palette;\n  const entry = entries[((seq % entries.length) + entries.length) % entries.length];\n  const color = entry && resolvePaletteColor(palette, { ref: entry.name });\n  return (color && colorLiteralToHex(color)) ?? fallback;\n}\n\n/** Preview / \"ghost\" stroke color used by drag-to-draw tool overlays and the\n *  selected-anchor highlight. Derived from the first palette entry so the\n *  preview chrome matches the default insert color. */\nexport const GHOST_STROKE: string = cycleFill(0);\n\n/**\n * A solid paint from a color string — the authoring shorthand for the one\n * shape a `Fill.paint` or a `Stroke.paint` may take.\n *\n * An alpha channel in `color` moves to `opacity`, because that is where every\n * paint kind carries its alpha; leaving it in the hex too would multiply the\n * two in the renderer.\n */\nexport function solid(color: string): SolidPaint {\n  const a = getAlpha01(color);\n  const rgb = color.length === 9 && color.startsWith('#') ? color.slice(0, 7) : color;\n  return a === 1 ? { color: rgb } : { color: rgb, opacity: a };\n}\n\n/** A solid stroke of `color` at `width` world units. Authoring shorthand for\n *  `{ paint: solid(color), width }`. */\nexport function strokeOf(color: string, width = 1): CommandStroke & { paint: SolidPaint } {\n  return { paint: solid(color), width };\n}\n\n/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling\n *  for a gradient or pattern, which has no color to pass. */\nexport function strokeWith(paint: Paint, width = 1): Stroke {\n  return { paint, width };\n}\n\n/** The kit's default node fill — what a shape with no declared fill paints. */\nexport const DEFAULT_SHAPE_FILL: Fill & { paint: Paint } = { paint: { color: '#888' } };\n\n/**\n * The 0..1 alpha a paint paints at.\n *\n * Every paint kind carries its alpha in `opacity` — that is the one slot a\n * gradient or a pattern has, so it is the slot all of them use.\n */\nexport function paintAlpha(paint: Paint | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: Paint, alpha01: number): Paint {\n  return { ...paint, opacity: Math.max(0, Math.min(1, alpha01)) };\n}\n\n/**\n * `paint` recolored to `color`, keeping everything else about it.\n *\n * A solid paint takes the new color; a gradient or a pattern has no single\n * color to replace, so it is superseded by a solid one — picking a color off\n * a swatch means \"paint this color\". An alpha channel in `color` wins;\n * without one, the paint's existing opacity carries over.\n */\nexport function paintWithColor(paint: Paint | undefined, color: string): Paint {\n  const next = solid(color);\n  const explicitAlpha = color.length === 9 && color.startsWith('#');\n  if (explicitAlpha || paint === undefined) return next;\n  const alpha = paintAlpha(paint);\n  return alpha === 1 ? next : { ...next, opacity: alpha };\n}\n"],"mappings":";;;AAyBA,IAAaA,IAAqB,aAGrBC,IAAuB,aAE9BC,KAAQ,MAA8BC,EAAkBC,CAAG,GAIpDC,IAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAOH,EAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAOA,EAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAOA,EAAK,SAAS;CAAE;AACzC,EACF;AAKA,SAAgBI,EAAU,GAAa,IAAmBD,GAAiB,IAAWL,GAA4B;CAChH,IAAM,EAAE,eAAYO,GACdC,IAAQC,GAAUC,IAAMD,EAAQ,SAAUA,EAAQ,UAAUA,EAAQ,SACpEE,IAAQH,KAASI,EAAoBL,GAAS,EAAE,KAAKC,EAAM,KAAK,CAAC;CACvE,QAAQG,KAASE,EAAkBF,CAAK,MAAMG;AAChD;AAKA,IAAaC,IAAuBT,EAAU,CAAC;AAU/C,SAAgBU,EAAM,GAA2B;CAC/C,IAAMC,IAAIC,EAAWP,CAAK,GACpBQ,IAAMR,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,IAAIA,EAAM,MAAM,GAAG,CAAC,IAAIA;CAC9E,OAAOM,MAAM,IAAI,EAAE,OAAOE,EAAI,IAAI;EAAE,OAAOA;EAAK,SAASF;CAAE;AAC7D;AAIA,SAAgBG,EAAS,GAAe,IAAQ,GAA0C;CACxF,OAAO;EAAE,OAAOJ,EAAML,CAAK;EAAG;CAAM;AACtC;AAIA,SAAgBU,EAAW,GAAc,IAAQ,GAAW;CAC1D,OAAO;EAAE;EAAO;CAAM;AACxB;AAGA,IAAaC,IAA8C,EAAE,OAAO,EAAE,OAAO,OAAO,EAAE;AAQtF,SAAgBC,EAAW,GAAkC;CAC3D,OAAOC,GAAO,WAAW;AAC3B;AAGA,SAAgBC,EAAe,GAAc,GAAwB;CACnE,OAAO;EAAE,GAAGD;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGE,CAAO,CAAC;CAAE;AAChE;AAUA,SAAgBC,EAAe,GAA0B,GAAsB;CAC7E,IAAMC,IAAOZ,EAAML,CAAK;CAExB,IADsBA,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,KAC3Ca,MAAU,KAAA,GAAW,OAAOI;CACjD,IAAMC,IAAQN,EAAWC,CAAK;CAC9B,OAAOK,MAAU,IAAID,IAAO;EAAE,GAAGA;EAAM,SAASC;CAAM;AACxD"}

package/dist/version.js

@@ -1,5 +1,5 @@
 //#region src/version.ts
-var e = "1.9.4";
+var e = "1.10.1";
 //#endregion
 export { e as VERSION };
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.9.4",
-  "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
+  "version": "1.10.1",
+  "description": "A 2D scene-graph engine for React, rendered on WebGL2: the scene tree, viewport math, pointer and keyboard input, layered rendering, and op-based undo.",
   "license": "MIT",
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",
@@ -17,9 +17,9 @@
   "sideEffects": [
     "*.css",
     "./src/import-shims/mesh.ts",
-    "./src/features/meshPaint/register.ts",
+    "./src/core/paint/registerMesh.ts",
     "./dist/mesh.js",
-    "./dist/features/meshPaint/register.js"
+    "./dist/core/paint/registerMesh.js"
   ],
   "engines": {
     "node": ">=22"
@@ -86,24 +86,29 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "@weasel-js/font": "1.9.4",
+    "@weasel-js/font": "1.10.1",
     "react": ">=18"
   },
   "dependencies": {
-    "@msb235/blits": "0.8.1",
-    "@weasel-js/cursor": "1.9.4",
-    "@weasel-js/geom": "1.9.4",
-    "@weasel-js/gestures": "1.9.4",
-    "@weasel-js/history": "1.9.4",
-    "@weasel-js/modes": "1.9.4",
-    "@weasel-js/paint": "1.9.4",
-    "@weasel-js/prefs": "1.9.4",
-    "@weasel-js/quantity": "1.9.4",
-    "@weasel-js/react": "1.9.4",
-    "@weasel-js/registry": "1.9.4",
-    "@weasel-js/routing": "1.9.4",
-    "@weasel-js/select": "1.9.4",
-    "@weasel-js/text": "1.9.4",
+    "@msb235/blits": "0.10.0",
+    "@weasel-js/animator": "1.10.1",
+    "@weasel-js/cursor": "1.10.1",
+    "@weasel-js/geom": "1.10.1",
+    "@weasel-js/gestures": "1.10.1",
+    "@weasel-js/history": "1.10.1",
+    "@weasel-js/modes": "1.10.1",
+    "@weasel-js/paint": "1.10.1",
+    "@weasel-js/prefs": "1.10.1",
+    "@weasel-js/quantity": "1.10.1",
+    "@weasel-js/react": "1.10.1",
+    "@weasel-js/registry": "1.10.1",
+    "@weasel-js/renderer": "1.10.1",
+    "@weasel-js/routing": "1.10.1",
+    "@weasel-js/select": "1.10.1",
+    "@weasel-js/simulation": "1.10.1",
+    "@weasel-js/stroke": "1.10.1",
+    "@weasel-js/text": "1.10.1",
+    "@weasel-js/text-dom": "1.10.1",
     "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
@@ -121,7 +126,7 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/modes": "1.9.4",
-    "@weasel-js/theme": "1.9.4"
+    "@weasel-js/modes": "1.10.1",
+    "@weasel-js/theme": "1.10.1"
   }
 }