@weasel-js/core 1.11.0 → 1.11.1

package/dist/{depSchema-Cgfu_G9s.d.ts → depSchema-BpZNOv7q.d.ts}

@@ -5,878 +5,21 @@ import { IconRef } from '@weasel-js/icons';
 import { PaintDrawKind, DrawCommand, Effect, CompositeOp, BlendFactors } from '@weasel-js/renderer';
 import * as _weasel_js_routing_react from '@weasel-js/routing/react';
 import * as _weasel_js_geom from '@weasel-js/geom';
-import { Path, PoseLinear, Affine, FramedBox, View, Rect, Scale2, PolygonPath, PathFillRule, AnchorSet, PointOrigin } from '@weasel-js/geom';
-import * as _weasel_js_history from '@weasel-js/history';
-import { SerializedHistory, Op, History } from '@weasel-js/history';
+import { FramedBox, View, Path, Affine, Rect, Scale2, PolygonPath, PathFillRule, AnchorSet, PointOrigin } from '@weasel-js/geom';
+import { Op, History } from '@weasel-js/history';
 import { NodeId, ModifierState, OverlayRole, ResizeAnchor, ActionDeps, OngoingHandle, OngoingOverlay, SelectionApi, IngestItem, Point2, DragSample, DebugSink, LongPressState } from '@weasel-js/routing';
 import { TextNodeSource, TextOutlinesError, TextStyle, StyledRun, TextVerticalAlign } from '@weasel-js/text';
 import { CursorSpec } from '@weasel-js/cursor';
 import { ClaimableGesture } from '@weasel-js/gestures';
 import { SnapTier, ProbeRole } from '@weasel-js/geom/nd';
-import { a as ParallaxOpts, C as ContainerBounds, L as LayoutStrategy, P as PlaneMap, I as InsertAdapter, b as PasteOmission, R as RegionPickView, c as LayoutDropTargetMode, d as ReflowTransition } from './types-CHVXGfYm.js';
-import { UnitScope } from '@weasel-js/quantity';
+import { S as Scene, R as RectPose } from './types-CniVctmk.js';
+import { a as PlaneMap, L as LayoutStrategy, b as LayoutDropTargetMode, R as ReflowTransition } from './types-7puAuVD2.js';
 import { O as OriginProjection } from './originProjection-gY0jb4Wb.js';
 import { EasingSpec, InterpolatorFactory, Target, Animator, TargetAxes } from '@weasel-js/animator';
-import { B as BoundsConstraint } from './clone-DZDrfIlU.js';
+import { I as InsertAdapter, P as PasteOmission, R as RegionPickView } from './types-oFeQ5VjV.js';
+import { B as BoundsConstraint } from './clone-C3e0OTuF.js';
 import { P as PoseDescriptor } from './poseDescriptor-DN2yfnq_.js';
 
-/** The form a scene's undo entries are recorded in. A serialized history
- *  carries it, and one carrying another is not restored. Form 2 holds the
- *  scene's own ops for every edit; before it, an `applyBatch` entry held the
- *  ops it was given. */
-declare const SCENE_HISTORY_FORM = 2;
-/** What `Scene.serializeHistory` answers with. */
-interface SerializedSceneHistory extends SerializedHistory {
-    form: typeof SCENE_HISTORY_FORM;
-}
-
-interface LayerRecordBase<TLayer extends string> {
-    id: TLayer;
-    visible: boolean;
-    locked: boolean;
-    /** Draw this layer as a parallax plane: through a view derived from the
-     *  camera's (see `deriveParallaxView`), and picked through the same one.
-     *  Absent means the layer moves with the camera. */
-    parallax?: ParallaxOpts;
-    /** A non-printing layer of aids — measurements, notes — rather than content.
-     *  Its nodes draw on the canvas and save with the scene, but export leaves
-     *  them out and content picking passes through them. Read it through
-     *  `isAnnotationLayer`. Absent means content. */
-    annotation?: boolean;
-}
-/** A layer declared when the scene was created. Fixed set, no display name —
- *  these are the kit's own render bands, not something a user manages. */
-interface SystemLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
-    kind: 'system';
-}
-/** A layer the user created and can rename, reorder or delete. */
-interface UserLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
-    kind: 'user';
-    name: string;
-}
-/** Per-layer metadata held by the scene: whether it is visible and locked,
- *  and where it sits in the render stack. Distinct from a node's `layer` tag,
- *  which merely names one of these. */
-type LayerRecord<TLayer extends string> = SystemLayerRecord<TLayer> | UserLayerRecord<TLayer>;
-/** One of the layers a scene is created with. */
-interface SystemLayerSpec<TLayer extends string> {
-    id: TLayer;
-    visible?: boolean;
-    locked?: boolean;
-    /** See `LayerRecord.parallax`. */
-    parallax?: ParallaxOpts;
-    /** See `LayerRecord.annotation`. */
-    annotation?: boolean;
-}
-/** Argument to `Scene.addLayer`. Always produces a `UserLayerRecord`
- *  (`kind: 'user'`). */
-interface AddLayerSpec<TLayer extends string> {
-    id: TLayer;
-    name: string;
-    /** Default `true`. */
-    visible?: boolean;
-    /** Default `false`. */
-    locked?: boolean;
-    /** See `LayerRecord.parallax`. */
-    parallax?: ParallaxOpts;
-    /** See `LayerRecord.annotation`. */
-    annotation?: boolean;
-    /** Render-stack position. Default: top of stack (highest render index). */
-    index?: number;
-}
-
-/** A pose a container's layout wrote — reported by `Scene.onReflow` — in the
- *  node's stored frame. */
-interface LayoutMove<TPose> {
-    id: NodeId;
-    from: TPose;
-    to: TPose;
-}
-/** How a scene reads and resizes a laid-out container's bounds. */
-interface LayoutFrame<TPose> {
-    /** The container's bounds, from its world pose. Default: the pose's own
-     *  `x`/`y`/`width`/`height`; a pose without them is not laid out. */
-    bounds?(pose: TPose): ContainerBounds | null;
-    /** `pose` resized from bounds `from` to `to`, for a layout that grows its
-     *  container. Default: `to`'s fields written over the pose. */
-    remap?(pose: TPose, from: ContainerBounds, to: ContainerBounds): TPose;
-}
-
-/** Folding a node's pose up its parent chain to world, and back down. */
-/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */
-interface PoseAdapter<TPose> {
-    getPose(id: string): TPose;
-    getParent(id: string): string | null;
-    /** Whether `id`'s pose is a frame its children are expressed in. Absent
-     *  means every node is one. A container whose pose derives from its children
-     *  is not: its children share its frame, so the fold passes over it. */
-    definesFrame?(id: string): boolean;
-}
-/**
- * What a container's pose does to its children under a `compose`: nothing,
- * an offset, or a whole frame. `'rigid'` is the frame: a container's rotation
- * and its `transform` both reach its children, and a child's `transform`
- * holds the skew or stretch its box and rotation cannot.
- */
-type PoseClosure = 'identity' | 'translation' | 'rigid';
-/** Consumer's pose-composition strategy for hierarchical scenes. `compose`
- *  folds a child's pose (in parent's frame) up to the next frame; `decompose`
- *  is its inverse. Default is IDENTITY — an absolute-pose scene where every
- *  node already stores world coords (parent is grouping-only, no transform). */
-interface PoseComposition<TPose> {
-    compose(parent: TPose, child: TPose): TPose;
-    decompose(parent: TPose, world: TPose): TPose;
-    closure: PoseClosure;
-}
-/** Default pose-composition strategy: IDENTITY, an absolute-pose scene. */
-declare const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown>;
-/** Whether `composition` makes a container's pose a frame, so a stored pose
- *  is local to it. False for the absolute-pose model. */
-declare function composesFrames(composition: {
-    closure: PoseClosure;
-}): boolean;
-/**
- * Walk `id`'s parent chain and fold local poses into a world pose via
- * `compose`. Cycle-safe.
- *
- * `compose(parent, child)` interprets `child` as expressed *in `parent`'s
- * local frame* and returns the equivalent pose in the next frame up.
- */
-declare function composeWorldPose<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
-/**
- * Convert `worldPose` into a local pose expressed under `newParentId`'s
- * frame, so a reparented child keeps its visual world position.
- *
- * `decompose(parent, world)` returns the local pose `child` such that
- * `compose(parent, child) === world`. Pass `newParentId === null` for the
- * root frame; the function returns `worldPose` unchanged.
- */
-declare function rebaseLocalPose<TPose>(adapter: PoseAdapter<TPose>, worldPose: TPose, newParentId: string | null, compose: (parent: TPose, child: TPose) => TPose, decompose: (parent: TPose, world: TPose) => TPose): TPose;
-
-/**
- * Where a reported pose write came from.
- *
- * - `'call'` — a scene method called directly, alone or inside `scene.batch`:
- *   a button's `scene.setPose`, a `scene.add`.
- * - `'ops'` — ops applied as one edit through `applyBatch` or `history.apply`,
- *   which is how actions commit: a drag's release, a resize, a nudge, an align.
- * - `'undo'` / `'redo'` — a history step, a jump through the history included.
- * - `'layout'` — a container's layout arranging what a live edit changed; also
- *   reported to `onReflow`.
- * - `'untracked'` — a write inside `scene.untracked`, such as a pose target
- *   committing an animation's destination.
- */
-type PoseWriteOrigin = 'call' | 'ops' | 'undo' | 'redo' | 'layout' | 'untracked';
-/** One node's pose as a scene change left it, in the node's stored frame. */
-interface PoseWrite<TPose> {
-    id: NodeId;
-    /** The pose before the change; `undefined` for a node the change added. */
-    from: TPose | undefined;
-    to: TPose;
-    origin: PoseWriteOrigin;
-    /** The edit's label (`'setPose'`, a batch's, an action's `'Move'`) for
-     *  `'call'` and `'ops'`; `undefined` otherwise. */
-    label?: string;
-}
-/** A removed node as it was last shown, with the descendants it took along. */
-interface RemovedNode<TPose, TNode = unknown> {
-    /** The node as it stood before the change removed it. */
-    node: TNode;
-    /** Where it was shown, override included, in its stored frame. */
-    pose: TPose;
-    children: readonly RemovedNode<TPose, TNode>[];
-}
-/** One node a scene change removed, a removal's root: its descendants ride
- *  beneath it rather than being reported apart. */
-interface PoseRemoval<TPose, TNode = unknown> extends RemovedNode<TPose, TNode> {
-    id: NodeId;
-    /** The parent it was removed from, which may still be in the scene. */
-    parent: NodeId | null;
-    origin: PoseWriteOrigin;
-    label?: string;
-}
-/** What a scene reports about the poses its edits write. */
-interface ScenePoseReports<TPose, TNode = unknown> {
-    /** Called with the poses each live edit's layout pass wrote, after the
-     *  edit lands — never for an undo or redo, which restore poses rather than
-     *  arrange them. What a reflow animation glides from. */
-    onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;
-    /** Called once per change, before the scene's subscribers hear of it, with
-     *  every node whose pose the change wrote or that it added, and every node
-     *  it removed — an undone add among them. A node written back to the pose
-     *  it had, or both added and removed by the change, is left out of both.
-     *  Not called for `loadState` or the scene's initial nodes. */
-    onPoseWrite(listener: (writes: readonly PoseWrite<TPose>[], removed: readonly PoseRemoval<TPose, TNode>[]) => void): () => void;
-}
-
-/**
- * One node's ephemeral presentation override — what a frame loop wants to say
- * about a node without saying it about the document.
- *
- * Not document content: never recorded in history, never in `toJSON`, and
- * writing one does not bump `Scene.getVersion()`. Hoist one entry per node and
- * mutate it in place on a frame loop; `PoseOverrides.commit()` is what makes a
- * mutation visible.
- */
-interface PoseOverride<TPose> {
-    /** Replaces the node's document pose everywhere the render and hit-test
-     *  paths read one, including the clip a container derives from its pose, and
-     *  winning over a `derivePose`. Resolved by `effectivePose` — reading
-     *  `node.pose` directly is how those paths came to disagree about where a
-     *  node is. */
-    pose?: TPose;
-    /** Multiplied into the node's painted alpha, on top of any `alphaFor`. */
-    alpha?: number;
-    /** Replaces the geometry the node paints and is picked by: the path in its data, or the one
-     *  it derives. It is in the frame a painter draws in, so give `pose` beside it, as the
-     *  path's bounds with no rotation, or the pose's turn is applied to the path again and the
-     *  selection chrome stays on the old box. A skinned rig is the writer. */
-    path?: Path;
-}
-/**
- * The scene's ephemeral per-node overrides — see {@link PoseOverride}.
- *
- * The intended shape of a frame is: `set` each node once, mutate the entries
- * in place per frame, `commit()` once. `commit` is not optional bookkeeping —
- * the painter memo keys on pose *reference*, so a mutation without a commit
- * paints the previous frame with no error.
- *
- * To promote a frame to document state (dropping a drag, baking an animation),
- * write it once through `Scene.setPose` and `clear` the override.
- */
-interface PoseOverrides<TPose> {
-    /** Store `entry` for `id` **by reference**; the caller keeps mutating it. */
-    set(id: NodeId, entry: PoseOverride<TPose>): void;
-    /** The entry `set` stored, by reference — what a writer checks to know
-     *  whether its own entry is still installed. Painting reads `read`. */
-    get(id: NodeId): PoseOverride<TPose> | undefined;
-    /** What the node is drawn and picked with: every source of overrides for
-     *  it folded into one, as of the last write or `commit()`. `undefined` for
-     *  a node nothing overrides. The object is reused per node. */
-    read(id: NodeId): PoseOverride<TPose> | undefined;
-    has(id: NodeId): boolean;
-    /** The overridden ids, as a snapshot array. */
-    ids(): readonly NodeId[];
-    clear(id: NodeId): void;
-    clearAll(): void;
-    /** Publish this frame's in-place mutations: invalidate the painter memo for
-     *  every overridden node, then notify subscribers. */
-    commit(): void;
-    /** Notified after every write. The canvas uses this to repaint without a
-     *  scene version bump. */
-    subscribe(fn: () => void): () => void;
-    /** Monotonic write counter. A snapshot for observers that poll. */
-    getGeneration(): number;
-    /** A claim on some nodes' poses for a writer that publishes a whole frame
-     *  at a time: a gesture's preview, a layout run. Each call is a new claim. */
-    hold(): PoseHold<TPose>;
-}
-/**
- * One writer's claim on some nodes' pose overrides, from
- * {@link PoseOverrides.hold}.
- *
- * A hold knows which entries are its own, so several writers share the table
- * without clearing each other: a drag and a layout run each publish their
- * frame, and each sees the other's nodes as pinned.
- */
-interface PoseHold<TPose> {
-    /** Publish this frame's poses. It is the whole picture, not a delta: an id
-     *  the frame leaves out is released. Subscribers are notified once. */
-    set(poses: Iterable<readonly [NodeId, TPose]>): void;
-    /** The poses other writers are publishing, by id. */
-    others(): ReadonlyMap<NodeId, TPose>;
-    /** Release every id still held. An id whose entry another writer has since
-     *  replaced is left alone: that writer owns it now. When the frame is being
-     *  committed to the document, call this after the write lands, or the scene
-     *  answers with the old pose in between. */
-    drop(): void;
-}
-
-/** One layer as it appears in a snapshot. A snapshot written before layer
- *  kind was serialized carries neither field, and loads as a system layer —
- *  which is what every layer in such a snapshot was. */
-interface SerializedLayer<TLayer extends string> extends SystemLayerSpec<TLayer> {
-    kind?: 'system' | 'user';
-    /** Present on a user layer, absent on a system one. */
-    name?: string;
-}
-/** JSON-serializable shape of a Scene's current state. Produced by
- *  `scene.toJSON()`; consumed by `sceneFromJSON()`. Function fields
- *  (e.g., `clipFromPose`) appear as string keys (`clipFromPoseKey`) and
- *  are resolved through `SceneRegistry` at load time. */
-interface SerializedScene<TData, TLayer extends string, TPose> {
-    version: 1;
-    /** The whole layer stack, system and user alike — the name predates user
-     *  layers and is kept so existing snapshots still parse. */
-    systemLayers: readonly SerializedLayer<TLayer>[];
-    nodes: readonly SerializedNode<TData, TLayer, TPose>[];
-}
-/** JSON-serializable shape of a single node. Mirrors `AddNodeSpec` but
- *  with function fields replaced by registry keys. */
-interface SerializedNode<TData, TLayer extends string, TPose> {
-    id: string;
-    kind: 'leaf' | 'container';
-    layer: TLayer;
-    pose: TPose;
-    data: TData;
-    /** Parent id; omitted for roots. */
-    parent?: string;
-    /** Registry key for the container's clip-path factory.
-     *  Containers only; omitted when the container has no clip. */
-    clipFromPoseKey?: string;
-    /** Registry key for the container's `copiesFromPose`. Containers only;
-     *  omitted when it draws no copies. */
-    copiesFromPoseKey?: string;
-    /** Ids this node's geometry derives from, or `'children'`. Omitted when it
-     *  derives from nothing. */
-    dependsOn?: readonly string[] | 'children';
-    /** Mirrors `SceneNode.pickable`. Omitted when the node is pickable. */
-    pickable?: boolean;
-    /** Mirrors `SceneNode.hidden`. Omitted when the node is shown. */
-    hidden?: boolean;
-    /** Mirrors `SceneNode.locked`. Omitted when the node is unlocked. */
-    locked?: boolean;
-    /** Registry key for the node's `derivePath` function. Omitted when it has none. */
-    derivePathKey?: string;
-    /** Registry key for the node's `derivePose` function. Omitted when it has none. */
-    derivePoseKey?: string;
-    /** Registry key for the container's layout strategy. Omitted when it has none. */
-    layoutKey?: string;
-    /** Mirrors `ContainerNode.units`. Omitted when the container declares none. */
-    units?: UnitScope;
-}
-
-/**
- * Axis-aligned rectangle pose with optional rotation. Rotation is in
- * radians, pivoted on the unrotated AABB center; absent === 0.
- */
-interface RectPose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Rotation in radians around the unrotated AABB center. Absent === 0. */
-    rotation?: number;
-    /** A skew or per-axis scale the box and rotation cannot hold; see
-     *  {@link PoseLinear}. Absent is the identity. */
-    transform?: PoseLinear;
-}
-
-/**
- * One dependency, as a derivation reads it: the node itself and the pose it is
- * painted at.
- *
- * The node comes along because a connector legitimately reads more than a box
- * — an edge that thickens with its endpoint's weight, or routes only to nodes
- * on a given layer, is answering off `data` and `layer`.
- */
-interface DerivedDep<TPose, TData = unknown, TLayer extends string = string> {
-    node: Node<TData, TLayer, TPose>;
-    /** Its override when it has one, else its own derived pose, else the pose
-     *  the document stores — `effectivePose`, the same answer the renderer uses. */
-    pose: TPose;
-    /** The path a pose override shows it by, else the one it derives, else
-     *  `null`; the document reading skips the override, and a `toPose` lookup
-     *  carries it into the box its `toPose` answers. Read
-     *  it to place something *along* a dependency: a label on a routed edge.
-     *  Resolved on first read and memoized on the dependency. */
-    readonly path: Path | null;
-}
-/** `F` with its parameters checked bivariantly, as a method's are, so that a
- *  `Scene<D, L, MyPose>` is a `Scene<unknown, string, unknown>`. A callback for
- *  an unrelated pose is still rejected; one for a narrower pose is not. */
-type Bivariant<F extends (...args: never[]) => unknown> = {
-    method(...args: Parameters<F>): ReturnType<F>;
-}['method'];
-/** Computes a node's path from its dependencies: the type of a node's
- *  `derivePath` and of each entry in `SceneRegistry.derivePath`. */
-type DerivePathFn<TPose, TData = unknown, TLayer extends string = string> = Bivariant<(node: Node<TData, TLayer, TPose>, deps: readonly (DerivedDep<TPose, TData, TLayer> | undefined)[]) => Path | null>;
-/** Computes a node's pose from its dependencies: the type of a node's
- *  `derivePose` and of each entry in `SceneRegistry.derivePose`. */
-type DerivePoseFn<TPose, TData = unknown, TLayer extends string = string> = Bivariant<(node: Node<TData, TLayer, TPose>, deps: readonly (DerivedDep<TPose, TData, TLayer> | undefined)[]) => TPose | null>;
-/** A container's clip, from its pose: the type of `ContainerNode.clipFromPose`
- *  and of each entry in `SceneRegistry.clipFromPose`. */
-type ClipFromPoseFn<TPose> = Bivariant<(pose: TPose) => Path | null>;
-/** The extra times a container draws its children: the type of
- *  `ContainerNode.copiesFromPose` and of each entry in
- *  `SceneRegistry.copiesFromPose`. Each affine is in world coordinates and
- *  carries the children, as drawn, to one copy. */
-type CopiesFromPoseFn<TPose, TData = unknown, TLayer extends string = string> = Bivariant<(pose: TPose, node: ContainerNode<TData, TLayer, TPose>) => readonly Affine[] | null>;
-
-/** Brand a string as a NodeId. */
-declare const asNodeId: (s: string) => NodeId;
-
-interface NodeBase<TData, TLayer extends string, TPose> {
-    id: NodeId;
-    layer: TLayer;
-    pose: TPose;
-    data: TData;
-    parent: NodeId | null;
-    /** Nodes whose poses this node's geometry is computed from. Fixed at add
-     *  time. Absent or empty means the node's geometry is authored, which is the
-     *  normal case.
-     *
-     *  `'children'` means "my own children, in child order" — a container that
-     *  hugs its contents, which a fixed id list cannot express because
-     *  reparenting would have to maintain it. The two forms differ in lifetime
-     *  as well as in membership: deleting a node deletes everything that names
-     *  it in `dependsOn`, but a container outlives the children it derives
-     *  from — an emptied group is still a group. */
-    dependsOn?: readonly NodeId[] | 'children';
-    /** Whether the hit-test walk can return this node. Default `true`; `false`
-     *  makes it transparent to picking, so a click on it lands on whatever is
-     *  behind — normally its own container.
-     *
-     *  For content a container owns rather than content the user selects on its
-     *  own: the label inside a box, a body's rows. It does not hide the node
-     *  from anything else — it still paints, still clips, and a consumer can
-     *  still select it by id. */
-    pickable?: boolean;
-    /** Not drawn, with its whole subtree: picking, area selection, select-all,
-     *  snapping and the selection pass over it, and an SVG export writes it with
-     *  `display="none"`. Absent means shown; `Scene.isHidden` folds in its
-     *  ancestors' flags and its layer's visibility. */
-    hidden?: boolean;
-    /** Out of reach, with its whole subtree: still drawn, but picking and area
-     *  selection pass over it, the selection drops it, and every edit to it
-     *  throws, as on a locked layer. Absent means unlocked; `Scene.isLocked`
-     *  folds in its ancestors' and its layer's. */
-    locked?: boolean;
-    /** Computes this node's path from its dependencies, in `dependsOn` order —
-     *  each one the node and the pose it is painted at.
-     *  A dependency that has been removed arrives as `undefined`.
-     *  Returning `null` means "nothing to draw right now". Re-evaluated when a
-     *  dependency's world pose changes, never authored. */
-    derivePath?: DerivePathFn<TPose, TData, TLayer>;
-    /** Computes this node's pose from its dependencies' poses, the same way
-     *  `derivePath` computes its path — same `dependsOn` list, same
-     *  registry-keyed serialization.
-     *
-     *  Where a derived path is resolved at paint time and reaches only the
-     *  painter, a derived pose is what the node *is* at: it feeds bounds,
-     *  hit-testing, selection chrome, snapping and layout, and every reader
-     *  gets it through `effectivePose`. A pose override still wins over it.
-     *
-     *  Returning `null` means "I have nothing to derive from right now", and
-     *  the node falls back to its authored `pose`. `setPose` on a derived node
-     *  still writes that authored pose; it is simply not what anything reads. */
-    derivePose?: DerivePoseFn<TPose, TData, TLayer>;
-}
-/** A node with no children — a shape, a label, an image. */
-interface LeafNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
-    kind: 'leaf';
-}
-/** A node with an ordered list of children. This is the real group: what
- *  Cmd+G creates, what SVG `<g>` round-trips to. A container has its own pose,
- *  which its children's poses are relative to, and may optionally clip them. */
-interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
-    kind: 'container';
-    children: NodeId[];
-    /** Optional clip-path source. Re-evaluated each render. Returning `null`
-     *  means "no clip for this container right now"; an empty / zero-area path
-     *  means "clip everything out" (children render nowhere). */
-    clipFromPose?: ClipFromPoseFn<TPose>;
-    /** Draws the whole subtree again under each affine it returns, on top of
-     *  the original, which still draws once as authored. The copies are paint,
-     *  not nodes: nothing stores them, so they follow every edit to the
-     *  children, and a pick that lands on one answers with the child it copies.
-     *  A copy is a copy of the clipped content — the clip travels with it.
-     *  Re-evaluated each render; `null` or `[]` draws no copies. */
-    copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;
-    /** How this container arranges its children. Whenever the container's
-     *  child set or order changes, or its bounds change size, the scene hands
-     *  the change to the strategy — `depart` for children that left it,
-     *  `arrive` for children that joined it, `childPoses` otherwise — and records the poses it writes in the same
-     *  undo entry as the change. A drag reads it too: it is the layout `move`
-     *  reflows and drops against. */
-    layout?: LayoutStrategy<TPose>;
-    /** The unit system this container's contents are written in, and what one
-     *  of its base units is worth in the enclosing scope's. It covers the
-     *  children, not the container; `sceneUnitScopes` reads the chain. */
-    units?: UnitScope;
-}
-/** A node in the scene tree: either a leaf or a container. Re-exported
- *  publicly as `SceneNode`, to avoid colliding with the DOM's `Node`. */
-type Node<TData, TLayer extends string, TPose = RectPose> = LeafNode<TData, TLayer, TPose> | ContainerNode<TData, TLayer, TPose>;
-/** What `Scene.add` needs to mint a node. Everything except the id is
- *  required; the id is generated unless one is supplied. */
-interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
-    kind: 'leaf' | 'container';
-    layer: TLayer;
-    pose: TPose;
-    data: TData;
-    parent?: NodeId | null;
-    index?: number;
-    /** Explicit id wins over the Scene's `generateId` and the kit default. */
-    id?: NodeId;
-    /** Mirrors `SceneNode.pickable`. Omit for the default, which is pickable. */
-    pickable?: boolean;
-    /** Mirrors `SceneNode.hidden`. */
-    hidden?: boolean;
-    /** Mirrors `SceneNode.locked`. */
-    locked?: boolean;
-    /** Only meaningful when `kind === 'container'`. Attach a clip-path function
-     *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */
-    clipFromPose?: ClipFromPoseFn<TPose>;
-    /** Mirrors `ContainerNode.copiesFromPose`; ignored for leaves. */
-    copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;
-    /** Mirrors `SceneNode.dependsOn`. */
-    dependsOn?: readonly NodeId[] | 'children';
-    /** Mirrors `SceneNode.derivePath`. Taken as a live function; its registry key is
-     *  looked up from it, never passed in. */
-    derivePath?: DerivePathFn<TPose, TData, TLayer>;
-    /** Mirrors `SceneNode.derivePose`, on the same terms as `derivePath`. */
-    derivePose?: DerivePoseFn<TPose, TData, TLayer>;
-    /** Mirrors `ContainerNode.layout`; ignored for leaves. */
-    layout?: LayoutStrategy<TPose>;
-    /** Mirrors `ContainerNode.units`; ignored for leaves. */
-    units?: UnitScope;
-}
-/** A custom scene mutation registered with `Scene.registerOp`: how to apply
- *  it and how to undo it. The pair is what makes it participate in history. */
-interface RegisteredOp<P> {
-    apply: (payload: P) => void;
-    revert: (payload: P) => void;
-    /** Opts this kind into coalescing under `UseSceneOptions.coalesceWindowMs`:
-     *  two entries of this kind that return the same key inside the window
-     *  merge, and undoing the merged entry calls `revert` with the first
-     *  payload only. Declare it only when `revert` restores an absolute state
-     *  (a stored "from" value), never for a relative payload such as a delta.
-     *  Omitted, or returning `undefined`, the op is always its own entry. */
-    coalesceKey?: (payload: P) => string | undefined;
-}
-/** Per-scene registry mapping string keys to live function references.
- *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
- *  Each function-field type has its own keyed map. */
-interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string> {
-    /** Maps registry keys to `clipFromPose` factory functions for container nodes. */
-    clipFromPose?: Readonly<Record<string, ClipFromPoseFn<TPose>>>;
-    /** Maps registry keys to `copiesFromPose` functions for container nodes. */
-    copiesFromPose?: Readonly<Record<string, CopiesFromPoseFn<TPose, TData, TLayer>>>;
-    /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */
-    derivePath?: Readonly<Record<string, DerivePathFn<TPose, TData, TLayer>>>;
-    /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */
-    derivePose?: Readonly<Record<string, DerivePoseFn<TPose, TData, TLayer>>>;
-    /** Maps registry keys to container layout strategies. */
-    layout?: Readonly<Record<string, LayoutStrategy<TPose>>>;
-}
-/**
- * Decides what one edit's changes to containers do to their children.
- * `arrivals` maps each container to the ids that joined it — by an `add`
- * under it or a `move` into it, whatever op or call made them — in the order
- * they arrived. `changed` names every container whose child set or order
- * changed, or whose pose changed size, arrivals included. Both are read once
- * the edit's other mutations have landed.
- *
- * Return the poses to write, in each node's stored frame; they become part of
- * the same edit, and so of the same undo step. An empty map writes nothing.
- * Return `null` to refuse: the whole edit is reverted (see
- * `SceneArrivalRefused`).
- *
- * Runs only for live edits. Undo, redo and a restored history replay the
- * arrangement that was decided the first time. With none installed, a scene
- * holding declared layouts (`ContainerNode.layout`) runs its own.
- */
-type SceneArrivalHandler<TPose> = (arrivals: ReadonlyMap<NodeId, readonly NodeId[]>, changed: ReadonlySet<NodeId>, 
-/** The nodes that left each container in the edit, by the container they
- *  left — removed, or moved out. */
-departures: ReadonlyMap<NodeId, readonly NodeId[]>) => ReadonlyMap<NodeId, TPose> | null;
-/**
- * The kit-owned scene tree: nodes, layers, and the undo history over both.
- *
- * A scene is logical, not visual — it says what exists and where, and nothing
- * about how it is painted. Every mutating method is undoable, and reads are
- * snapshots rather than live views. Nodes are addressed by `NodeId`; hold ids
- * across mutations, not node objects.
- *
- * Three type parameters keep it domain-agnostic: `TData` is the app's payload,
- * which the kit never inspects; `TPose` is the transform shape, `RectPose` by
- * default; `TLayer` is the union of layer names.
- */
-interface Scene<TData, TLayer extends string, TPose = RectPose> extends ScenePoseReports<TPose, Node<TData, TLayer, TPose>> {
-    readonly nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;
-    readonly roots: readonly NodeId[];
-    readonly layers: readonly LayerRecord<TLayer>[];
-    /** The registry this scene resolves node functions against — the consumer's
-     *  entries over the kit's. */
-    readonly registry: SceneRegistry<TPose, TData, TLayer>;
-    /** See {@link UseSceneOptions.composition}. */
-    readonly composition: PoseComposition<TPose>;
-    get(id: NodeId): Node<TData, TLayer, TPose> | undefined;
-    /** A token for the node `id` names right now, for telling one node from a
-     *  later one that reuses its id. It holds for as long as the node stays in
-     *  the scene, whatever edits it takes, and is different every time the id
-     *  enters the scene — by `add`, by an undo or redo that brings it back, or
-     *  by `loadState`. `undefined` when `id` is not in the scene. Compare tokens
-     *  for equality only; their order means nothing. */
-    incarnation(id: NodeId): number | undefined;
-    childrenOf(id: NodeId): readonly NodeId[];
-    ancestorsOf(id: NodeId): readonly NodeId[];
-    renderOrder(): Iterable<NodeId>;
-    /** The same layer-major sequence as {@link Scene.renderOrder}, as the nodes
-     *  themselves. Prefer this wherever the ids are only going to be resolved
-     *  back to nodes. Cached until a structural edit, so repeat calls hand back
-     *  the same array — a snapshot, not a live view, and not yours to mutate. */
-    renderOrderNodes(): readonly Node<TData, TLayer, TPose>[];
-    /** The nodes on one layer, in render order. Cached alongside
-     *  {@link Scene.renderOrderNodes} until a structural edit. A snapshot, not
-     *  a live view, and not yours to mutate. An unknown layer id yields an
-     *  empty array. */
-    nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];
-    /** A fresh id from this scene's `generateId`, or the kit default: the id
-     *  `add` would give a spec with none. For code that has to name a node
-     *  before it exists, such as one building an insert op. */
-    mintId(): NodeId;
-    add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;
-    /** Delete `id`, its **entire subtree**, and **everything that derives from**
-     *  any of those nodes — a node listing one of them in `dependsOn` goes too,
-     *  along with its own subtree, transitively. A dependent can live anywhere in
-     *  the tree, so this deletes nodes the caller never named and may unlink
-     *  several disjoint subtrees at once. Recorded as one undoable step; `undo()`
-     *  restores every one of them where it was, child order intact. */
-    remove(id: NodeId): void;
-    /** {@link remove} over several roots at once, as a **single** undoable step.
-     *  Ids resolve against the tree as it stands at the call, so an id that
-     *  another one would cascade away is absorbed rather than removed twice —
-     *  which is what makes it safe to pass a whole selection. Throws if any id is
-     *  not in the scene; an empty list does nothing and records no step. */
-    removeMany(ids: readonly NodeId[]): void;
-    /** Every node {@link removeMany} would take if given `ids`: each id, its
-     *  subtree, everything deriving from any of those, and those nodes' subtrees
-     *  in turn. Ids not in the scene come back unchanged.
-     *
-     *  A set, not a restore order: a dependent can be reached before the parent
-     *  it sits under, which is also in the closure. */
-    removalClosure(ids: readonly NodeId[]): readonly NodeId[];
-    update(id: NodeId, patch: {
-        data: TData;
-    }): void;
-    setPose(id: NodeId, pose: TPose): void;
-    /** Retag `id` to `layer`. On a **container this cascades**: every descendant
-     *  is moved to the same layer, recorded as a **single** undo step.
-     *
-     *  Invariants:
-     *  - **Layer floor** — a child may not render below its parent, so retagging
-     *    to a layer *below* the node's parent throws. Retagging to the parent's
-     *    layer or any higher one is allowed; a node with no parent is
-     *    unconstrained.
-     *  - **No-op elision** — setting the layer a node already has does nothing
-     *    and pushes **no** history entry. */
-    setLayer(id: NodeId, layer: TLayer): void;
-    /** Point `id` at a different set of dependencies — retargeting an edge's end
-     *  onto another node, or switching a container between an id list and
-     *  `'children'`. Recorded as one undoable step.
-     *
-     *  Order is significant: a derivation reads its dependencies positionally,
-     *  so `[b, a]` is not `[a, b]`. Ids need not be in the scene — a declared
-     *  dependency that appears later invalidates the node when it does, the same
-     *  as one declared at `add`. Passing `undefined` drops the declaration, after
-     *  which nothing cascades the node away.
-     *
-     *  **No-op elision** — declaring what the node already declares does nothing
-     *  and pushes no history entry. */
-    setDependsOn(id: NodeId, dependsOn: readonly NodeId[] | 'children' | undefined): void;
-    /** Give container `id` a different layout — a strategy, its key in
-     *  `SceneRegistry.layout`, or `null` for none — and re-arrange its children
-     *  under it, as one undoable step. Throws for a leaf, or a key the registry
-     *  does not hold. A registered layout is recorded by its key, so a
-     *  serialized history restores it; an unregistered one lives only as long
-     *  as the session.
-     *
-     *  **No-op elision** — setting the layout a container already has does
-     *  nothing and pushes no history entry. */
-    setLayout(id: NodeId, layout: LayoutStrategy<TPose> | string | null): void;
-    /** Reparent `id` under `parent` (or to a root when `parent` is `null`) at
-     *  `index` within the new sibling list, appending when `index` is omitted.
-     *  Siblings are reindexed. Recorded as one undoable step.
-     *
-     *  Rejected (throws) when:
-     *  - `parent` exists but is a **leaf**, not a container;
-     *  - the move would form a **cycle** — `parent` is `id` itself or one of
-     *    `id`'s own descendants;
-     *  - it would drop `id` **below its new parent's layer** (child may not
-     *    render below its parent).
-     *
-     *  `move(id, null)` — detaching to a root — is always allowed regardless of
-     *  layer, since a root has no parent to render beneath. */
-    move(id: NodeId, parent: NodeId | null, index?: number): void;
-    /** Shift `id` to `index` within its **current** parent's child list. Unlike
-     *  {@link move}, the parent never changes — only sibling order. */
-    reorder(id: NodeId, index: number): void;
-    /** Show or hide a layer. Hiding drops its nodes from the selection. */
-    setLayerVisible(layer: TLayer, visible: boolean): void;
-    /** Lock or unlock a layer. A locked layer still paints, but its nodes are
-     *  out of reach: picking and area selection pass over them, the selection
-     *  drops them, and every node mutation on them throws. Locking is never
-     *  blocked by the lock, and neither are the other layer operations. */
-    setLayerLocked(layer: TLayer, locked: boolean): void;
-    /** Set or clear (`undefined`) a layer's parallax — see
-     *  `LayerRecord.parallax`. Undoable; an animation tweening it writes inside
-     *  {@link Scene.untracked} so no frame becomes an undo step. */
-    setLayerParallax(layer: TLayer, parallax: ParallaxOpts | undefined): void;
-    /** Whether `id` is locked: it or an ancestor carries `locked`, or sits on a
-     *  locked layer. A lock covers its whole subtree, whatever layers the
-     *  descendants are tagged to. An id not in the scene is not locked. */
-    isLocked(id: NodeId): boolean;
-    /** Whether `id` is not drawn: its own layer is hidden, or it or an ancestor
-     *  carries `hidden`. A hidden layer hides only the nodes tagged to it. An
-     *  id not in the scene is not hidden. */
-    isHidden(id: NodeId): boolean;
-    /** Hide or show node `id` and its subtree — see `SceneNode.hidden`. One
-     *  undo step; hiding drops the subtree from the selection. Never blocked by
-     *  a lock, and setting what the node already has records nothing. */
-    setHidden(id: NodeId, hidden: boolean): void;
-    /** Lock or unlock node `id` and its subtree — see `SceneNode.locked`. One
-     *  undo step; locking drops the subtree from the selection. Never blocked
-     *  by a lock, and setting what the node already has records nothing. */
-    setLocked(id: NodeId, locked: boolean): void;
-    /** Run `fn` with the lock guard lifted, for a programmatic edit that has to
-     *  reach a locked node. Undo and redo never need it. */
-    unlocked<T>(fn: () => T): T;
-    addLayer(spec: AddLayerSpec<TLayer>): void;
-    /** Drop a user layer and every node tagged to it, as one undoable step.
-     *  Removal cascades, so this also deletes nodes **on other layers** that
-     *  derive from a node on this one. */
-    removeLayer(layer: TLayer): void;
-    renameLayer(layer: TLayer, name: string): void;
-    moveLayer(layer: TLayer, index: number): void;
-    registerOp<P>(kind: string, handler: RegisteredOp<P>): void;
-    recordOp<P>(op: {
-        kind: string;
-        payload: P;
-    }): void;
-    /** Install (or clear with `null`) the active-journal accessor after scene
-     *  construction, for a journal source built with `scene.history` as a
-     *  dependency. Overrides any `getActiveJournal` set in `UseSceneOptions`. */
-    setActiveJournalAccessor(fn: (() => _weasel_js_history.Journal | null) | null): void;
-    /** Install what the scene does when nodes join a container, replacing any
-     *  handler installed before; `null` removes it. Returns a function that
-     *  removes this handler, and does nothing once another has replaced it.
-     *  See {@link SceneArrivalHandler}. */
-    setArrivalHandler(handler: SceneArrivalHandler<TPose> | null): () => void;
-    /** Apply a batch of ops against `adapter` as one undo entry.
-     *
-     *  The entry holds the scene writes the ops made, as a direct call records
-     *  them, and beside them any op that wrote no scene state, bound to
-     *  `adapter`. Undo restores those writes; it does not call an op's
-     *  `invert()` or the adapter again. **What an op states is not recorded**:
-     *  one applied over a document that already holds its result, as after an
-     *  `untracked` preview, records a write from that pose to itself, and undo
-     *  goes nowhere. Put the document back first.
-     *
-     *  The entry lands in the open `batch` when there is one, else on the
-     *  active journal, else on the scene's own history, where it can coalesce
-     *  under `coalesceWindowMs` with one whose ops' keys match.
-     *
-     *  Returns false when the arrival handler refused the batch: it is reverted
-     *  and unrecorded. Inside `batch` it is true; that batch may still refuse. */
-    applyBatch(ops: Op[], label: string, adapter: unknown): boolean;
-    /** The transient set of active ids — "operate on these N as a unit".
-     *  Shared by every view over this scene unless a view supplies its own
-     *  (see `CanvasView.selection`). Not document content: it never appears
-     *  in `toJSON`. It does ride on history entries, so undo and redo put
-     *  back the selection an edit was made under; changing it is never an
-     *  undo step of its own. Removing a node deselects it. */
-    getSelection(): readonly NodeId[];
-    setSelection(ids: readonly NodeId[]): void;
-    /** Per-node pose / alpha overrides the render and hit-test paths read
-     *  through. Like {@link Scene.getSelection} this is not document content:
-     *  writes are never recorded, never serialized, and do not bump
-     *  {@link Scene.getVersion}. See {@link PoseOverrides}. */
-    readonly overrides: PoseOverrides<TPose>;
-    /** The scene's undo/redo engine, in the shape `@weasel-js/history` defines.
-     *  Mutating members route through
-     *  the scene's own wrappers, so an undo driven through this bumps
-     *  {@link Scene.getVersion} and notifies subscribers exactly as
-     *  {@link Scene.undo} does; `getVersion` / `subscribe` on it report the
-     *  engine's history version, not the scene's. */
-    readonly history: History;
-    undo(): boolean;
-    redo(): boolean;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    batch<T>(label: string, fn: () => T): T;
-    /** The layout container `id` declares, or `null` for a leaf or a
-     *  container that declares none. */
-    layoutOf(id: NodeId): LayoutStrategy<TPose> | null;
-    /** Declare the unit scope of container `id`, or clear it with `null`. */
-    setUnits(id: NodeId, units: UnitScope | null): void;
-    /** Run `fn` with every mutation applied but none recorded — for writes
-     *  that are not edits, such as a simulation stepping poses each frame.
-     *  Undo and redo move between recorded states and never restore an
-     *  untracked write; the next recorded change starts from whatever the
-     *  untracked writes left, so undoing it lands there. A `batch` inside
-     *  records nothing; inside a `batch`, these writes stay out of its entry.
-     *  Notifies once, reverts `fn`'s writes if it throws, and throws on
-     *  `applyBatch` and `history.apply` / `applyOps`, which exist to record. */
-    untracked<T>(fn: () => T): T;
-    /** Read-only snapshot of every history entry currently reachable from
-     *  the present state. Oldest applied first, then redoable entries in
-     *  the order they'd be re-applied. Each entry id is stable. */
-    historyEntries(): readonly {
-        id: string;
-        label: string;
-    }[];
-    /** Index of the "current state". Equals the count of applied entries;
-     *  `0` means "nothing applied" (initial). */
-    historyIndex(): number;
-    /** Jump to the given history index, clamped to [0, total]. Returns true
-     *  if any movement occurred. */
-    jumpToHistoryIndex(index: number): boolean;
-    /** Snapshot the undo/redo history in a JSON-serializable form (the
-     *  engine's `SerializedHistory`, marked with the scene's recorded form).
-     *  An entry holds the scene's own ops, whichever way the edit was made.
-     *  An op handed to `applyBatch` that wrote no scene state is held as
-     *  itself, and an entry with a nameless one is dropped. Payload
-     *  JSON-safety (e.g. typed arrays inside poses) is the caller's concern.
-     *  Do not call mid-`batch` — the open batch's ops are not yet recorded. */
-    serializeHistory(): SerializedSceneHistory;
-    /** Replace the undo/redo history from a `serializeHistory()` snapshot.
-     *  Call on a scene whose node/layer state already matches the snapshot's
-     *  head state (i.e. right after `loadState` from the paired scene
-     *  snapshot); node state is NOT mutated. Ops re-registered via
-     *  `registerOp` before this call round-trip; unknown kinds become no-op
-     *  placeholders; external ops rebuild via the global op-factory registry
-     *  and replay against the `setHistoryAdapter` accessor. Restored entries
-     *  never coalesce with new ones. Notifies once. A snapshot that is not in
-     *  the current recorded form (see `SCENE_HISTORY_FORM`) is dropped:
-     *  the history is left as it was. Do not call mid-`batch`:
-     *  the stacks are replaced underneath the open batch, whose eventual
-     *  flush would graft onto (and evict against) the restored stacks. */
-    restoreHistory(snapshot: SerializedHistory): void;
-    /** Install (or clear with `null`) the accessor for the adapter that
-     *  RESTORED external ops apply against on undo/redo: the ops handed to
-     *  `applyBatch` that wrote no scene state, such as a selection change,
-     *  rebuilt from a `restoreHistory` snapshot. Resolved lazily at each
-     *  apply, so wiring order relative to `restoreHistory` doesn't matter.
-     *  Live `applyBatch` entries are unaffected (they bind their call-site
-     *  adapter). If unset when a restored op applies, the op is a debug-warned
-     *  no-op. */
-    setHistoryAdapter(fn: (() => unknown) | null): void;
-    /** Snapshot the current scene state to a JSON-serializable shape.
-     *  History (undo/redo stacks) is NOT captured. Function fields like
-     *  `ContainerNode.clipFromPose` are translated to string keys via the
-     *  scene's registry; throws if any function field has no matching key. */
-    toJSON(): SerializedScene<TData, TLayer, TPose>;
-    /** Replace this scene's entire node + layer state in place from a snapshot
-     *  produced by `toJSON()`. Unlike `sceneFromJSON`, the existing Scene
-     *  instance is preserved — holders such as `<SceneCanvas>` keep their
-     *  reference. History (undo/redo) is cleared, matching `sceneFromJSON`.
-     *  Bumps `getVersion()` and notifies subscribers exactly once. Selected
-     *  ids the snapshot does not hold leave the selection, and every pose
-     *  override is cleared.
-     *
-     *  Throws inside any other edit — `batch`, `untracked`, `applyBatch`, an
-     *  undo — which would revert to a state this replaces. Throws on an unsupported version or unknown registry/layer ids; on a
-     *  malformed snapshot the scene is left empty or partially populated (callers should treat a
-     *  `loadState` throw as fatal and reload). Snapshots from `toJSON()` are
-     *  always well-formed. */
-    loadState(json: SerializedScene<TData, TLayer, TPose>): void;
-    subscribe(listener: () => void): () => void;
-    /** Monotonically increasing version. Snapshot for `useSyncExternalStore`. */
-    getVersion(): number;
-}
-
 /** Pixel dimensions of the canvas viewport. */
 interface ViewportDims {
     width: number;
@@ -1852,6 +995,9 @@ interface TransientPath {
     path: Path;
     /** Omitted reads as `'chrome'`. */
     role?: OverlayRole;
+    /** Paint the path wears, drawn in place of the role's fill and under the
+     *  role's outline: a result shown as it will look once made. */
+    paint?: PathPaint;
 }
 /** How one role reads. The stroke is one screen pixel wide at any zoom. */
 interface PathOverlayStyle {
@@ -1959,18 +1105,6 @@ interface PreviewPathsDep {
     show(paths: readonly TransientPath[]): () => void;
 }
 
-/** The snap readout's colors and line width, for a mark that sets no `color`. */
-interface SnapReadoutStyle {
-    /** Points, lines and their labels. Default orange, as the path marker. */
-    color?: string;
-    /** Gap and distance marks. Default blue, as the guides. */
-    gapColor?: string;
-    /** Stroke width in screen px. Default 1. */
-    lineWidth?: number;
-}
-/** A screen-space layer drawing the marks in `store`, redrawn when they change. */
-declare function createSnapReadoutLayer(store: SnapOutcomeStore, style?: SnapReadoutStyle): RenderLayer<unknown>;
-
 /** The `snap` dep: what a drawn or dragged point locks to. */
 
 type Point$4 = {
@@ -2004,6 +1138,9 @@ interface SnapBegin {
     press: Point$4;
     /** The subject, whose geometry offers no targets. */
     ids?: readonly string[];
+    /** The container a subject not yet in the scene lands in: an insert's
+     *  target. Absent for the top of the tree, or a gesture with `ids`. */
+    parent?: string;
     /** Resize: the sides the drag pins. An axis left `free` is an edge handle. */
     handle?: ResizeAnchor;
     /** Resize: the box `handle` belongs to. Default: the subject's drawn box,
@@ -2027,6 +1164,13 @@ interface SnapBegin {
     /** How the camera's world maps into the parallax plane the gesture's points
      *  are in, read each frame; absent or null in the camera's own world. */
     plane?: () => PlaneMap | null;
+    /** Sources asked for this gesture only, after the canvas's own, under the
+     *  same ranking; one sharing an id with a source still asked throws. Their
+     *  points are 2D world coordinates, so a 3D host does not take them. */
+    sources?: readonly SnapSource[];
+    /** Ids of sources this gesture does not ask: listed, registered or a
+     *  canvas default. */
+    omit?: readonly string[];
 }
 /** The snap roles held this frame. */
 interface SnapMods {
@@ -2126,6 +1270,12 @@ interface SnapCollect<P = Point$3> {
     /** `id`'s drawn box, measured as `box` is. Absent in a host with no 2D
      *  scene. */
     drawnBox?(id: string): FramedBox | undefined;
+    /** The subject: the nodes the gesture moves or resizes. Absent for a
+     *  gesture with none, such as drawing a new shape. */
+    ids?: readonly string[];
+    /** Where a gesture with no subject yet puts what it draws: the container a
+     *  new node lands in. Absent for the top of the tree. */
+    parent?: string;
     /** Nodes that offer no targets: what the gesture moves. */
     exclude: readonly string[];
     /** Only these nodes offer targets. */
@@ -2241,11 +1391,22 @@ interface SceneCanvasSnap {
      *  guide snaps: a pose neither a rect nor a `Path` needs its own. Default
      *  `AUTO_ORIGIN_PROJECTION`. */
     originProjection?: OriginProjection<unknown>;
-    /** Whether the snap marks are drawn. Default `true`. */
+    /** Whether the canvas draws the snap marks. Default `true`. With `false`
+     *  the marks are still written to the `snapReadout` dep's store, for a
+     *  layer of the consumer's own. */
     readout?: boolean;
     /** The readout's default colors and line width, for a mark that sets no `color`. */
     readoutStyle?: SnapReadoutStyle;
 }
+/** The snap readout's colors and line width, for a mark that sets no `color`. */
+interface SnapReadoutStyle {
+    /** Points, lines and their labels. Default orange, as the path marker. */
+    color?: string;
+    /** Gap and distance marks. Default blue, as the guides. */
+    gapColor?: string;
+    /** Stroke width in screen px. Default 1. */
+    lineWidth?: number;
+}
 
 type Point$2 = {
     x: number;
@@ -2461,6 +1622,28 @@ declare function useDecayLoop(): {
     cancel: () => void;
 };
 
+/** A node as a transform frame previews it: its stored pose, and its data where that changes. */
+interface TransformPreviewNode {
+    id: string;
+    pose: unknown;
+    data?: unknown;
+}
+/**
+ * Something that changes other nodes along with a whole-node transform — a
+ * move, resize, rotate, flip, align, distribute, or nudge. The
+ * `transformFollowers` dep holds every one, and each transform runs them all,
+ * in order.
+ */
+interface TransformFollower {
+    /** The other nodes a drag's frame changes, given the stored pose the frame
+     *  puts each transformed node in: what `finish` would commit for it.
+     *  `data` holds the data the followers before this one previewed, by id. */
+    preview(frame: ReadonlyMap<string, unknown>, data: ReadonlyMap<string, unknown>): readonly TransformPreviewNode[];
+    /** `ops`, the batch so far, with this follower's ops added after it; null
+     *  when it refuses the transform. */
+    finish(ops: readonly Op[], label: string): Op[] | null;
+}
+
 /**
  * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)
  * share: what their committed batch is called in history, whether it is
@@ -2730,6 +1913,16 @@ interface PathEditFinishCtx {
     /** The nodes that list `id` in their `dependsOn`, directly or through others. */
     dependents(id: string): readonly string[];
 }
+/**
+ * The scene as {@link PathEditExtension.finishTransform} reads it: `node` and
+ * `path` answer each node as the transform leaves it, `before` as it was.
+ */
+interface PathTransformFinishCtx extends Omit<PathEditFinishCtx, 'id'> {
+    /** The nodes the transform moves, resizes or turns. */
+    ids: readonly string[];
+    /** A node's committed editable path before the transform, in world space; null when it has none. */
+    before(id: string): PolygonPath | null;
+}
 /** One feature's share of path edit. Every member is optional. */
 interface PathEditExtension {
     /** Names it as a {@link PathEditMark}'s owner. Unique per canvas. */
@@ -2765,6 +1958,14 @@ interface PathEditExtension {
         pose: unknown;
         data: unknown;
     }, worldPath: PolygonPath, origins?: readonly (PointOrigin | null)[], ctx?: PathEditFinishCtx): FinishedPathEdit | null;
+    /**
+     * The other nodes a whole-node transform — a move, resize, rotate, flip or
+     * nudge — changes along with the nodes it transforms, so whatever this
+     * extension keeps true across nodes holds; committed in the transform's
+     * history entry. Null when the transform should not happen. An entry
+     * naming a node the transform itself moves is ignored.
+     */
+    finishTransform?(ctx: PathTransformFinishCtx): readonly PathEditOther[] | null;
     /** How path edit reads and writes the nodes whose `data.representation`
      *  is of its kind. */
     representation?: PathRepresentation;
@@ -2930,6 +2131,10 @@ interface IngestCtx {
     /** The kit insert dep — id/layer/undoable-op supplied; the canonical way
      *  for a handler to mint a node (`insert.commit(bounds, { kind, ... })`). */
     insert: InsertDep;
+    /** The canvas's snap dep, for a handler that places what it inserts where a
+     *  gesture would: begin a session, take `at()`, `end()`. Its points are ctx
+     *  coordinates: world on a 2D canvas, screen in a 3D host. */
+    snap?: SnapDep;
     /** Raw op commit for handlers that build their own ops. */
     applyOps(ops: Op[], label?: string): void;
     scene: Scene<unknown, string, unknown>;
@@ -2964,7 +2169,10 @@ interface ContentHandlerEntry {
     /** Stable identifier — used for unregistration and debugging
      *  (`'kit:image'`, `'app:csv'`). */
     id: string;
-    /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. */
+    /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. A drop
+     *  or paste keeps string flavors of any exact MIME named here or in
+     *  `types` while the handler is registered, so a handler can claim a drag
+     *  from the app's own UI by a type of its own. */
     match: string | string[] | ((item: IngestItem) => boolean);
     /** For a predicate `match`: the MIME globs it could say yes to. A drag
      *  still in flight shows its MIMEs and no contents, so a predicate cannot be
@@ -3123,6 +2331,29 @@ interface InsertLive {
     gesture: unknown;
 }
 
+/**
+ * Layout-strategy lookup by container id, consumed by `moveAction` to run
+ * the drag-time reflow pass. Sourced by `<SceneCanvas>` from the layout each
+ * container declares on its scene node. `getLayout` returns null for a
+ * container that declares none, so the reflow pass is a no-op then.
+ */
+interface LayoutDep {
+    getLayout(containerId: string): LayoutStrategy<unknown> | null;
+    /** Which container wins when several contain the drop point. Default
+     *  `'innermost'`. */
+    dropTarget?: LayoutDropTargetMode;
+    /** Carries displaced siblings to their slots over time. Absent, they snap. */
+    reflow?: ReflowTransition<unknown> | null;
+}
+/**
+ * Whether the nodes `ids` may be dropped into the container `parent`. A move
+ * consults it before reparenting anything: reparent-on-drop passes over a
+ * refused container to the nearest one around it that admits them, and the
+ * layout drop treats a refused layout container as if it were not there.
+ * Absent, every container takes any drop.
+ */
+type CanDropIntoDep = (parent: string, ids: readonly string[]) => boolean;
+
 /**
  * The deps behind text editing, the clipboard, and Slice.
  */
@@ -3378,20 +2609,6 @@ interface ResizePolicy<TPose> extends GestureLifecycleOptions {
      *  resize isn't wanted. */
     expandIds: (ids: string[]) => string[];
 }
-/**
- * Layout-strategy lookup by container id, consumed by `moveAction` to run
- * the drag-time reflow pass. Sourced by `<SceneCanvas>` from the layout each
- * container declares on its scene node. `getLayout` returns null for a
- * container that declares none, so the reflow pass is a no-op then.
- */
-interface LayoutDep {
-    getLayout(containerId: string): LayoutStrategy<unknown> | null;
-    /** Which container wins when several contain the drop point. Default
-     *  `'innermost'`. */
-    dropTarget?: LayoutDropTargetMode;
-    /** Carries displaced siblings to their slots over time. Absent, they snap. */
-    reflow?: ReflowTransition<unknown> | null;
-}
 
 /**
  * The names an action may declare in `requires`, and what each resolves to.
@@ -3468,6 +2685,9 @@ declare module '@weasel-js/routing' {
         /** Edit-anchors dep — narrow read/write of one polygon's path. If
          *  absent, `editAnchorsAction`'s `start` returns an empty handle (no-op). */
         editAnchors: EditAnchorsDep;
+        /** What changes other nodes along with a whole-node transform, in order;
+         *  add one with `useTransformFollower`. Absent: only what it transforms changes. */
+        transformFollowers?: readonly TransformFollower[];
         /** The transforms a path being edited should stay its own image under.
          *  Absent: an anchor drag moves only what is dragged. */
         pathSymmetry?: PathSymmetryDep;
@@ -3522,6 +2742,8 @@ declare module '@weasel-js/routing' {
          * Optional: absent (or all-null) → `moveAction` skips reflow.
          */
         layout?: LayoutDep;
+        /** Which containers a move may drop into; see {@link CanDropIntoDep}. */
+        canDropInto?: CanDropIntoDep;
         /**
          * Slice dep — the commit for the Slice action. `<SceneCanvas>` publishes
          * `useSliceDepSource`; a consumer overrides it with `useSliceDep`.
@@ -3578,4 +2800,4 @@ declare module '@weasel-js/routing' {
     }
 }
 
-export { type CreateOutlinesAdapter as $, type AddNodeSpec as A, type LayerGroup as B, type ContentHandlerEntry as C, type Dims as D, type EditAnchorsDep as E, type FitViewToBoundsOptions as F, type GestureLifecycleOptions as G, type HandleLocks as H, type InertiaConfig as I, type SerializedScene as J, type GeometryProjection as K, type LayoutFrame as L, type InsertNodeFactory as M, type Node as N, type InsertPaint as O, type PathEditMark as P, type SvgIngestOptions as Q, type RectPose as R, type Scene as S, type SceneCanvasSnap as T, type Affordance as U, type ViewAnimationOptions as V, type AffordanceRegion as W, type AffordanceBinding as X, type CommonAffordanceScratch as Y, type TextOverflow as Z, _resetPaintKindsForTests as _, type PathEditExtension as a, type PaintKind as a$, type PaintKindEntry as a0, type DerivePoseFn as a1, type DerivePathFn as a2, type DerivedDep as a3, type PathEditTarget as a4, type PathSymmetryDep as a5, type BooleanOpOptions as a6, type BooleansAdapter as a7, type BooleanOp as a8, type PathPaint as a9, type FinishedEditFrame as aA, type FinishedPathEdit as aB, GEOMETRY_BOUND_DATA as aC, type HandleLock as aD, type HitTestView as aE, IDENTITY_POSE_COMPOSITION as aF, type IngestCtx as aG, type IngestionDep as aH, type InsertDep as aI, type InsertEnds as aJ, type InsertExtras as aK, type InsertIntoDep as aL, type InsertLive as aM, type LassoSelectDep as aN, type LayerCommandCache as aO, type LayerDrawFailure as aP, type LayerDrawSpan as aQ, type LayerRecord as aR, type LayerRetainPolicy as aS, type LayoutDep as aT, type LayoutMove as aU, type LeafNode as aV, type Locus as aW, type MinSize as aX, type NodeAtPointDep as aY, type OutlinePathSpec as aZ, PATH_OVERLAY_ROLES as a_, type BooleanOpResult as aa, type BooleanStrokes as ab, type SnapMods as ac, type SourceCandidate as ad, type SnapProbeAt as ae, type SnapCollect as af, type SnapMark as ag, type SnapDep as ah, type SnapOutcome as ai, type AddLayerSpec as aj, type AngleCandidate as ak, type AngleCollect as al, type AnimateToBoundsOptions as am, type AreaSelectDep as an, type Bivariant as ao, type BooleanOpPreview as ap, type BooleanPreviewPiece as aq, type ClipFromPoseFn as ar, type ClipboardDep as as, type ClipboardIngestCtx as at, type ContainerNode as au, type CopiesFromPoseFn as av, type CreateOutlinesResult as aw, type CustomPaintContext as ax, DEFAULT_LAYER_RETAIN as ay, type DecayLoopConfig as az, type SnapSource as b, listPaintKinds as b$, type PaintKindEditorProps as b0, type PaintKindFamily as b1, type PaintKindLoader as b2, type PanBounds as b3, type PathEditDrag as b4, type PathEditDragStart as b5, type PathEditFinishCtx as b6, type PathEditHandleMove as b7, type PathEditMarksCtx as b8, type PathEditOther as b9, type SvgUnpacker as bA, type SystemLayerRecord as bB, type TextEditDep as bC, type TextNodeData as bD, type TransientPath as bE, type UserLayerRecord as bF, VIEW_ANIMATION_KEY as bG, type ViewAnimationApi as bH, type ViewApi as bI, type ViewChannel as bJ, applyBooleanOp as bK, applyCreateOutlines as bL, asNodeId as bM, asPaint as bN, composeWorldPose as bO, composesFrames as bP, createPathOverlay as bQ, createSnapOutcomeStore as bR, createSnapReadoutLayer as bS, depsUnchanged as bT, drawLayers as bU, drawOneLayer as bV, fitViewToBounds as bW, getPaintKind as bX, isLayerPainted as bY, isLayerVisible as bZ, listGradientKinds as b_, type PathEditPart as ba, type PathEditStore as bb, type PathForm as bc, type PathOverlay as bd, type PathOverlayOptions as be, type PathOverlayStyle as bf, type PathRepresentation as bg, type PoseClosure as bh, type PoseHold as bi, type PoseOverride as bj, type PoseWriteOrigin as bk, type PreviewPathsDep as bl, type RemovedNode as bm, type ResizePolicy as bn, SCENE_HISTORY_FORM as bo, STICKY_DEFAULTS as bp, type SceneArrivalHandler as bq, type SerializedLayer as br, type SerializedNode as bs, type SerializedSceneHistory as bt, type SnapBegin as bu, type SnapEdge as bv, type SnapEdges as bw, type SnapMarks as bx, type SnapReadoutDep as by, type SnapReadoutStyle as bz, type SnapGesture as c, minSizeOf as c0, paintKindOf as c1, paintKindRegistry as c2, paintedLayers as c3, paintsLayer as c4, paletteInsertPaint as c5, pathPaintOf as c6, patternFamily as c7, previewBooleanOp as c8, rebaseLocalPose as c9, registerContentHandler as ca, registerPaintKind as cb, registerPaintKindLoader as cc, seedTile as cd, stickyData as ce, stickyNodeFactory as cf, subscribeToSources as cg, switchGradientKind as ch, textBoxOf as ci, useDecayLoop as cj, useViewAnimation as ck, useViewAnimationOn as cl, viewAxes as cm, withoutGeometryBoundData as cn, type SnapConstrain as d, type SnapResizeBox as e, type SnapGeometry as f, type SnapOutcomeStore as g, type SnapSession as h, type SystemLayerSpec as i, type RegisteredOp as j, type SceneRegistry as k, type PoseComposition as l, type RenderLayer as m, type LayerHit as n, type PoseAdapter as o, type ViewportDims as p, type RedrawSource as q, type EditAnchorsParams as r, type SliceDep as s, type StickyStyle as t, type PoseOverrides as u, type PoseRemoval as v, type PoseWrite as w, type ScenePoseReports as x, type AnchorMarkerShape as y, type ChromeState as z };
+export { type SnapCollect as $, type AnchorMarkerShape as A, type PathEditTarget as B, type ContentHandlerEntry as C, type Dims as D, type EditAnchorsDep as E, type FitViewToBoundsOptions as F, type GestureLifecycleOptions as G, type HandleLocks as H, type InertiaConfig as I, type FinishedEditFrame as J, type PathSymmetryDep as K, type LayerHit as L, type BooleanOpOptions as M, type BooleansAdapter as N, type BooleanOp as O, type PathEditMark as P, type PathPaint as Q, type RenderLayer as R, type SnapSource as S, type TransformFollower as T, type BooleanOpResult as U, type ViewAnimationOptions as V, type BooleanStrokes as W, type SnapMods as X, type SourceCandidate as Y, type SnapProbeAt as Z, _resetPaintKindsForTests as _, type PathEditExtension as a, type SnapEdges as a$, type SnapMark as a0, type SnapDep as a1, type SnapOutcome as a2, type SnapReadoutStyle as a3, type AngleCandidate as a4, type AngleCollect as a5, type AnimateToBoundsOptions as a6, type AreaSelectDep as a7, type BooleanOpPreview as a8, type BooleanPreviewPiece as a9, type NodeAtPointDep as aA, type OutlinePathSpec as aB, PATH_OVERLAY_ROLES as aC, type PaintKind as aD, type PaintKindEditorProps as aE, type PaintKindFamily as aF, type PaintKindLoader as aG, type PanBounds as aH, type PathEditDrag as aI, type PathEditDragStart as aJ, type PathEditFinishCtx as aK, type PathEditHandleMove as aL, type PathEditMarksCtx as aM, type PathEditOther as aN, type PathEditPart as aO, type PathEditStore as aP, type PathForm as aQ, type PathOverlay as aR, type PathOverlayOptions as aS, type PathOverlayStyle as aT, type PathRepresentation as aU, type PathTransformFinishCtx as aV, type PreviewPathsDep as aW, type ResizePolicy as aX, STICKY_DEFAULTS as aY, type SnapBegin as aZ, type SnapEdge as a_, type CanDropIntoDep as aa, type ClipboardDep as ab, type ClipboardIngestCtx as ac, type CreateOutlinesResult as ad, type CustomPaintContext as ae, DEFAULT_LAYER_RETAIN as af, type DecayLoopConfig as ag, type FinishedPathEdit as ah, GEOMETRY_BOUND_DATA as ai, type HandleLock as aj, type HitTestView as ak, type IngestCtx as al, type IngestionDep as am, type InsertDep as an, type InsertEnds as ao, type InsertExtras as ap, type InsertIntoDep as aq, type InsertLive as ar, type LassoSelectDep as as, type LayerCommandCache as at, type LayerDrawFailure as au, type LayerDrawSpan as av, type LayerRetainPolicy as aw, type LayoutDep as ax, type Locus as ay, type MinSize as az, type SnapGesture as b, type SnapMarks as b0, type SnapReadoutDep as b1, type SvgUnpacker as b2, type TextEditDep as b3, type TextNodeData as b4, type TransformPreviewNode as b5, type TransientPath as b6, VIEW_ANIMATION_KEY as b7, type ViewAnimationApi as b8, type ViewApi as b9, registerPaintKindLoader as bA, seedTile as bB, stickyData as bC, stickyNodeFactory as bD, subscribeToSources as bE, switchGradientKind as bF, textBoxOf as bG, useDecayLoop as bH, useViewAnimation as bI, useViewAnimationOn as bJ, viewAxes as bK, withoutGeometryBoundData as bL, type ViewChannel as ba, applyBooleanOp as bb, applyCreateOutlines as bc, asPaint as bd, createPathOverlay as be, createSnapOutcomeStore as bf, depsUnchanged as bg, drawLayers as bh, drawOneLayer as bi, fitViewToBounds as bj, getPaintKind as bk, isLayerPainted as bl, isLayerVisible as bm, listGradientKinds as bn, listPaintKinds as bo, minSizeOf as bp, paintKindOf as bq, paintKindRegistry as br, paintedLayers as bs, paintsLayer as bt, paletteInsertPaint as bu, pathPaintOf as bv, patternFamily as bw, previewBooleanOp as bx, registerContentHandler as by, registerPaintKind as bz, type SnapConstrain as c, type SnapResizeBox as d, type SnapGeometry as e, type SnapOutcomeStore as f, type SnapSession as g, type ViewportDims as h, type RedrawSource as i, type EditAnchorsParams as j, type SliceDep as k, type StickyStyle as l, type ChromeState as m, type LayerGroup as n, type GeometryProjection as o, type InsertNodeFactory as p, type InsertPaint as q, type SvgIngestOptions as r, type SceneCanvasSnap as s, type Affordance as t, type AffordanceRegion as u, type AffordanceBinding as v, type CommonAffordanceScratch as w, type TextOverflow as x, type CreateOutlinesAdapter as y, type PaintKindEntry as z };