@weasel-js/core 1.10.0 → 1.11.0

package/dist/depSchema-Cgfu_G9s.d.ts

@@ -0,0 +1,3581 @@
+import { TileKind, Paint, GradStop, TilePaint, Fill, Stroke, CommandFill, CommandStroke, CommandPaint } from '@weasel-js/paint';
+import { Reflection } from '@weasel-js/registry';
+import { ComponentType } from 'react';
+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 { 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 { 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 { 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;
+    height: number;
+}
+/** Options for {@link fitViewToBounds}. */
+interface FitViewToBoundsOptions {
+    /** Inset (in CSS px) around the bounds. Default 16. */
+    padding?: number;
+    /** Defaults to the kit-wide max zoom (`DEFAULT_MAX_ZOOM`). */
+    maxScale?: number;
+    /** Defaults to the kit-wide min zoom (`DEFAULT_MIN_ZOOM`). */
+    minScale?: number;
+    /**
+     * Fit mode:
+     * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.
+     * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.
+     * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.
+     */
+    mode?: 'contain' | 'fill' | 'stretch';
+    /**
+     * Where bounds that overflow the viewport on an axis sit, which happens when
+     * `minScale` stops the fit or `mode` is `'fill'`. `'center'` (default) shows
+     * their middle; `'start'` shows their left or top edge, inset by `padding`.
+     * An axis that fits is centered either way.
+     */
+    anchor?: 'center' | 'start';
+}
+/**
+ * Compute the target {@link View} that fits `bounds` (world space) inside
+ * `viewportDims` (CSS px). The bounds are centered in the viewport with
+ * uniform padding on all sides; the resulting scale is clamped to the
+ * configured min/max.
+ *
+ * Empty / zero-sized bounds or viewports cannot be fit — in that case this
+ * returns `currentView` unchanged and logs a `console.warn`.
+ */
+declare function fitViewToBounds(bounds: FramedBox, viewportDims: ViewportDims, currentView: View, opts?: FitViewToBoundsOptions): View;
+
+/**
+ * `Paint`'s discriminant, open on the string the way `ChromeId` is: the
+ * kinds the kit ships, plus whatever a consumer registers.
+ */
+type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | TileKind | 'texture' | (string & {});
+/**
+ * A set of kinds an editor offers as one choice. Kinds sharing a family show
+ * as a single segment in a kind bar, named by the family, and the member is
+ * picked inside that segment's body. The built-in tiles and `texture` are the
+ * `patternFamily`.
+ */
+interface PaintKindFamily {
+    id: string;
+    label: string;
+    /** Glyph for the family's segment. */
+    icon?: IconRef;
+}
+/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`
+ *  is the control that mounts it. */
+interface PaintKindEditorProps {
+    value: Paint;
+    onInput?(next: Paint): void;
+    onChange(next: Paint): void;
+}
+/**
+ * One paint kind: the renderer's draw slots, plus what an editor and a
+ * serializer read.
+ *
+ * `seed`, `label` and `colorOf` are the editor's slots and every kind has
+ * them. The rest are optional because a kind may not need them.
+ */
+interface PaintKindEntry extends PaintDrawKind {
+    label: string;
+    /** Glyph naming this kind in an editor's kind bar. A kind without one is
+     *  named by its `label`. */
+    icon?: IconRef;
+    /** The family this kind is offered under; see {@link PaintKindFamily}. A
+     *  kind without one is its own segment. */
+    family?: PaintKindFamily;
+    /** A paint of this kind seeded from a color — what an editor writes when a
+     *  consumer switches a solid to this kind. */
+    seed(fromColor: string): Paint;
+    /** The single color this paint shows, or `undefined` when it has none. */
+    colorOf(paint: Paint): string | undefined;
+    /** Editor slot. */
+    Editor?: ComponentType<PaintKindEditorProps>;
+    /**
+     * The stop list this paint reads as. With `fromStops`, it is what makes a
+     * kind a gradient: `listGradientKinds` returns the kinds carrying both, and
+     * `switchGradientKind` converts between any two of them through the list.
+     */
+    stopsOf?(paint: Paint): GradStop[];
+    /** A paint of this kind built from a stop list, in `bounds` units. The
+     *  converse of `stopsOf`; supply both or neither. */
+    fromStops?(stops: GradStop[]): Paint;
+    /**
+     * The `<defs>` entry backing a `url(#id)` reference.
+     *
+     * SVG has paint servers for two gradients and a pattern and nothing else, so
+     * a kind beyond those has no element to target: write a foreign-namespaced
+     * one under the `wzl:` prefix `@weasel-js/svg` declares on the root whenever
+     * a document holds such a paint. That package emits the fallback color
+     * beside the reference on its own, from `colorOf`.
+     */
+    toSvg?(id: string, fill: Paint): string;
+}
+/**
+ * A consumer's own paint, typed as a `Paint`.
+ *
+ * `Paint` stays a closed union: opening its discriminant would widen every
+ * built-in member and break the narrowing the kit's own branches depend on.
+ * A registered kind declares its own interface instead and passes it through
+ * here — the kit reads only `kind` and hands the whole object back to that
+ * kind's slots.
+ */
+declare function asPaint<T extends {
+    kind: string;
+}>(paint: T): Paint;
+
+/**
+ * The paint-kind registry — what makes `Paint` open. The built-in kinds
+ * are registered here at module load so an editor's kind bar can enumerate
+ * every kind through one list.
+ *
+ * Every entry is also handed to the renderer's own registry, which reads only
+ * its draw slots. A built-in kind has none: its render slot is a branch in the
+ * GL renderer and its serialize slot lives in `@weasel-js/svg`.
+ */
+
+/** The family the built-in tiles and `texture` are offered under. A consumer's
+ *  own pattern kind joins it by naming this as its `family`. */
+declare const patternFamily: PaintKindFamily;
+/** A tile paint seeded from a color. `units: 'bounds'` anchors the tile to the
+ *  node's box, so the texture travels with the shape. */
+declare function seedTile(kind: TileKind, color: string): TilePaint;
+/** Resolves with the entry for a kind that is loaded on first use. */
+type PaintKindLoader = () => Promise<PaintKindEntry>;
+/** Every registered paint kind, with the overrides each displaced. */
+declare const paintKindRegistry: Reflection<PaintKindEntry>;
+/** Register a paint kind. Returns a disposer that removes it. Re-registering an
+ *  existing id is an override; disposing it uncovers whatever it displaced. */
+declare function registerPaintKind(entry: PaintKindEntry): () => void;
+/**
+ * Declare a paint kind that is loaded the first time something looks it up,
+ * so its code stays out of the bundle until a paint of it appears — typically
+ * `() => import('./myKind').then((m) => m.myKindEntry)`.
+ *
+ * Until it lands the kind is unregistered: the renderer draws nothing for its
+ * paints, and every other reader treats it as unknown. Registering it fires
+ * `paintKindRegistry`'s subscribers. Call `warmPaintKinds` to load ahead of
+ * the first frame instead.
+ *
+ * A kind that is already registered never calls its loader. Returns a
+ * disposer that removes the loader.
+ */
+declare function registerPaintKindLoader(id: string, load: PaintKindLoader): () => void;
+/** The entry for `kind`, or `undefined`. A lookup that misses on a kind with
+ *  a loader starts that load; see {@link registerPaintKindLoader}. */
+declare function getPaintKind(kind: string | undefined): PaintKindEntry | undefined;
+/** Every registered kind, built-ins first, in registration order. The same
+ *  array until the registry changes. */
+declare function listPaintKinds(): readonly PaintKindEntry[];
+/** Every registered gradient kind — the ones that read as and build from a
+ *  stop list — in registration order. The same array until the registry
+ *  changes. */
+declare function listGradientKinds(): readonly PaintKindEntry[];
+/**
+ * `paint` retargeted to gradient kind `kind`, or `undefined` when either side
+ * is not a gradient kind.
+ *
+ * Between two of the stop gradients this is `withGradientKind`, which carries
+ * the geometry. Any other pair goes through the stop list — `stopsOf` on the
+ * way out, `fromStops` on the way in — keeping `interpolate` and `opacity`.
+ * Lossy wherever the kinds hold different information.
+ */
+declare function switchGradientKind(paint: Paint, kind: PaintKind): Paint | undefined;
+/** The registry entry for a paint, or `undefined` when its kind is unknown. */
+declare function paintKindOf(fill: Paint): PaintKindEntry | undefined;
+/** @internal Test helper — do not call from product code. */
+declare function _resetPaintKindsForTests(): void;
+
+/** The paint a path node wears, resolved: what an action that turns ink into
+ *  geometry reads from a node and tells a consumer to put on a result. */
+interface PathPaint {
+    /** `null` is no fill. */
+    fill: Fill | null;
+    /** Absent for no stroke. */
+    stroke?: Stroke;
+}
+/** {@link PathPaint} of a node that keeps its paint in `data.fill` and
+ *  `data.stroke`, as the built-in path painter draws it: a stroke with no
+ *  `paint` is none, and an undeclared fill is the default shape fill unless
+ *  the node is stroked. */
+declare function pathPaintOf(data: {
+    fill?: Fill | null;
+    stroke?: Stroke | null;
+}): PathPaint;
+
+/**
+ * Create Outlines: replace each selected text node with path nodes carrying
+ * its glyph outlines, giving up editability for geometry — the destructive
+ * conversion every vector editor has. One path per paint the text wears; one
+ * undoable batch; the replacement takes the text node's slot, so stacking
+ * order is unchanged.
+ */
+
+/** What a path minted by an outline action must carry — see
+ *  {@link CreateOutlinesAdapter.createPathNode}. */
+interface OutlinePathSpec extends PathPaint {
+    /** The parent the path goes under: the source's own, or the container
+     *  minted to hold a source's several paths. */
+    parent: string | null;
+}
+/** What `applyCreateOutlines` and `applyOutlineStroke` read and write through. */
+interface CreateOutlinesAdapter {
+    getSelection(): readonly NodeId[] | readonly string[];
+    /** The text node behind `id`, or `undefined` for anything else. */
+    getTextSource(id: NodeId): TextNodeSource | undefined;
+    /**
+     * Optional: the world-space path of the path node behind `id`, and the
+     * paint it wears. Outline Stroke reads both, and passes over a node that
+     * lacks either.
+     */
+    getWorldPath?(id: NodeId): Path | undefined;
+    getPaint?(id: NodeId): PathPaint | undefined;
+    /**
+     * Optional: the frame the node behind `id` draws its stroke in, as the
+     * matrix taking that frame to world (`poseFrameOf`); null or absent for a
+     * node drawn straight. Outline Stroke skews and stretches a world-width
+     * stroke with it. Without it every stroke is outlined in world.
+     */
+    getStrokeFrame?(id: NodeId): Affine | null | undefined;
+    /**
+     * Mint one path node of node `sourceId`'s outlines. `path` is in world
+     * space. The node must wear `spec`'s fill and stroke — a text whose runs
+     * differ in paint gets one path per paint, and a filled node whose stroke
+     * is outlined gets one for the fill and one for the stroke — and sit under
+     * `spec.parent`. The kit places it; only the consumer knows its data shape,
+     * so anything else of the source's `data` worth keeping is the adapter's to
+     * copy: onto this path when it stands alone in the source's slot, onto the
+     * container when `createContainerNode` minted one.
+     */
+    createPathNode(path: Path, sourceId: NodeId, spec: OutlinePathSpec): {
+        id: string;
+    };
+    /**
+     * Mint the container that holds one source's several paths, under `parent`.
+     * `bounds` is the world envelope of the paths. The kit puts the container in
+     * the source's slot and the paths inside it, back to front. Without this,
+     * the paths are laid flat in that slot instead.
+     */
+    createContainerNode?(sourceId: NodeId, spec: {
+        parent: string | null;
+        bounds: Rect;
+    }): {
+        id: string;
+    };
+    /** Full node for `id`, so undo restores the text node whole. */
+    getNode(id: string): {
+        id: string;
+    } | undefined | null;
+    /** The tree: each path is inserted at its source node's index among its
+     *  parent's children. */
+    getParent(id: string): string | null;
+    getChildren(parentId: string | null): string[];
+    applyOps?(ops: Op[], label?: string): void;
+    setSelection?(ids: NodeId[]): void;
+    insertNode?(node: {
+        id: string;
+    }, index?: number): void;
+    removeNode?(id: string): void;
+}
+/** Outcome of {@link applyCreateOutlines}. */
+type CreateOutlinesResult = 
+/** `resultIds` are what replaced the text nodes at their level — a path,
+ *  a container, or a run of flat paths each — which is also what is now
+ *  selected in the text nodes' place. */
+{
+    kind: 'applied';
+    resultIds: string[];
+}
+/** Nothing selected is text with ink. */
+ | {
+    kind: 'noop';
+    reason: 'no-text';
+}
+/** Some selected text has no outline geometry; nothing was changed. */
+ | {
+    kind: 'failed';
+    reason: 'text-outlines';
+    error: TextOutlinesError;
+};
+/**
+ * Convert every text node in the selection to outlines, as one batch labeled
+ * "Create Outlines". Other selected nodes are left alone and stay selected.
+ * All or nothing: if any text node's face cannot supply outlines the scene is
+ * untouched and the error comes back in the result.
+ */
+declare function applyCreateOutlines(adapter: CreateOutlinesAdapter): CreateOutlinesResult;
+
+/**
+ * What each selected node gives a Boolean operation: its path, its glyph
+ * outlines, or the region its ink covers once a stroke is counted.
+ */
+
+/**
+ * What a stroked operand gives a Boolean operation.
+ *
+ * - `'ignore'`: its path, as though it had no stroke.
+ * - `'unfilled'`: the region its stroke covers when it has no fill, as a line
+ *   or an open pencil stroke has none; its path when it is filled.
+ * - `'include'`: what it paints — its fill and its stroke together, or the
+ *   stroke alone when it has no fill.
+ *
+ * Any mode but `'ignore'` needs {@link BooleansAdapter.getPaint}.
+ */
+type BooleanStrokes = 'ignore' | 'unfilled' | 'include';
+/** Options for `applyBooleanOp`. */
+interface BooleanOpOptions {
+    /** Default `'ignore'`. */
+    strokes?: BooleanStrokes;
+    /** The view scale a `{ px }` stroke width resolves against: one number, or
+     *  the view's own scale per axis. Default 1. */
+    scale?: number | Scale2;
+}
+
+/**
+ * Pure action core for path boolean operations. Resolves the current
+ * selection into z-ordered paths, runs the chosen op, and dispatches a
+ * single batch of `Op`s (delete sources + insert results + set selection).
+ */
+
+/** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */
+type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';
+/** Adapter the hook and the pure core both consume. */
+interface BooleansAdapter {
+    getSelection(): readonly NodeId[] | readonly string[];
+    getWorldPath(id: NodeId): Path | undefined;
+    /**
+     * Optional: the text node behind `id`, for an id `getWorldPath` has no path
+     * for. Its glyph outlines (`textToPath`) become the operand, so text can be
+     * cut, united or intersected like any shape.
+     */
+    getTextSource?(id: NodeId): TextNodeSource | undefined;
+    /**
+     * Optional: the paint the path node behind `id` wears. An operation told to
+     * count strokes (`BooleanOpOptions.strokes`) reads it to learn whether the
+     * node is stroked and whether it is filled; without it every operand is its
+     * path alone.
+     */
+    getPaint?(id: NodeId): PathPaint | undefined;
+    /**
+     * Optional: the frame the node behind `id` draws its stroke in, as the
+     * matrix taking that frame to world (`poseFrameOf`); null or absent for a
+     * node drawn straight. A counted world-width stroke is skewed and stretched
+     * with it. Without it every stroke is outlined in world.
+     */
+    getStrokeFrame?(id: NodeId): Affine | null | undefined;
+    compareZ(a: NodeId, b: NodeId): number;
+    /**
+     * Mint a new node from a boolean-op result `Path`. `producedBy` names the
+     * op that synthesized it — adapters that store provenance (e.g. for a
+     * layer-panel icon) record it; others ignore the arg. `sourceId` is the
+     * source the result stands in for: the topmost, except that each piece of
+     * a Divide, Crop, Trim, or Merge names the topmost source it was cut from. Give the
+     * node that source's parent, or the kit's reorder cannot find it there.
+     * `paint` is passed when that source's stroke went into the geometry, and
+     * the node must wear it as given: wearing the source's stroke again would
+     * draw it twice. Without `paint`, give it that source's paint. The kit never
+     * reads a node's `data`: anything else the result should keep of its source,
+     * a name say, is the adapter's to copy from `sourceId`.
+     */
+    createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId, paint?: PathPaint): {
+        id: string;
+    };
+    /**
+     * The full object for an id. The delete ops capture it, so their `invert`
+     * (an insert) restores the complete object on undo.
+     */
+    getNode(id: NodeId): {
+        id: string;
+    } | undefined | null;
+    /**
+     * The tree. The kit reads each source's slot among its siblings through
+     * `getParent` and `getChildren`, and moves each result into the slot of
+     * the topmost source in its own source's parent through `setChildOrder`.
+     * `defaultCommitAdapter` supplies all three, and `getNode`.
+     */
+    getParent(id: string): string | null;
+    getChildren(parentId: string | null): string[];
+    setChildOrder(parentId: string | null, ids: string[]): void;
+    applyOps?(ops: Op[], label?: string): void;
+    setSelection?(ids: NodeId[]): void;
+    insertNode?(node: {
+        id: string;
+    }): void;
+    removeNode?(id: string): void;
+}
+/** Outcome reported back to callers (lets the hook surface no-op signals). */
+type BooleanOpResult = {
+    kind: 'applied';
+    resultIds: string[];
+} | {
+    kind: 'noop';
+    reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result';
+}
+/** A text operand had no outline geometry. Nothing was changed: an op that
+ *  quietly dropped the operand would commit a different shape than asked. */
+ | {
+    kind: 'failed';
+    reason: 'text-outlines';
+    error: TextOutlinesError;
+};
+/** One path a Boolean operation would make. */
+interface BooleanPreviewPiece {
+    path: Path;
+    /** The source the piece stands in for; see `BooleansAdapter.createPathNode`. */
+    sourceId: NodeId;
+    /** Set when that source's stroke went into `path`: the paint the piece wears. */
+    paint?: PathPaint;
+}
+/** What {@link previewBooleanOp} answers: the pieces, or why there are none. */
+type BooleanOpPreview = {
+    kind: 'pieces';
+    pieces: BooleanPreviewPiece[];
+} | Exclude<BooleanOpResult, {
+    kind: 'applied';
+}>;
+/**
+ * What {@link applyBooleanOp} would make of the selection, without minting a
+ * node or committing anything: for drawing an operation before it is applied.
+ */
+declare function previewBooleanOp(adapter: BooleansAdapter, op: BooleanOp, opts?: BooleanOpOptions): BooleanOpPreview;
+/**
+ * Run one Boolean operation over the selected paths and commit the result as a
+ * single undoable batch.
+ *
+ * Operands are ordered back-to-front, which is what makes `subtract` mean
+ * "everything in front removed from the backmost shape". Returns without
+ * mutating anything when the selection holds no paths, or too few for the
+ * requested operation. `opts.strokes` says what a stroked operand gives.
+ */
+declare function applyBooleanOp(adapter: BooleansAdapter, op: BooleanOp, opts?: BooleanOpOptions): BooleanOpResult;
+
+/**
+ * Read-only state that affordances consult on every render and hit-test
+ * call. Built via `buildChromeState` and held across renders, so affordances
+ * must not cache anything they read from it.
+ */
+interface ChromeState {
+    /** Currently selected ids. Live; reflects useSelection's React state,
+     *  less any on a layer this view does not paint. */
+    readonly selection: readonly NodeId[];
+    /** True when the canvas is in multi-mode AND >= 2 ids are selected, and
+     *  still >= 2 once `selection` drops the ones this view does not paint. */
+    readonly multiActive: boolean;
+    /** Bounds for any selection member id. Honors active-tool overlay state
+     *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed
+     *  pose bounds). Returns null for unknown ids or ids whose bounds aren't
+     *  computable. */
+    boundsOf(id: string): FramedBox | null;
+    /** Multi-union AABB when `multiActive`. Recomputed from `boundsOf` over
+     *  every selected id on each read, expanding rotated members to the extent
+     *  of their ink; null otherwise. */
+    readonly unionBounds: FramedBox | null;
+    /** Active modifier state at the moment of the call. */
+    readonly modifiers: ModifierState;
+    /** True iff the node's pose-descriptor declares it can carry a rotation.
+     *  Affordances consult this to decide whether to expose rotate cursors /
+     *  drag-bands. Defaults to `true` when the descriptor doesn't declare
+     *  (back-compat) or when the id is unknown — the rotation gesture will
+     *  no-op visually for poses without AABB fields, but the affordance
+     *  doesn't lie about the cursor. Optional on the interface so unit-test
+     *  call sites that construct `ChromeState` by hand keep compiling;
+     *  affordances should treat an absent predicate as "true". */
+    canRotate?(id: string): boolean;
+    /** Whether a scene layer reaches the screen in the view this state was
+     *  built for — its `layerVisibility` / `layerOrder`, as `ViewApi` answers
+     *  it. Absent: the view paints every layer the scene shows. An affordance
+     *  that reads it puts no chrome on a node whose layer it says `false` to. */
+    layerIsPainted?(layerId: string): boolean;
+}
+/** Whether chrome goes on something painted on `layer`, as `gate` — a
+ *  `ChromeState`, a `ViewApi` — says. No layer, or no gate: it does. */
+declare function paintsLayer(gate: {
+    layerIsPainted?(layerId: string): boolean;
+} | null | undefined, layer: string | undefined): boolean;
+
+/**
+ * A single interactive piece of chrome. Affordances declare interactive regions in a target's
+ * *local* frame; `composeAffordanceLayer` composes the target's bounds transform (rotation
+ * around the AABB center, when present) for both paint and hit-test, so the affordance never
+ * touches rotation, view.scale, or world↔screen math.
+ */
+interface Affordance {
+    /** Stable id for debug overlays + visibility maps. */
+    id: string;
+    /** This affordance's interactive regions. Each lives in some target id's local frame (or
+     *  the world frame when `targetId` is `null`). `[]` means no chrome for this state. */
+    regions(state: ChromeState): readonly AffordanceRegion[];
+    /** Optional non-interactive decoration (e.g., a leader line from a bounds edge to a
+     *  handle). Receives raw state + view because it may live outside any single target's
+     *  local frame. */
+    decorate?(state: ChromeState, view: View): DrawCommand[];
+}
+/**
+ * One interactive region produced by an affordance. The framework owns
+ * the local↔world transform for `targetId` (when non-null), so `shape`,
+ * `paint.sizePx`, and `hitRadiusPx` are always specified in coordinates
+ * the affordance can reason about directly.
+ */
+interface AffordanceRegion<TScratch = unknown> {
+    /** Stable id, e.g. `corner-min-min`. Used for debug overlays + a11y. */
+    id: string;
+    /** A chrome-caps id gating this region on top of its affordance's. */
+    chromeId?: string;
+    /** Target id whose `state.boundsOf(targetId)` defines this region's
+     *  local frame: the bounds' `rotation` and `transform`, as `poseFrameOf`
+     *  composes them about the box center. Pass
+     *  `null` for affordances anchored to the viewport / world frame
+     *  (identity transform). */
+    targetId: string | null;
+    /** Region geometry, expressed in the target's local frame.
+     *
+     *  - `point` — square hit of half-extent `hitRadiusPx` screen pixels,
+     *    axis-aligned on screen unless `turned`. `standoff` pushes the anchor `px`
+     *    screen pixels off the edge whose outward normal (target-local) is
+     *    `normal`, measured along that normal as it lands on screen — for
+     *    chrome that floats a fixed distance off an edge at any zoom.
+     *  - `rect`  — axis-aligned rect (target rotation applies).
+     *  - `annulus` — outer ellipse minus inner rect cutout, for zones that sit *around* the
+     *    AABB (e.g. a rotate-on-hover band).
+     *  - `outline` — within `hitRadiusPx` screen pixels of `path`'s outline, either side of it,
+     *    for chrome that is a path's own edge (path edit's segments). Hit-only. */
+    shape: {
+        kind: 'point';
+        x: number;
+        y: number;
+        hitRadiusPx: number;
+        standoff?: {
+            px: number;
+            normal: {
+                x: number;
+                y: number;
+            };
+        };
+        /** Turn the square to the target, at the angle the target's x axis
+         *  lands on screen (`screenAngleOf`) — for handles painted turned. */
+        turned?: boolean;
+        /** The body this point is a corner of: its target-local size, and
+         *  which way leads out of it on each axis. While the body spans under
+         *  four `hitRadiusPx` on an axis on screen, only the outward half of
+         *  the square on that axis takes a press, so a small body can still be
+         *  grabbed. The cut runs along the square's own axes: pair it with
+         *  `turned` on a target that can rotate. */
+        cornerOf?: {
+            width: number;
+            height: number;
+            outward: {
+                x: -1 | 1;
+                y: -1 | 1;
+            };
+        };
+        /** The body this point is an edge midpoint of: its target-local
+         *  size. While either side spans under `EDGE_HANDLE_MIN_RADII`
+         *  `hitRadiusPx` on screen, the point is neither hit nor painted, so it
+         *  cannot crowd the corners or cover the middle of a small body. */
+        edgeOf?: {
+            width: number;
+            height: number;
+        };
+    } | {
+        kind: 'rect';
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | {
+        kind: 'annulus';
+        /** Outer-ellipse center (target-local). */
+        cx: number;
+        cy: number;
+        /** Outer-ellipse semi-axes (target-local). */
+        rx: number;
+        ry: number;
+        /** Inner rect (target-local) — the cutout. Typically the
+         *  selection's AABB. */
+        innerX: number;
+        innerY: number;
+        innerWidth: number;
+        innerHeight: number;
+        /** Minimum band thickness outside the inner rect, in **screen**
+         *  pixels. The framework widens `rx`/`ry` to at least
+         *  `innerHalfExtent + pxExtent(minBandPx, view.scale)` on each axis
+         *  for both paint and hit-test.
+         *
+         *  In screen pixels because the clamp has to know the view and the affordance
+         *  doesn't: `ChromeState` carries no scale. */
+        minBandPx?: number;
+    } | {
+        kind: 'outline';
+        path: PolygonPath;
+        hitRadiusPx: number;
+    };
+    /** Optional paint. World position is derived from `shape` + target
+     *  transform; visual size stays in screen pixels (so handles don't
+     *  warp under zoom or non-uniform scale). Omit for hit-only regions.
+     *
+     *  - `square` — small fixed-size square (only valid over `point` shapes).
+     *  - `annulus` — fill + stroke the annulus ring (only valid over `annulus` shapes).
+     *  - `custom` — emit arbitrary draw commands; receives a {@link CustomPaintContext}. */
+    paint?: {
+        kind: 'square';
+        sizePx: number;
+        fill?: CommandFill;
+        stroke?: CommandStroke;
+    } | {
+        kind: 'annulus';
+        fill?: CommandFill;
+        stroke?: CommandStroke;
+        insetPx?: number;
+    } | {
+        kind: 'custom';
+        draw: (ctx: CustomPaintContext) => DrawCommand[];
+    };
+    /** Discriminator a press on this region reports as `AffordanceHit.kind` —
+     *  the string routing specs match on (`'handle:top-left'`,
+     *  `'rotate-handle'`, `'anchor:3'`). Omit for regions that only exist
+     *  inside a consumer-registered layer, where the layer id is the
+     *  discriminator; `buildAffordanceAt` falls back to
+     *  `<affordanceId>:<regionId>`. */
+    hitKind?: string;
+    /** Cursor to show while hovering this region: one spec, or one worked out
+     *  from where the pointer is (`at`, in world coords). */
+    cursor?: CursorSpec | ((at: {
+        x: number;
+        y: number;
+    }, view: View) => CursorSpec);
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Read only when the affordance is composed into a
+     *  consumer-registered layer; kit chrome routes through
+     *  `buildAffordanceAt`, which reports `'shared'`. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+    /** Drag binding produced when this region is hit. Called lazily, so state snapshots
+     *  (e.g., capturing per-leaf poses at click time) belong inside `bind()`, not inside
+     *  `regions()`. */
+    bind(): AffordanceBinding<TScratch>;
+}
+/** Context passed to a region's `paint.kind === 'custom'` draw callback. */
+interface CustomPaintContext {
+    /** World-space mapping of `shape`. For `point`, only `x`/`y` are set.
+     *  For `rect`, all four fields are set. */
+    world: {
+        x: number;
+        y: number;
+        width?: number;
+        height?: number;
+    };
+    /** The original local shape (same object identity as `region.shape`). */
+    local: AffordanceRegion['shape'];
+    view: View;
+    state: ChromeState;
+}
+/**
+ * Result of an affordance hit. `initialScratch` is what the region already knows (which
+ * corner, which target id) so the action that picks up the drag doesn't re-derive it. It
+ * reaches the matching action through `InvocationCtx.drag.affordance`.
+ */
+interface AffordanceBinding<TScratch = unknown> {
+    initialScratch?: TScratch;
+}
+/**
+ * The fields `buildAffordanceAt` lifts out of a region's `initialScratch` when it turns a
+ * region hit into an `AffordanceHit`. Scratch is otherwise opaque; these names mean the same
+ * thing to every affordance. An affordance that doesn't set them produces a hit without
+ * those fields.
+ */
+interface CommonAffordanceScratch {
+    /** The node (or `MULTI_RESIZE_TARGET_ID`) this chrome acts on. Becomes
+     *  `AffordanceHit.targetIds`. */
+    targetId?: string;
+    /** For resize chrome: which corner stays pinned. Mirrors the kit's
+     *  `ResizeAnchor`, spelled inline so `affordances/` doesn't take a type
+     *  dependency on the gesture layer for one field. */
+    anchor?: {
+        x: 'min' | 'max' | 'free';
+        y: 'min' | 'max' | 'free';
+    };
+    /** World-space invariant point of the transform — the fixed corner for a
+     *  resize, the pivot for a rotation. */
+    fixedPoint?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * What a **registered layer's** `hitTest` returns. The added fields are how a consumer's own
+ * chrome says the things kit chrome says through `AffordanceRegion` — which cursor to show,
+ * and whether it owns the point outright.
+ */
+interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
+    /** Cursor while the pointer is over this hit. Reaches the hover-cursor
+     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
+    cursor?: CursorSpec;
+    /** `'exclusive'` bars every binding whose target doesn't consult the affordance. Omitted
+     *  means `'shared'`. Becomes `AffordanceHit.strength`. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+}
+
+/**
+ * Several consecutive layers composited as one.
+ *
+ * A layer's own `effects` run over that layer alone, which is the wrong
+ * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not
+ * `blur(A) over blur(B)`. A group draws its members into one buffer, runs one
+ * chain over it, and composites the result back once.
+ *
+ * Membership is by `RenderLayer.id` — the same names `layerOrder` and
+ * `layerVisibility` use, not the `layers` map's slot keys.
+ *
+ * Only *consecutive* members share a buffer. A group whose members are
+ * separated in the render order is drawn as one bracket per run, with a
+ * warning.
+ *
+ * This is a render-stack bracket, not a scene `ContainerNode`.
+ */
+interface LayerGroup {
+    /** Names the group in warnings; not a layer id and never drawn. */
+    id: string;
+    /**
+     * Member layer ids. Order here is ignored — the render order decides.
+     *
+     * A name claims that layer and every layer under it in the `:` namespace, so
+     * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers
+     * draws as. The separator is required: `'scene'` does not reach `scenery`.
+     * A name matching no layer being drawn is warned about.
+     */
+    layers: readonly string[];
+    /** Passes over the group's combined pixels, in order. A thunk is re-read on
+     *  every frame, so an animating radius costs no React render. */
+    effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);
+    /** Opacity applied to the group's composited result, not to each member. */
+    alpha?: number;
+    /** 4×5 color matrix (row-major, 20 numbers) applied to the composited
+     *  result. See `GroupDrawCommand.colorMatrix`. */
+    colorMatrix?: number[];
+    /** How the composited result joins the layers under it. Default
+     *  `source-over`. See `GroupDrawCommand.composite`. */
+    composite?: CompositeOp | BlendFactors;
+}
+
+/**
+ * When `drawLayers` asks the renderer to keep a layer's pixels between frames
+ * (`GroupDrawCommand.retain`) rather than submit its commands again.
+ *
+ * A layer is retained once its `deps` have held for a frame, the view has held
+ * since the frame before (for a world-space layer, whose pixels move with
+ * it), and it holds at least `minCommands` drawing commands. A layer changing
+ * every frame is never retained: drawing it into its surface and compositing
+ * that costs more than drawing it.
+ */
+interface LayerRetainPolicy {
+    minCommands: number;
+}
+/** Measured on 1280x800 at dpr 2: an unchanged layer composites cheaper than
+ *  it submits from about 130 to 250 commands, depending on the layer count. */
+declare const DEFAULT_LAYER_RETAIN: LayerRetainPolicy;
+
+/** Something outside React whose changes a paint reads — a mode registry, a
+ *  scoping lookup. A notification repaints the canvas; the listener takes no
+ *  arguments and the returned function unsubscribes. */
+interface RedrawSource {
+    subscribe(listener: () => void): () => void;
+}
+/** The `subscribe` for a layer that draws `sources`: it notifies whenever any
+ *  of them does. A thunk is read when the subscription is made. */
+declare function subscribeToSources(sources: readonly {
+    subscribe?: RedrawSource['subscribe'];
+}[] | (() => readonly {
+    subscribe?: RedrawSource['subscribe'];
+}[])): RedrawSource['subscribe'];
+
+/** Canvas size in CSS pixels, so layers don't have to know about DPR. */
+interface Dims {
+    width: number;
+    height: number;
+}
+/**
+ * What a layer's `draw` threw, and which layer threw it. A throw that escaped
+ * the frame loop would take the whole frame with it, every other layer
+ * included.
+ */
+interface LayerDrawFailure {
+    layerId: string;
+    error: unknown;
+}
+/** One layer's memoized output, keyed by layer id. Owned by the canvas that
+ *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */
+type LayerCommandCache = Map<string, {
+    deps: readonly unknown[];
+    cmds: DrawCommand[];
+    /** Whether the last frame served `cmds` from here rather than drawing. */
+    reused?: boolean;
+    /** The view the last frame drew under. */
+    view?: View;
+}>;
+/**
+ * One layer of a canvas: `draw` turns `data` and the view into draw commands;
+ * the other fields control caching, visibility, coordinate space and hit-testing.
+ *
+ * @template TData - The data object passed to each draw call.
+ */
+interface RenderLayer<TData> {
+    /** Unique identifier used in visibility maps and ordering arrays. When a
+     *  cache is in use, an id must identify the same logical layer across
+     *  frames — reusing it for a different layer can serve cross-layer commands. */
+    id: string;
+    /** Human-readable name for UI toggles. */
+    label: string;
+    /**
+     * Emit a DrawCommand tree, in the coordinates `space` names. A world-space
+     * layer must NOT apply the view transform itself.
+     */
+    draw: (data: TData, view: View, dims: Dims) => DrawCommand[];
+    /**
+     * Optional cache key. When present and a `LayerCommandCache` is supplied to
+     * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as
+     * every entry is `Object.is`-equal to the previous call's. A layer with no
+     * `deps` rebuilds on every frame.
+     *
+     * **The returned commands must be treated as immutable.** A cached tree is
+     * handed to the renderer again on later frames, so mutating a tree you
+     * previously returned corrupts the cache silently rather than erroring.
+     *
+     * **Screen-space layers are not protected against a stale `view`/`dims`
+     * the way world-space layers are** (see `space` below) — include them in
+     * `deps` if `draw` reads them.
+     */
+    deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];
+    /** Whether the layer is shown when no explicit visibility entry exists.
+     *  Defaults to `true` when absent. */
+    defaultVisible?: boolean;
+    /** When true, the layer is always drawn regardless of the visibility map. */
+    alwaysOn?: boolean;
+    /**
+     * Coordinate space the layer draws in.
+     *
+     * - `'world'` (default): the layer's `draw` returns world-space commands;
+     *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`
+     *   automatically.
+     * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)
+     *   commands; `drawLayers` passes them through unchanged. World-anchored
+     *   chrome inside a screen-space layer must call `worldToScreen` or wrap
+     *   the relevant subset with `viewToMat3(view)` manually.
+     */
+    space?: 'world' | 'screen';
+    /**
+     * Where the layer learns that state `draw` reads, outside the scene and the
+     * props, has changed. The canvas painting it subscribes while the layer is
+     * mounted and repaints on every notification.
+     */
+    subscribe?: RedrawSource['subscribe'];
+    /**
+     * Full-screen passes run over this layer's own pixels before it joins the
+     * frame. See `GroupDrawCommand.effects` for what a pass may read, and
+     * {@link LayerGroup} to run one chain over several layers at once.
+     */
+    effects?: readonly Effect[];
+    /**
+     * Whether the renderer may keep this layer's pixels between frames and
+     * composite them as one quad instead of drawing its commands again — see
+     * {@link LayerRetainPolicy} for when `drawLayers` does. `false` never
+     * retains it, `true` retains it whatever its size; either way only a layer
+     * with `deps`, drawn through a cache, and without `effects`.
+     */
+    retain?: boolean;
+    /**
+     * Optional hit-test for **consumer-attached** layers.
+     *
+     * Only layers registered through `CanvasExtensionApi.registerLayer` are
+     * hit-tested, last-registered-first, ahead of the kit's own selection
+     * chrome. First non-null result wins; null means "I don't claim this hit,
+     * try the next layer."
+     *
+     * Layers that reach the draw stack some other way — a `Tool.overlay`, an
+     * entry in the `layers` map — are painted but never hit-tested, so defining
+     * `hitTest` on one has no effect.
+     *
+     * Coordinates are world-space.
+     */
+    hitTest?: (worldX: number, worldY: number, data: TData, view: View, dims: Dims, 
+    /** Chrome-caps visibility predicate. When supplied, the layer must
+     *  not return a hit from any chrome element whose id reports
+     *  `false`. Absent → every element is hittable. */
+    isVisible?: (id: string) => boolean) => LayerHit | null;
+    /**
+     * Called on every pointermove when no gesture is currently captured, so a
+     * layer can track hover state. Coords are world-space, and the layer does
+     * its own throttling.
+     */
+    onUncapturedMove?: (worldX: number, worldY: number, evt: PointerEvent, view: View, dims: Dims) => void;
+    /** Called when the cursor leaves the canvas element. */
+    onUncapturedLeave?: () => void;
+}
+/** Where one layer's commands landed in {@link drawLayers}' output,
+ *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's
+ *  run is one span under the group's id. */
+interface LayerDrawSpan {
+    id: string;
+    start: number;
+    end: number;
+    buildMs: number;
+}
+/**
+ * Walk visible layers and concatenate their emitted DrawCommand arrays into
+ * one flat list, ready to feed to `WeaselRenderer.render(commands)`.
+ *
+ * A layer whose `draw` throws is dropped for the frame and reported through
+ * `onLayerError` — the rest of the frame still paints.
+ *
+ * `groups` brackets runs of consecutive layers so they composite as one — see
+ * `LayerGroup`. `spans`, when passed, receives one {@link LayerDrawSpan} per
+ * layer drawn. `retain` decides which unchanged layers the renderer keeps
+ * as pixels between frames; `false` keeps none.
+ */
+declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void, groups?: readonly LayerGroup[], spans?: LayerDrawSpan[], retain?: LayerRetainPolicy | false): DrawCommand[];
+/**
+ * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in
+ * `visibility`, then `defaultVisible`, defaulting to shown.
+ */
+declare function isLayerVisible<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>): boolean;
+/**
+ * Does this layer reach the screen at all — membership of
+ * {@link paintedLayers}, asked of one layer.
+ *
+ * **A listed `order` is the whole list**, so omission from it drops a layer
+ * that `visibility` would have shown, and `alwaysOn` does not rescue it.
+ * Hit-testing asks this, not `isLayerVisible`.
+ */
+declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>, order: readonly string[] | undefined): boolean;
+/**
+ * The layers that reach the screen, in the order they are drawn: `order`
+ * sequences them and drops what it leaves out, then `visibility` drops what is
+ * hidden. What `drawLayers` paints, and what a view narrows its stack with.
+ */
+declare function paintedLayers<TData>(layers: readonly RenderLayer<TData>[], visibility: Record<string, boolean>, order: readonly string[] | undefined): RenderLayer<TData>[];
+/**
+ * Draw one layer and put its commands in the space its `space` declares:
+ * world-space output wrapped in a `viewToMat3(view)` group, screen-space
+ * output passed through.
+ *
+ * Anything rendering layers through a view goes through here.
+ *
+ * A `draw` that throws yields no commands, and `onLayerError` is told which
+ * layer it was. The layer's cache entry goes with it, so the next frame is a
+ * real re-attempt.
+ */
+declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
+/** Whether `b` matches `a` entry for entry under `Object.is` — how
+ *  `RenderLayer.deps` is compared, and any cache keyed the same way. */
+declare function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean;
+
+/**
+ * Paths that are no node, drawn over the scene: a region a tool would take,
+ * the result an operation would make before it is applied.
+ */
+
+/** One path to draw, in world coordinates, and what it is. */
+interface TransientPath {
+    path: Path;
+    /** Omitted reads as `'chrome'`. */
+    role?: OverlayRole;
+}
+/** How one role reads. The stroke is one screen pixel wide at any zoom. */
+interface PathOverlayStyle {
+    fill?: CommandPaint;
+    stroke?: CommandPaint;
+}
+/**
+ * The kit's roles: `'chrome'` for a path shown for reference, `'picked'` for
+ * one a gesture has taken, and `'remove'` for one it would delete.
+ */
+declare const PATH_OVERLAY_ROLES: Readonly<Record<string, PathOverlayStyle>>;
+/** The paths an overlay holds, and the layer that draws them. */
+interface PathOverlay {
+    get(): readonly TransientPath[];
+    /** Replace every path. */
+    set(paths: readonly TransientPath[]): void;
+    clear(): void;
+    /** A world-space layer drawing the paths in order, repainting on each change. */
+    layer: RenderLayer<unknown>;
+}
+/** Options for {@link createPathOverlay}. */
+interface PathOverlayOptions {
+    /** The layer's id; see `RenderLayer.id`. */
+    id: string;
+    label?: string;
+    /** Styles per role, merged over {@link PATH_OVERLAY_ROLES}. A role with
+     *  none paints as `'chrome'`. */
+    roles?: Readonly<Record<string, PathOverlayStyle>>;
+}
+/** A store of transient paths and the layer that draws it; hand the layer to
+ *  a tool's `overlay` or a canvas's `layers`. */
+declare function createPathOverlay({ id, label, roles }: PathOverlayOptions): PathOverlay;
+
+/** Cancel-key prefix. Each hook instance appends its own id, so two runners
+ *  sharing an animator do not cancel each other. */
+declare const VIEW_ANIMATION_KEY = "view";
+/** How the camera should move. */
+interface ViewAnimationOptions {
+    /** Duration in ms. Default the `view.animationMs` kit setting, else `DEFAULT_VIEW_ANIMATION_MS`;
+     *  0 under `prefers-reduced-motion`. */
+    ms?: number;
+    /** Easing curve. Default `easeOutCubic`. */
+    easing?: EasingSpec;
+    /** Replace the kit's log-scale / fixed-anchor curve. */
+    interpolator?: InterpolatorFactory<View>;
+    /** Fires when the target is reached. Not called on cancel. */
+    onDone?: () => void;
+}
+/** Options accepted by {@link ViewAnimationApi.animateToBounds}. */
+interface AnimateToBoundsOptions extends FitViewToBoundsOptions, ViewAnimationOptions {
+}
+/** What the runner reads and writes. On `<SceneCanvas>` this is the same
+ *  channel `view.set` uses, so a camera animation on an uncontrolled canvas
+ *  costs no React render. */
+interface ViewChannel {
+    get(): View;
+    set(v: View): void;
+}
+/** The camera animation surface. Its own animations run one at a time. */
+interface ViewAnimationApi {
+    /** Glide from the live view to `to`. A thunk receives the pending target when
+     *  one is in flight, so successive discrete steps compound. */
+    animate(to: View | ((base: View) => View), opts?: ViewAnimationOptions): void;
+    /** `fitViewToBounds` composed with `animate`. */
+    animateToBounds(bounds: FramedBox, dims: ViewportDims, opts?: AnimateToBoundsOptions): void;
+    /** Cancel. The view stays where it is — no jump to the target. */
+    stop(): void;
+    isAnimating(): boolean;
+    /** Where the in-flight animation is heading, or null when none is. */
+    target(): View | null;
+    /** Cancel unless the write that prompted this came from the runner's own
+     *  per-frame write. Feed it from every channel that can move the camera. */
+    stopIfExternal(): void;
+    /**
+     * The view as a {@link Target}, for running another animation on it: a shake
+     * or a nudge adds to a camera animation in flight, and neither cancels the
+     * other. Move it with the animator this runner was given, and without this
+     * runner's cancel key. `stop` and an outside write leave such an animation
+     * running.
+     */
+    readonly viewTarget: Target<View>;
+}
+/** A `View` as the four numbers an animation moves: `x`, `y`, `scale.x`, `scale.y`. */
+declare const viewAxes: TargetAxes<View>;
+/**
+ * Animate the viewport `View`. Runs on the kit's {@link Animator} — pass one to
+ * share a canvas's animator, or omit it and the hook makes its own. A caller
+ * that always has one should use {@link useViewAnimationOn}, which builds none.
+ *
+ * Every animation from one instance registers under that instance's cancel key,
+ * so starting one cancels whatever *it* had in flight, and each starts from where
+ * the last one was rather than a captured value — an interrupted camera never jumps.
+ * Two instances on one animator are independent. The view is a target
+ * ({@link ViewAnimationApi.viewTarget}), so other animations can add to the camera's.
+ */
+declare function useViewAnimation(view: ViewChannel, animator?: Animator): ViewAnimationApi;
+/** {@link useViewAnimation} on an animator the caller owns. Constructs no
+ *  animator of its own, so the camera runs on exactly the one passed. */
+declare function useViewAnimationOn(view: ViewChannel, animator: Animator): ViewAnimationApi;
+
+/** Paths drawn over the canvas until the function `show` returns is called.
+ *  A later `show` replaces what an earlier one drew, and the earlier one's
+ *  function then takes nothing down. */
+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 = {
+    x: number;
+    y: number;
+};
+/** Geometry a gesture brings to snap to that is in no scene node: what stays
+ *  put of a path whose anchors it is dragging. World coords. */
+interface SnapGeometry {
+    paths?: readonly Path[];
+    /** Points to snap to as anchors. */
+    anchors?: readonly Point$4[];
+}
+/** What builds a gesture's input subspace while `snap.constrain` is held:
+ *  an angle step in radians about `origin` (a rotate's every multiple of
+ *  it, required), an axis or 45° lock about the press, or a resize's
+ *  aspect. */
+type SnapConstrain = {
+    step: number;
+} | 'aspect' | 'axis';
+/** The box a resize drags, as drawn, in its own frame. */
+interface SnapResizeBox {
+    bounds: FramedBox;
+    /** Its frame into ctx coordinates, an affine map. Default: the identity. */
+    toWorld?: (p: Point$4) => Point$4;
+}
+/** What a gesture tells the snap dep when it starts. Points are ctx
+ *  coordinates: world in 2D. */
+interface SnapBegin {
+    gesture: SnapGesture;
+    press: Point$4;
+    /** The subject, whose geometry offers no targets. */
+    ids?: readonly 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,
+     *  axis-aligned. */
+    box?: SnapResizeBox;
+    /** Rotate, handle: the point the angle turns about. Default `press`. */
+    pivot?: Point$4;
+    /** Rotate: the subject's angle at press, radians. Default 0. */
+    theta0?: number;
+    /** Angle gestures: the reach as an angle, radians, in place of screen px
+     *  through the press radius; it overrides each source's `reachPx` and is
+     *  not capped. */
+    reachRad?: number;
+    /** Point gestures: the fixed end of what the gesture draws — a span's
+     *  start, the previous anchor, the anchor a handle pulls from. Tangent and
+     *  perpendicular targets are measured from it, a `constrain` step turns
+     *  about it, and no point target on it is offered. */
+    origin?: Point$4;
+    also?: SnapGeometry;
+    constrain?: SnapConstrain;
+    /** 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;
+}
+/** The snap roles held this frame. */
+interface SnapMods {
+    /** No source answers; the input subspace still applies. */
+    suspend: boolean;
+    constrain: boolean;
+    /** Angle gestures: the angle stays at `theta0`, which becomes a required
+     *  target. */
+    hold?: boolean;
+}
+/** Where a session put one frame's point, and the marks to draw for it. */
+interface SnapOutcome {
+    point: Point$4;
+    /** Whether some target holds the point. */
+    held: boolean;
+    marks: readonly SnapMark[];
+}
+/** One gesture's snapping, from press to release. */
+interface SnapSession {
+    /** Where `p` lands. */
+    at(p: Point$4, mods: SnapMods): SnapOutcome;
+    /** Where the angle `theta` (radians, about `pivot`) lands. */
+    angle(theta: number, mods: SnapMods): {
+        theta: number;
+        marks: readonly SnapMark[];
+    };
+    /** Clears the gesture's marks. */
+    end(): void;
+}
+/**
+ * Snapping, for every gesture that snaps: each one begins a session at press
+ * and asks it, frame by frame, where its point lands. Points are ctx
+ * coordinates — world in 2D, screen in a 3D host.
+ */
+interface SnapDep {
+    /** Start a gesture's snap session. */
+    begin(req: SnapBegin): SnapSession;
+}
+
+/** The snap source contract: what a target set offers a snap session, and
+ *  the marks a session draws for what it met. */
+
+type Point$3 = {
+    x: number;
+    y: number;
+};
+/** The positions a target allows: `at` plus any combination of `dirs`. No
+ *  dirs is a point, one a line, two a plane. */
+interface Locus<P = Point$3> {
+    at: P;
+    dirs: readonly P[];
+    /** One interval per dir, in multiples of it: a segment or a bounded face. */
+    span?: readonly (readonly [number, number])[];
+}
+/** One locus a source offers one probe. */
+interface SourceCandidate<P = Point$3> {
+    /** The id of a probe the source was offered. */
+    probe: string;
+    locus: Locus<P>;
+    /** The result must meet one required candidate, whatever its reach. */
+    required?: boolean;
+    /** Drawn when the result meets this candidate. A function is handed the
+     *  resolved move, so the marks can sit where the probe landed. */
+    mark?: SnapMarks<P> | ((delta: P) => SnapMarks<P>);
+}
+/** `'handle'` is an angle about an anchor, as `'rotate'` is about a pivot,
+ *  but asks only sources that name it. */
+type SnapGesture = 'point' | 'move' | 'resize' | 'rotate' | 'handle';
+/** The sides of a box a gesture moves on one axis; null for neither. */
+type SnapEdge = 'min' | 'max' | 'both' | null;
+/** Which sides of the subject's box a gesture moves, per axis. */
+interface SnapEdges {
+    x: SnapEdge;
+    y: SnapEdge;
+}
+/** A point on the subject that should land on a locus. */
+interface SnapProbeAt<P = Point$3> {
+    id: string;
+    at: P;
+    role: ProbeRole;
+}
+/** What a session asks a source for, once per frame. */
+interface SnapCollect<P = Point$3> {
+    gesture: SnapGesture;
+    /** The probes this source matches, where the unsnapped gesture puts them. */
+    probes: readonly SnapProbeAt<P>[];
+    /** The unsnapped move from the press. A probe at `at` here lands at
+     *  `at - delta0 + delta` for the resolved `delta` a function mark gets. */
+    delta0: P;
+    /** The subject's drawn box, stroke included, where the unsnapped gesture
+     *  puts it: a move's union of boxes, or the box a resize drags. Absent for
+     *  other gestures. */
+    box?: FramedBox;
+    /** Which sides of `box` the gesture moves on each axis. Default: both, as
+     *  a move does. */
+    edges?: SnapEdges;
+    /** `id`'s drawn box, measured as `box` is. Absent in a host with no 2D
+     *  scene. */
+    drawnBox?(id: string): FramedBox | undefined;
+    /** Nodes that offer no targets: what the gesture moves. */
+    exclude: readonly string[];
+    /** Only these nodes offer targets. */
+    include?: readonly string[];
+    /** Where the geometry being drawn starts; tangent and perpendicular targets
+     *  are measured from it. */
+    origin?: P;
+    also?: SnapGeometry;
+    /** `px` screen pixels as world units: a radius to cull targets by. */
+    reachWorld(px: number): number;
+    /** The reach, in screen px, the session applies to this source: its own
+     *  `reachPx`, else the canvas's. Candidates past it are dropped anyway. */
+    reachPx: number;
+    /** Absent in a host with no 2D scene. */
+    scene?: Scene<unknown, string, unknown>;
+    /** How the camera's world maps into the parallax plane the probes are in.
+     *  Absent in the camera's own world. A target the camera draws, a grid or
+     *  a ruler guide, is carried through it. */
+    plane?: PlaneMap | null;
+}
+/** What a rotate or handle drag asks a source for, once per frame. Angles
+ *  are radians about `pivot`, in the frame `rotationOf` reads. */
+interface AngleCollect {
+    pivot: Point$3;
+    /** Where the gesture was pressed: its distance from `pivot` is the radius
+     *  the default marks are drawn at. */
+    press: Point$3;
+    /** The angle at press. */
+    theta0: number;
+    /** The unsnapped angle now. */
+    theta: number;
+    /** The subject. */
+    ids: readonly string[];
+    /** Nodes that offer no targets: the subject and everything under it. */
+    exclude: readonly string[];
+    mods: SnapMods;
+    also?: SnapGeometry;
+    /** Absent in a host with no 2D scene. */
+    scene?: Scene<unknown, string, unknown>;
+    /** `id`'s world rotation, read as the subject's is; undefined for a node
+     *  that cannot turn. */
+    rotationOf?(id: string): number | undefined;
+}
+/** An angle a source offers. The session compares it round the circle, so
+ *  any whole turn of it is the same target. */
+interface AngleCandidate {
+    angle: number;
+    /** The result must land on one required angle, whatever its reach. */
+    required?: boolean;
+    /** Drawn when the result lands on it. Default: a ray from the pivot along
+     *  the snapped angle, labeled in degrees. */
+    mark?: SnapMarks;
+}
+/** A set of snap targets. */
+interface SnapSource<P = Point$3> {
+    id: string;
+    /** Default `'target'`. A fallback never displaces a target in reach. */
+    tier?: SnapTier;
+    /** Overrides the canvas's reach for this source, in screen px. */
+    reachPx?: number;
+    /** The probe roles it matches; it is never offered a probe of another. */
+    roles: readonly ProbeRole[];
+    /** Default: every gesture but `'rotate'` and `'handle'`. */
+    gestures?: readonly SnapGesture[];
+    collect(q: SnapCollect<P>): Iterable<SourceCandidate<P>>;
+    /** Angle targets, for a source whose `gestures` include `'rotate'` or `'handle'`. */
+    angles?(q: AngleCollect): Iterable<AngleCandidate>;
+}
+/** One mark, or several, for one candidate. */
+type SnapMarks<P = Point$3> = SnapMark<P> | readonly SnapMark<P>[];
+/** What a session draws for a candidate the result meets. World coords. */
+type SnapMark<P = Point$3> = {
+    kind: 'point';
+    at: P;
+    glyph: string;
+    label?: string;
+    color?: string;
+} | {
+    kind: 'line';
+    from: P;
+    to: P;
+    color?: string;
+} | {
+    kind: 'gap';
+    from: P;
+    to: P;
+    value: number;
+    color?: string;
+} | {
+    kind: 'distance';
+    from: P;
+    to: P;
+    value: number;
+    color?: string;
+};
+/** `<SceneCanvas snap>`. */
+interface SceneCanvasSnap {
+    /** Sources ahead of the presets' `snapSources` and any `useSnapSource`.
+     *  One source per id is asked: the last listed, in the order prop,
+     *  presets, `useSnapSource` in mount order. A canvas default (`'rotation'`,
+     *  `'path-snap'`) loses to any of them. */
+    sources?: readonly SnapSource[];
+    /** Ids of canvas defaults to leave out: `'rotation'` stops a rotate
+     *  snapping to quarter turns and other nodes' angles (Shift's step is the
+     *  rotate's own and stays), and `'path-snap'` stops a point gesture (the
+     *  pen, an anchor drag, a drawn line's ends, a measurement) snapping to
+     *  other nodes' anchors. */
+    omit?: readonly string[];
+    /** The reach of a source that sets none, in screen px. Default: the kit
+     *  setting `targets.snapPx`. */
+    reachPx?: number;
+    /** How a pose's origin is read, for the `origin` probe a grid or a ruler
+     *  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`. */
+    readout?: boolean;
+    /** The readout's default colors and line width, for a mark that sets no `color`. */
+    readoutStyle?: SnapReadoutStyle;
+}
+
+type Point$2 = {
+    x: number;
+    y: number;
+};
+/** The marks of the snap in flight, for the readout to draw. */
+interface SnapOutcomeStore<P = Point$2> {
+    get(): readonly SnapMark<P>[];
+    set(marks: readonly SnapMark<P>[]): void;
+    subscribe(listener: () => void): () => void;
+}
+/** An empty outcome store, which notifies only when the marks change. */
+declare function createSnapOutcomeStore<P = Point$2>(): SnapOutcomeStore<P>;
+
+/** The `snapReadout` dep: where marks go to be drawn. */
+interface SnapReadoutDep {
+    store: SnapOutcomeStore;
+}
+
+/**
+ * Consumer-supplied node factory for one insert `kind`. Given the drag AABB
+ * and the tool's `extras`, returns the node's `data` (in the consumer's own
+ * data shape) plus an optional `pose` override — the dep supplies id, layer,
+ * and the undoable insert op. Return `null` to reject the insert.
+ *
+ * A factory registered for a kit kind (`rect`, `line`, …) fully replaces the
+ * kit's default `{ path, fill }` factory for that kind; a factory for a novel
+ * kind adds support the kit doesn't ship (e.g. `text`). To change only the
+ * paint of a kit shape, pass an {@link InsertPaint}. See
+ * `SceneCanvas`'s `insertNodeFactories` prop.
+ */
+type InsertNodeFactory = (bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, extras: InsertExtras) => {
+    data: unknown;
+    pose?: unknown;
+} | null;
+/**
+ * The paint a kit-built shape is inserted with. `kind` is the shape being
+ * built and `seq` counts this canvas's inserts from 1. A key left out stays
+ * off the node, so its painter's default applies; `null` is "none". A pencil
+ * trail too short to fit is built as a rect and asks as one. A line and an
+ * open pen path are inserted unfilled: a fill given to either is dropped.
+ * `fillRule` is the rule a path that carries one is built with, where the
+ * kit's own is nonzero; a rect or an ellipse has none to set.
+ *
+ * It paints only the shapes the kit builds: an `InsertNodeFactory` owns its
+ * node's whole `data`. See `SceneCanvas`'s `insertPaint` prop.
+ */
+type InsertPaint = (kind: string, seq: number) => {
+    fill?: Fill | null;
+    stroke?: Stroke | null;
+    fillRule?: PathFillRule;
+};
+/** The default {@link InsertPaint}: the next color of the kit palette, as a
+ *  fill on a closed shape, a fill and a stroke on a pen path, and a stroke
+ *  alone on a line or a pencil trail. */
+declare const paletteInsertPaint: InsertPaint;
+
+/** The `data` a `kit:text` node carries. */
+interface TextNodeData {
+    text: string;
+    style?: TextStyle;
+    runs?: readonly StyledRun[];
+    fill?: Fill | null;
+    stroke?: Stroke | null;
+    verticalAlign?: TextVerticalAlign;
+    /** Paint for the whole pose box, drawn under the glyphs. `fill` is the
+     *  glyphs' own paint, so a box behind them needs a key of its own. */
+    background?: Fill | null;
+    /** World units between the pose box and the box the text lays out in, on
+     *  every side. */
+    padding?: number;
+    /** What happens to text that runs past the pose box: `'visible'` (the
+     *  default) draws it there, `'clip'` cuts it at the box's edge. */
+    overflow?: TextOverflow;
+}
+/** How a text node treats lines that run past its box. */
+type TextOverflow = 'visible' | 'clip';
+/** The box a text node's lines lay out in: its pose box, inset by
+ *  `data.padding` and never past its center. */
+declare function textBoxOf(d: Pick<TextNodeData, 'padding'>, p: RectPose): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+/** The smallest box a node may be drawn or resized to, in world units. */
+interface MinSize {
+    width: number;
+    height: number;
+}
+/** A node's minimum, from `data.minSize`, or `null` when it has none. A
+ *  side that is not a positive number holds nothing. */
+declare function minSizeOf(data: unknown): MinSize | null;
+
+/** How a sticky note looks as it is made, named as the text node it becomes
+ *  names them. Every field but `fill` has a default, in {@link STICKY_DEFAULTS}. */
+interface StickyStyle {
+    /** The note itself, painted over its whole box. */
+    background?: Fill;
+    /** The text's paint. Absent, the text style's default. */
+    fill?: Fill;
+    /** World units from the note's edge to its text, on every side. */
+    padding?: number;
+    /** Typography for the note's text. */
+    style?: TextStyle;
+    verticalAlign?: TextVerticalAlign;
+    /** What happens to text that outgrows the note. */
+    overflow?: TextOverflow;
+    /** The smallest note a drag makes or a resize leaves, in world units. */
+    minSize?: MinSize;
+    /** The note a click makes, centered on the click, in world units. A drag
+     *  makes the note it draws. */
+    size?: {
+        width: number;
+        height: number;
+    };
+}
+/** The look a sticky note takes for any field its tool leaves out. */
+declare const STICKY_DEFAULTS: {
+    readonly background: {
+        readonly paint: {
+            readonly kind: "solid";
+            readonly color: "#fff1a6ff";
+        };
+    };
+    readonly padding: 12;
+    readonly style: {
+        readonly fontSize: 18;
+        readonly align: "center";
+        readonly wrap: true;
+    };
+    readonly verticalAlign: "center";
+    readonly overflow: "clip";
+    readonly minSize: {
+        readonly width: 48;
+        readonly height: 48;
+    };
+    readonly size: {
+        readonly width: 160;
+        readonly height: 160;
+    };
+};
+/**
+ * A sticky note's `data`: a text node with a `background`, so the `kit:text`
+ * painter draws it and the text editor edits it with no sticky case of its
+ * own. `look` is the `sticky` insert's extras, which carry the tool's
+ * {@link StickyStyle}.
+ */
+declare function stickyData(look: StickyStyle & {
+    text?: string;
+}): TextNodeData & {
+    minSize: MinSize;
+};
+/** The kit's `sticky` insert as an `InsertNodeFactory`, for a canvas that
+ *  wraps it — to tag the data with a `kind`, say — under `insertNodeFactories`. */
+declare const stickyNodeFactory: InsertNodeFactory;
+
+/** Per-axis limits on a view's position. Any side may be left open. */
+interface PanBounds {
+    minX?: number;
+    maxX?: number;
+    minY?: number;
+    maxY?: number;
+}
+/** Momentum settings for a pan: how quickly a flung view slows, when it stops,
+ *  and what happens at the pan limits. The `DecayLoopConfig` fields a caller
+ *  chooses up front, without the per-gesture `velocity` / `onTick`. */
+interface InertiaConfig {
+    friction?: number;
+    minSpeed?: number;
+    /** What to do when inertial pan reaches `bounds`. Default: no clamping. */
+    boundary?: 'stop' | 'bounce' | 'spring';
+    /** View-coordinate limits for boundary clamping. Requires `boundary` to take effect. */
+    bounds?: PanBounds;
+}
+/** How a decay should run: its starting velocity, how fast it slows, and what
+ *  happens if it reaches the pan limits. */
+interface DecayLoopConfig {
+    velocity: {
+        vx: number;
+        vy: number;
+    };
+    friction?: number;
+    minSpeed?: number;
+    /** Bounds for boundary clamping. Requires `boundary` to take effect. */
+    viewBounds?: PanBounds;
+    /**
+     * What to do when the accumulated position hits `viewBounds`. Default: no clamping.
+     * - `'stop'`: clamp at boundary, kill velocity component.
+     * - `'bounce'`: linear reflection — flip velocity sign, magnitude preserved.
+     * - `'spring'`: damped reflection — flip velocity sign and shrink magnitude
+     *   by `SPRING_DAMPING` per bounce so the motion settles naturally.
+     */
+    boundary?: 'stop' | 'bounce' | 'spring';
+    /** Starting position for internal boundary tracking. Required when `viewBounds` is set. */
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    onTick: (dx: number, dy: number) => void;
+    onEnd?: () => void;
+}
+/** A rAF loop that coasts a value to a stop under friction, reporting the
+ *  per-frame delta. What turns a released pan drag into momentum scrolling. */
+declare function useDecayLoop(): {
+    start: (config: DecayLoopConfig) => void;
+    cancel: () => void;
+};
+
+/**
+ * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)
+ * share: what their committed batch is called in history, whether it is
+ * recorded at all, and the callbacks fired as the gesture opens and closes.
+ *
+ * Move and rotate read it from their binding's params; resize reads it from
+ * the `resizePolicy` dep, where the rest of its options already live.
+ */
+
+/** The lifecycle options, as a binding's params or the resize policy carry
+ *  them. */
+interface GestureLifecycleOptions {
+    /** History label for the committed batch. Unset, the batch takes its first
+     *  op's label (a layout drop or a behavior names its own), else the
+     *  action's. */
+    label?: string;
+    /** Commit through `scene.untracked`: the edit lands, but no undo entry
+     *  records it and the consumer `applyOps` hook is bypassed. Unset, any
+     *  behavior's `defaultTransient: true` turns it on. */
+    transient?: boolean;
+    /** Fired once the gesture starts changing poses, with the ids it moves. */
+    onGestureStart?(ids: string[]): void;
+    /** Fired once per `onGestureStart`: `true` when the gesture wrote to the
+     *  document, `false` on cancel, abort, or a release with nothing to write. */
+    onGestureEnd?(committed: boolean): void;
+}
+
+/** Optional consumer seam: given a node and the affine `m` that a pose-transform
+ *  action applied to the node's POSE, return updated `data` with the node's
+ *  data-held geometry transformed by `m`, or `null` if this node has no
+ *  data-held geometry (the kit leaves `data` alone). */
+interface GeometryProjection {
+    transform(node: {
+        id?: string;
+        data: unknown;
+        pose: unknown;
+    }, m: Affine): unknown | null;
+}
+
+/** What a handle drag holds fixed: its direction from the anchor, or its length. */
+type HandleLock = 'angle' | 'length';
+/** Which handle locks are held for every handle drag, on top of the modifiers.
+ *  Both together freeze the handle. */
+interface HandleLocks {
+    angle: boolean;
+    length: boolean;
+}
+/**
+ * The params `editAnchors` reads, through `<SceneCanvas tune>` or a binding.
+ * Read on every move, so a change mid-drag reaches the drag.
+ */
+type EditAnchorsParams = {
+    /** A lock held for every handle drag without a modifier: Shift holds the
+     *  angle, Mod (Cmd or Ctrl) the length. Under `<SceneCanvas>` this is where
+     *  the `handleLock.angle` and `handleLock.length` toggles start from; once
+     *  one is pressed, the locks the `editAnchors` dep holds decide. */
+    handleLock?: HandleLock | null;
+};
+
+/**
+ * A path drawn from another form the node keeps beside it, such as a curve
+ * solved through the points it passes. The node's path stays the geometry
+ * every reader draws and hit-tests; `data.representation` holds the form,
+ * named by its `kind`. A preset that knows a kind brings a
+ * {@link PathRepresentation} for it (`PathEditExtension.representation`),
+ * through which path edit shows and edits the form. Where none is on, path
+ * edit edits the drawn path, and the edit drops the form.
+ */
+
+/** What `data.representation` holds: a form named by `kind`, with whatever
+ *  that kind keeps. */
+interface PathForm {
+    readonly kind: string;
+    readonly [field: string]: unknown;
+}
+type Point$1 = {
+    x: number;
+    y: number;
+};
+/** The outline of an anchor's marker, in screen space: `size` px across at
+ *  `at`, with the anchor's neighbors along its subpath, null past an open
+ *  end. */
+type AnchorMarkerShape = (at: Point$1, size: number, prev: Point$1 | null, next: Point$1 | null) => PolygonPath;
+/** How path edit reads and writes one kind of {@link PathForm}. */
+interface PathRepresentation {
+    /** The `kind` of the forms it reads. */
+    readonly kind: string;
+    /** What path edit shows and moves for a node holding `form`, whose drawn
+     *  path in world space is `path`. Null when `form` does not describe
+     *  `path`: path edit then edits `path`, and the edit drops the form. */
+    editPath(path: PolygonPath, form: PathForm): PolygonPath | null;
+    /**
+     * The drawn path an edit makes, and the form to keep beside it: `edited` is
+     * an edit of what {@link editPath} gave, `path` the drawn path it was given
+     * from. Null when `form` does not describe `path`; the edit is then stored
+     * as drawn, without the form. Runs on every commit of an edit and every
+     * frame of one in flight.
+     */
+    store(path: PolygonPath, form: PathForm, edited: PolygonPath): {
+        path: PolygonPath;
+        form: PathForm;
+    } | null;
+    /** The marker of each anchor of the edit path, by flat index. An anchor
+     *  with none draws path edit's square. */
+    anchorMarkers?(form: PathForm): readonly (AnchorMarkerShape | null)[];
+    /**
+     * A press at world point `at` on the drawn outline of the node in path
+     * edit: the drag it starts, or null when it starts none there. A
+     * representation that has this takes every segment press, in place of
+     * Bend segment.
+     */
+    segmentPress?(deps: ActionDeps, at: Point$1): (() => OngoingHandle) | null;
+}
+
+/**
+ * What a feature adds to path edit without path edit knowing it: marks drawn
+ * on the open path, parts of it to press, marks a click selects and Delete
+ * removes, a share in shaping an anchor or handle drag, what an edit must keep
+ * true when it commits, and how a path drawn from another form is edited. A
+ * preset carries its extensions as `FeaturePreset.pathEdit`; core consults
+ * them in preset order.
+ */
+
+/** A mark an extension drew that is selected in place of anchors: Delete
+ *  acts on it, and selecting anchors clears it. */
+interface PathEditMark {
+    /** The extension that drew it. */
+    owner: string;
+    /** Which of its marks, in the extension's own numbering. */
+    index: number;
+}
+/** The open path as an extension's marks and parts read it. */
+interface PathEditTarget {
+    /** The node being edited. */
+    id: string;
+    /** Its committed pose and data. */
+    node: {
+        pose: unknown;
+        data: unknown;
+    };
+    /** The path as drawn now, in-flight edits included, in world space. */
+    path: PolygonPath;
+    /** `path`'s anchors. */
+    anchors: AnchorSet;
+}
+/** What {@link PathEditExtension.marks} draws with. */
+interface PathEditMarksCtx extends PathEditTarget {
+    view: View;
+    /** World space to the screen space the marks are drawn in. */
+    toScreen(p: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    /** Chrome-caps' answer for a chrome id; marks gated by one ask it. */
+    isVisible(chromeId: string): boolean;
+    /** The selected mark's index when this extension owns it, else null. */
+    selected: number | null;
+}
+/** A grabbable point an extension adds to the open path. A press on it
+ *  routes as an affordance hit of kind `hitKind`. */
+interface PathEditPart {
+    x: number;
+    y: number;
+    hitKind: string;
+    /** Chrome-caps id it is hit-tested under, beside `path-edit.anchors`. */
+    chromeId?: string;
+    /** Hit radius in screen px; path edit's anchor radius when left out. */
+    hitRadiusPx?: number;
+    /** Pushes the part `px` screen pixels from (x, y) along the world-space
+     *  `normal`, so it keeps its distance at any zoom. */
+    standoff?: {
+        px: number;
+        normal: {
+            x: number;
+            y: number;
+        };
+    };
+}
+type Point = {
+    x: number;
+    y: number;
+};
+/** An anchor or handle drag on the open path, as it starts. */
+interface PathEditDragStart extends Omit<PathEditTarget, 'node'> {
+    /** The node's committed pose and data; null when it cannot be read. */
+    node: PathEditTarget['node'] | null;
+    /** What the press grabbed: an anchor, or one of its handles. */
+    part: 'anchor' | 'controlIn' | 'controlOut';
+    /** The pressed anchor, as a flat index. */
+    anchorIndex: number;
+    /** The anchors an anchor drag moves, as flat indices; empty for a handle
+     *  drag, or when Shift took the pressed anchor out of the selection. */
+    dragging: readonly number[];
+    /** The view's world-to-screen scale at the press, to measure in screen
+     *  pixels by; absent without a view. */
+    scale?: {
+        x: number;
+        y: number;
+    };
+    /** The canvas's `snap` dep, to begin a session on; absent without one. */
+    snap?: SnapDep;
+}
+/** A handle drag's move, as {@link PathEditDrag.handle} reads it. */
+interface PathEditHandleMove {
+    /** The handle locks in force this move, modifiers included. */
+    locks: HandleLocks;
+}
+/** One extension's share of a drag in flight. Every member is optional. */
+interface PathEditDrag {
+    /**
+     * For an anchor drag, anchors that follow it and the share of its delta
+     * each moves by, keyed by flat index. Read every move. When any extension
+     * gives one, the drag moves its dragged anchors in full and every anchor
+     * named by the largest share given, and moves no symmetric images.
+     */
+    weights?(): ReadonlyMap<number, number>;
+    /** For a handle drag, where the handle goes, given `to`: where the pointer
+     *  and the locks in force put it. Extensions answer in turn, each from the
+     *  last one's answer. */
+    handle?(to: Point, move: PathEditHandleMove): Point;
+    /** A wheel turned while the drag is in flight. Return true to claim it;
+     *  the drag then redoes its last move. */
+    wheel?(wheel: {
+        deltaX: number;
+        deltaY: number;
+        deltaZ: number;
+    }): boolean;
+    /** Overlays to draw while the drag is in flight, for `current`, the path
+     *  as the drag has made it. */
+    overlays?(current: AnchorSet): readonly OngoingOverlay[];
+    /** The drag is over, committed or canceled. */
+    end?(): void;
+}
+/** Another node an edit changes along with the edited one. */
+interface PathEditOther {
+    id: string;
+    /** Its new path, in world space, stored where the node keeps its own. */
+    path?: PolygonPath;
+    /** Data fields to set on it. */
+    data?: Record<string, unknown>;
+    /** Delete it: what it kept true no longer has anything to hold. */
+    remove?: boolean;
+}
+/** What an edit commits once an extension has finished it. */
+interface FinishedPathEdit {
+    path: PolygonPath;
+    /** Data fields to set beside the path. */
+    data?: Record<string, unknown>;
+    /** Other nodes the edit changes, committed in the same history entry and previewed with it. */
+    others?: readonly PathEditOther[];
+}
+/** The scene as {@link PathEditExtension.finishEdit} reads it, for an edit that reaches past one node. */
+interface PathEditFinishCtx {
+    /** The edited node's id. */
+    id: string;
+    /** A node's committed pose, data and dependencies; null when there is none. */
+    node(id: string): {
+        pose: unknown;
+        data: unknown;
+        dependsOn?: readonly string[] | 'children';
+    } | null;
+    /** A node's committed editable path, in world space; null when it has none. */
+    path(id: string): PolygonPath | null;
+    /** The nodes that list `id` in their `dependsOn`, directly or through others. */
+    dependents(id: string): readonly string[];
+}
+/** One feature's share of path edit. Every member is optional. */
+interface PathEditExtension {
+    /** Names it as a {@link PathEditMark}'s owner. Unique per canvas. */
+    readonly id: string;
+    /** Draw commands for the open path, in screen space, under its anchor
+     *  markers. Called every frame the overlay paints. */
+    marks?(ctx: PathEditMarksCtx): DrawCommand[];
+    /** Grabbable points on the open path, pressed ahead of its segments and
+     *  behind its anchors. */
+    parts?(target: PathEditTarget): readonly PathEditPart[];
+    /** The index of this extension's mark a click at `screen` (in the
+     *  overlay's screen space) lands on, or -1. Asked when a click misses
+     *  every anchor. */
+    markAt?(target: PathEditTarget, toScreen: PathEditMarksCtx['toScreen'], screen: {
+        x: number;
+        y: number;
+    }): number;
+    /** Remove mark `index` of the node `target` names, committing through
+     *  `store`. Delete in path edit calls it on the selected mark. */
+    deleteMark?(target: PathEditTarget, index: number, store: PathEditStore): void;
+    /** Its share of an anchor or handle drag starting on the open path, or
+     *  null to sit it out. Asked once, at the press. */
+    drag?(start: PathEditDragStart): PathEditDrag | null;
+    /**
+     * `worldPath`, an edit of `node`'s committed path, finished so whatever
+     * this extension keeps true holds — the path, and any data fields that
+     * change with it, and any other nodes it has to move to keep it. Null when
+     * it cannot hold, and the edit should then not happen. Runs on every commit
+     * of an edit and every frame of one in flight. `ctx` reads the rest of the
+     * scene; it is absent where an edit has no scene behind it.
+     */
+    finishEdit?(node: {
+        pose: unknown;
+        data: unknown;
+    }, worldPath: PolygonPath, origins?: readonly (PointOrigin | null)[], ctx?: PathEditFinishCtx): FinishedPathEdit | null;
+    /** How path edit reads and writes the nodes whose `data.representation`
+     *  is of its kind. */
+    representation?: PathRepresentation;
+}
+/** Commits a node's new path and data as one history entry, with no
+ *  extension finishing it. */
+type PathEditStore = (id: string, worldPath: PolygonPath, label: string, data?: Record<string, unknown>) => void;
+/**
+ * Data fields that describe how a node's geometry was made, or name its
+ * anchors, and so mean nothing once the geometry is replaced some other way.
+ * A writer replacing a node's path drops them: a held warp, path
+ * constraints, a skin, the form a path was drawn from.
+ */
+declare const GEOMETRY_BOUND_DATA: readonly string[];
+/** `data` without the fields in {@link GEOMETRY_BOUND_DATA}, other than `keep`. */
+declare function withoutGeometryBoundData<T>(data: T, keep?: readonly string[]): T;
+
+/** An edit as {@link EditAnchorsDep.finishEdit} finishes it: the edited node's world path, and the other nodes' that move with it. */
+interface FinishedEditFrame {
+    path: unknown;
+    others: readonly {
+        id: string;
+        path: unknown;
+    }[];
+}
+/**
+ * Adapter dep for `editAnchorsAction`: narrow read/write access to the
+ * editable polygon of a single node, so anchor-edit actions need not know
+ * whether it lives directly on the node's pose (`pose.kind === 'polygon'`)
+ * or on `node.data.path`.
+ *
+ * In-flight edit state is surfaced through the dispatcher's
+ * `OngoingHandle.previewIds/previewPose/previewData` triple, not this dep.
+ */
+interface EditAnchorsDep {
+    /** Id of the node currently being edited. Empty string means no node is
+     *  currently in edit mode — the chrome and gesture both opt out. */
+    editingId: string;
+    /** Enter/exit edit mode for a specific node. Pass `null` (or an empty
+     *  string) to exit. */
+    setEditingId(id: string | null): void;
+    /** Returns the COMMITTED editable polygon in world coordinates, or
+     *  null if this node has no editable polygon. For a node whose path was
+     *  drawn from a form a `PathRepresentation` reads, it is that form's edit
+     *  path, which `applyEdit` turns back into the drawn path. Does NOT consult in-
+     *  flight previews — callers that need live state read the dispatcher's
+     *  in-flight handles. */
+    getEditablePath(id: string): unknown;
+    /** The drawn geometry, in world coordinates, whose outline is a segment press, where it
+     *  differs from `getEditablePath`'s: a path drawn from a form. Absent, `getEditablePath`'s. */
+    getOutlinePath?(id: string): unknown;
+    /** Returns where the polygon is stored — `'pose'` when `node.pose`
+     *  IS the polygon, `'data'` when it lives on `node.data.path` with a
+     *  rect pose, or `null` when the node has no editable polygon. */
+    getStorageKind(id: string): 'pose' | 'data' | null;
+    /** Returns the node's raw `pose` and `data` so storage-aware actions
+     *  can capture origin state at gesture-start and synthesize a matching
+     *  `previewPose` / `previewData` during `onMove`. Returns null when the
+     *  node is gone. */
+    getNodeShape(id: string): {
+        pose: unknown;
+        data: unknown;
+    } | null;
+    /** Commit `worldPath` as the new value for `id`, as one history entry
+     *  labeled `label`: a setPose when the pose IS the polygon, a batched
+     *  setPose+update when it lives on data.path. Given `origins` (from
+     *  `editAnchorSetTracked`), its per-anchor data (skin, vertex colors) is
+     *  renumbered in that entry. The edit is finished first (see `finishEdit`); one an extension cannot
+     *  finish commits nothing. */
+    applyEdit(id: string, worldPath: unknown, label: string, origins?: readonly (PointOrigin | null)[]): void;
+    /** The ops `applyEdit` would commit for the same arguments, unapplied, so
+     *  a caller can make the edit part of a larger batch — the pen joining
+     *  two paths edits one node and deletes the other in one undo step.
+     *  Optional; a caller that needs it declines the composite edit without
+     *  it. Returns `[]` when `id` has no editable polygon, or when an
+     *  extension cannot finish the edit. */
+    editOps?(id: string, worldPath: unknown, label: string, origins?: readonly (PointOrigin | null)[]): Op[];
+    /**
+     * Anchors currently selected within the edited path, as **flat anchor
+     * indices** — the same numbering `enumerateAnchors` produces and the
+     * `anchor:N` affordance kinds carry.
+     *
+     * Selection is transient UI state, deliberately not part of the scene:
+     * it is cleared whenever `editingId` changes, and any edit that
+     * renumbers anchors (insert, delete) is responsible for leaving it
+     * coherent. Empty means "no anchor selected" — the keyboard actions
+     * (nudge, delete) no-op rather than acting on all anchors.
+     */
+    selectedAnchors: ReadonlySet<number>;
+    /** Replace the anchor selection. Pass an empty iterable to clear. */
+    setSelectedAnchors(next: Iterable<number>): void;
+    /** In-flight anchor-marquee rect in world coords, or null when no
+     *  marquee drag is active. */
+    marquee: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /** Set or clear the in-flight marquee rect. */
+    setMarquee(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null): void;
+    /** The path-edit tool in use, or null for plain anchor editing — one of a
+     *  set of named tools, such as `'simplifyBrush'`, that each change what a
+     *  plain drag in path edit does. Always null with no path open. */
+    tool: string | null;
+    /** Switch path-edit tool, or pass null for plain anchor editing. */
+    setTool(id: string | null): void;
+    /** The handle locks held for every handle drag, on top of the modifiers —
+     *  what the `handleLock.angle` and `handleLock.length` toggles set. Absent,
+     *  the drag holds what its `handleLock` param names. Unlike the anchor
+     *  selection, they outlast a change of edited path. */
+    handleLocks?: HandleLocks;
+    /** Replace the held handle locks. Absent, the toggles are unavailable. */
+    setHandleLocks?(next: HandleLocks): void;
+    /**
+     * `worldPath`, an edit of `id`'s committed path, finished by every
+     * extension's `finishEdit` in turn — path constraints made to hold, say —
+     * with the paths of any other nodes that move with it. Null when one cannot
+     * finish it, and the edit should then not happen. `applyEdit` and `editOps`
+     * run it themselves; an ongoing edit calls it each frame so its preview is
+     * what they will commit. Optional: absent, edits stand as they are.
+     */
+    finishEdit?(id: string, worldPath: unknown, origins?: readonly (PointOrigin | null)[]): FinishedEditFrame | null;
+    /**
+     * Commit `worldPath` for `id` with `data` laid over its data, as one
+     * history entry, finished by no extension: what an extension writing its
+     * own data with a path it already solved commits through. Optional.
+     */
+    store?: PathEditStore;
+    /** The canvas's path-edit extensions, in order. */
+    extensions?: readonly PathEditExtension[];
+    /**
+     * The extension mark selected in place of anchors, or null. Selecting one
+     * clears the anchor selection and selecting anchors clears it, so Delete
+     * acts on one or the other. Optional.
+     */
+    selectedMark?: PathEditMark | null;
+    /** Select an extension's mark, or pass null to clear. */
+    setSelectedMark?(mark: PathEditMark | null): void;
+}
+
+/** Context handed to every content handler for one ingest event. */
+interface IngestCtx {
+    /** World-space arrival point (drop / pointed imperative ingest); `null`
+     *  for paste and point-less calls — handlers pick their own policy
+     *  (the kit image handler centers on the viewport). */
+    point: {
+        x: number;
+        y: number;
+    } | null;
+    /** Visible canvas area in world coordinates. */
+    viewportWorldRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** 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;
+    /** Raw op commit for handlers that build their own ops. */
+    applyOps(ops: Op[], label?: string): void;
+    scene: Scene<unknown, string, unknown>;
+    selection: SelectionApi;
+    /** Consumer file→src resolver (SceneCanvas `ingestion.resolveSrc`).
+     *  When absent, the kit image handler embeds as a `data:` URI. */
+    resolveSrc?: (file: File) => Promise<string>;
+    /** Kit SVG-handler options (SceneCanvas `ingestion.svg`) — e.g.
+     *  `{ unpack: unpackSvgFiles }` (from `@weasel-js/svg`) to parse SVG files
+     *  into scene nodes. */
+    svg?: SvgIngestOptions;
+    /** Clipboard-paste seam — present when the hosting `SceneCanvas` supplied
+     *  an adapter with `commitPaste`. `reviver` comes from
+     *  `SceneCanvasProps.ingestion.clipboard`. Absent ⇒ the kit weasel-JSON
+     *  handler declines inert (dwarn, nothing ingested) — its matched items
+     *  were already consumed at match time, so they do NOT fall through;
+     *  only match-level misses flow on to other handlers. */
+    clipboard?: ClipboardIngestCtx;
+    /** Set to `true` by the kit weasel-JSON handler when it successfully
+     *  pastes a payload in this event. `kit:svg`'s `text/plain` SVG fallback
+     *  reads this to decline the SVG flavor of a copy whose weasel-JSON flavor
+     *  already ingested (avoids a double-paste when both flavors ride one
+     *  clipboard event). */
+    consumedWeaselPayload?: boolean;
+    /** Full action-deps bag, for consumer handlers that need more. */
+    deps: ActionDeps;
+}
+/** A handler for content arriving by paste, drop or file picker. Handlers are
+ *  matched by MIME glob or predicate and run highest-priority first; the kit's
+ *  own register at a low priority so a consumer's handler wins by default. */
+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. */
+    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
+     *  asked about it; this is what it is asked instead. Without it, no drag
+     *  can be refused while this handler is registered. */
+    types?: readonly string[];
+    /** Higher runs earlier. Kit defaults register at -100 so any consumer
+     *  handler (default 0) beats them. */
+    priority?: number;
+    handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;
+}
+/** Register a content handler. Returns a disposer that removes it. */
+declare function registerContentHandler(entry: ContentHandlerEntry): () => void;
+
+/**
+ * Options for the kit `image/svg+xml` content handler, threaded from
+ * SceneCanvas's `ingestion={{ svg }}` prop.
+ */
+interface SvgIngestOptions {
+    /** Parse dropped/pasted/picked SVG files into native scene nodes (path /
+     *  text leaves under containers mirroring the source `<g>` structure)
+     *  instead of the default single embedded-image node.
+     *
+     *  Pass `unpackSvgFiles` from `@weasel-js/svg`:
+     *
+     *  ```ts
+     *  import { unpackSvgFiles } from '@weasel-js/svg';
+     *  <SceneCanvas ingestion={{ svg: { unpack: unpackSvgFiles } }} />
+     *  ```
+     *
+     *  It is injected rather than flagged on with `true` because the SVG parser
+     *  lives in `@weasel-js/svg`, which depends on this package. */
+    unpack?: SvgUnpacker;
+}
+/** Parses SVG files and inserts the resulting nodes into `ctx.scene`, as one
+ *  `applyOps` batch per file. Implemented by `unpackSvgFiles` in
+ *  `@weasel-js/svg`; see {@link SvgIngestOptions.unpack}. */
+type SvgUnpacker = (files: File[], ctx: IngestCtx) => Promise<void>;
+/**
+ * Clipboard-paste seam consumed by the kit weasel-JSON content handler
+ * (`IngestCtx.clipboard`). Built by `<SceneCanvas>` from its own synthesized
+ * adapter + the `ingestion.clipboard` prop; absent when the consumer set
+ * `ingestion.clipboard.enabled === false` or the adapter lacks `commitPaste`.
+ * Absence makes the handler decline inert (dwarn, nothing ingested) — its
+ * matched items were already consumed at match time and do not fall through
+ * to other handlers.
+ */
+interface ClipboardIngestCtx {
+    /** The hosting canvas's adapter — `commitPaste` materializes the pasted
+     *  nodes (fresh ids, offset applied); insertion still goes through ops. */
+    adapter: InsertAdapter<{
+        id: string;
+    }>;
+    /** JSON reviver for the weasel wire payload (typed arrays etc.) — from
+     *  `SceneCanvasProps.ingestion.clipboard.reviver`. */
+    reviver?: (key: string, value: unknown) => unknown;
+    /** Told what a paste left out and why — from
+     *  `SceneCanvasProps.ingestion.clipboard.onOmitted`. */
+    onOmitted?: (omitted: PasteOmission[]) => void;
+}
+/** Dep for the `ingest` action (external-content ingestion). */
+interface IngestionDep {
+    /** Visible canvas area in world coordinates. */
+    viewportWorldRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Consumer file→src resolver (from SceneCanvas's `ingestion` prop).
+     *  Live accessor — read it at use time. Destructuring (or copying the
+     *  property early) snapshots the current value and won't track later
+     *  prop changes across an `await`. */
+    resolveSrc?: (file: File) => Promise<string>;
+    /** Kit SVG-handler options (from SceneCanvas's `ingestion` prop).
+     *  Live accessor, same caveat as `resolveSrc`. */
+    svg?: SvgIngestOptions;
+    /** Clipboard-paste seam for the kit weasel-JSON handler.
+     *  Live accessor, same caveat as `resolveSrc`. */
+    clipboard?: ClipboardIngestCtx;
+}
+
+/** The gesture an insert's bounds came from, in the same coordinates: `bounds`
+ *  is the box `start` and `end` span, or with `fromCenter`, the box centered
+ *  on `start` reaching `end`. A host whose bounds lose information on the
+ *  way, a 3D one casting them onto a plane, reads the ends instead. */
+interface InsertEnds {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    fromCenter?: boolean;
+}
+/** Adapter dep for `insertAction`. The `extras` carry the active tool's kind
+ *  + per-kind geometry. */
+interface InsertDep {
+    /**
+     * Materialise a new node from the given drag-rect bounds and typed
+     * per-kind extras. Returns the new node's id, or `null` if the consumer
+     * rejected the insert (e.g. sub-threshold bounds, unknown kind).
+     */
+    commit(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, extras: InsertExtras, 
+    /** Absent when no gesture made the bounds: a path the pen or spiro
+     *  drew, or content a paste ingests. A click-place reads as a drag out
+     *  from its center. */
+    ends?: InsertEnds): NodeId | null;
+    /**
+     * What `commit` would apply, unapplied: the new node's id and the ops that
+     * insert it, for a caller that has more to put in the same undo step. The
+     * pen joins two paths this way. Without it such a caller declines.
+     */
+    build?(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, extras: InsertExtras, ends?: InsertEnds): {
+        id: NodeId;
+        ops: Op[];
+    } | null;
+    /** The scene layer `commit` puts the node on. An insert on a layer carrying
+     *  `parallax` is dragged out in that plane's world, so `bounds` arrive
+     *  there too. Omitted: the camera's world. */
+    layer?(): string;
+}
+/**
+ * What `editAnchorsAction` keeps a path symmetric under. Asked once at the
+ * press, with the id of the path being edited; answer every transform of the
+ * symmetry group except the identity, in world coordinates. Of those, the
+ * ones the path is already its own image under are held through the drag:
+ * each image of a dragged anchor or handle follows it, and one a transform
+ * fixes stays where that transform allows.
+ */
+interface PathSymmetryDep {
+    transforms(id: string): readonly Affine[];
+}
+/** Where the `insert` dep puts what it makes. Read at each insert. A node
+ *  goes onto the container's layer, with its pose made local to it when the
+ *  scene composes frames; an id naming no container is the same as `null`. */
+interface InsertIntoDep {
+    get(): string | null;
+}
+/** Holder for the insert gesture in flight in one input scope. `gesture` is
+ *  `insertAction`'s own state, opaque to everything else, and `null` between
+ *  gestures. A source must return the same object on every read. */
+interface InsertLive {
+    gesture: unknown;
+}
+
+/**
+ * The deps behind text editing, the clipboard, and Slice.
+ */
+
+/**
+ * Dep for `enterTextEditAction`.
+ *
+ * Wrap the return value of `useTextEdit` / `useSceneTextEdit` to source this
+ * dep. The `isTextNode` predicate is optional — when absent the action fires
+ * unconditionally (the binding spec acts as the gate).
+ *
+ * @example
+ * ```ts
+ * const textEdit = useSceneTextEdit(scene, container);
+ * useDepSource('textEdit', () => ({
+ *   startEdit: textEdit.startEdit,
+ *   isTextNode: textEdit.isTextNode,
+ * }));
+ * ```
+ */
+interface TextEditDep {
+    /** Begin editing the node with `id`. */
+    startEdit(id: string, opts?: {
+        caret?: number | 'all';
+    }): void;
+    /**
+     * Optional predicate: returns `true` when the node with `id` is a text node.
+     * When absent the action fires on any selected node (binding spec is the gate).
+     * When present and returning `false`, the invocation is a no-op.
+     */
+    isTextNode?(id: string): boolean;
+}
+/**
+ * Clipboard dep — the imperative surface `useClipboardOps` returns.
+ *
+ * Consumers publish their live clipboard through `useDepSource('clipboard',
+ * …)` from inside the `<DepRegistryProvider>` (i.e. under `<SceneCanvas>`).
+ * The kit deliberately does not build one for them: `useClipboardOps` needs
+ * an adapter and a selection reader that only the consumer can supply.
+ */
+interface ClipboardDep {
+    copy(): void;
+    paste(at?: {
+        worldX: number;
+        worldY: number;
+    }): void;
+    isEmpty(): boolean;
+}
+/**
+ * The commit behind the Slice action. `commit` receives the cut as a polyline
+ * of at least two points (world coords): the drag's two ends for a straight
+ * cut, its whole trail for a freehand one, the placed points for a
+ * click-by-click one, whose last point equals its first when it closes into
+ * a loop. `<SceneCanvas>` publishes one over its scene (`useSliceDepSource`);
+ * a consumer replaces it with `useSliceDep`.
+ */
+interface SliceDep {
+    commit(cut: ReadonlyArray<Point2>): void;
+}
+
+/** Minimal view API the action layer consumes. */
+interface ViewApi {
+    get(): View;
+    set(v: View): void;
+    /** How this camera's world maps into the world the invocation edits in,
+     *  when that is a parallax plane — set by `inPlane` on the view it hands a
+     *  wrapped action. Absent or null: the camera's own world. */
+    plane?(): PlaneMap | null;
+    /** How the world the invocation edits in maps into the world `layer`'s
+     *  nodes are stored in, read now — set by `inPlane` alongside `plane`.
+     *  Absent or null: the same world. */
+    planeOf?(layer: string): PlaneMap | null;
+    /** Optional recenter callback. When wired, `viewportZoomAction`'s `reset`
+     *  branch (Cmd-0) calls this instead of resetting to identity. Return the
+     *  target `View` to let the action animate there; return nothing to keep
+     *  dispatching the view yourself. */
+    recenter?(): View | void;
+    /** Optional canvas-local host dimensions (CSS px). When wired,
+     *  `viewportZoomAction`'s keyboard branches (Cmd+= / Cmd+-) anchor at the
+     *  host center instead of the top-left origin. Null when the host isn't
+     *  measurable (unmounted). */
+    hostSize?(): {
+        width: number;
+        height: number;
+    } | null;
+    /** Optional camera animation. `<SceneCanvas>` wires these three; a consumer
+     *  publishing their own `view` dep need not, and actions fall back to `set`. */
+    animate?(to: View, opts?: ViewAnimationOptions): void;
+    stopAnimation?(): void;
+    /** Where an in-flight camera animation is heading, or null. Compute the next
+     *  discrete step from this so repeated presses compound. */
+    animationTarget?(): View | null;
+    /** Optional momentum decay. `<SceneCanvas>` wires this from `useDecayLoop`;
+     *  a consumer publishing their own `view` dep need not, and `viewport.dragPan`
+     *  simply lands the pan without coasting. */
+    decay?(config: DecayLoopConfig): void;
+    stopDecay?(): void;
+    /** Whether a scene layer reaches the screen in this view — its own
+     *  `layerVisibility` / `layerOrder`, on top of the scene's `visible` flag.
+     *  Absent: this view paints every layer the scene shows. Selecting actions
+     *  pass over what the asking view does not paint. */
+    layerIsPainted?(layerId: string): boolean;
+}
+/** The part of the asking view a region hit-test consults. `get` is its
+ *  camera, which a parallax layer is picked through. */
+type HitTestView = RegionPickView;
+/**
+ * Topmost-node-at-world-point dep, for any action that needs a single-best
+ * pick. The dep walks hits front-to-back and returns the first id not in
+ * `exclude`. Pass moving-node roots + their descendants when the caller
+ * wants to ignore the nodes it's manipulating.
+ */
+type NodeAtPointDep = (point: {
+    x: number;
+    y: number;
+}, exclude?: Iterable<NodeId>) => NodeId | null;
+/** What an area-selecting action needs: a way to ask what a region covers,
+ *  and a way to read and replace the selection. */
+interface AreaSelectDep {
+    /** Return ids of all scene nodes whose AABB overlaps `bounds`, skipping any
+     *  on a layer `view` — the view the gesture ran in — does not paint. */
+    hitTestArea(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, view?: HitTestView): NodeId[];
+    /** Return the current selection id list. */
+    getSelection(): NodeId[];
+    /** Replace the current selection. */
+    setSelection(ids: NodeId[]): void;
+}
+/**
+ * Adapter dep for `lassoSelectAction`: polygon-lasso hit-testing +
+ * selection read/write.
+ */
+interface LassoSelectDep {
+    /**
+     * Hit-test against a closed polygon (vertex order CW or CCW; last→first
+     * closing edge is implicit). Returns matching node ids.
+     * Optional — when absent, `lassoSelectAction` falls back to AABB via
+     * `hitTestArea`.
+     */
+    hitTestLasso?(polygon: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>, mode: 'centers' | 'intersect' | 'enclosed', view?: HitTestView): string[];
+    /** Return ids of nodes whose AABB overlaps the given rect (fallback). */
+    hitTestArea(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, view?: HitTestView): string[];
+    /** Return the current selection id list. */
+    getSelection(): string[];
+    /** Replace the current selection. */
+    setSelection(ids: string[]): void;
+}
+
+/**
+ * Per-kind extra geometry passed to `InsertDep.commit`.
+ *
+ * Built-in tools populate a typed variant so the kit's default factory can
+ * render the true tool params (line endpoints, polygon side count, star
+ * geometry, pencil sample list). Consumer-defined tools may pass any
+ * `{ kind: string; ... }` payload; the kit's factory falls back to AABB
+ * inscription for unknown kinds.
+ *
+ * `bounds` is still passed alongside as a useful AABB pose hint — factories
+ * may use it as the node's pose even when richer geometry is available. Any may carry a `minSize`
+ * (`{ width, height }`), which the kit's factories keep as `data.minSize` so a resize holds to it.
+ */
+type InsertExtras = {
+    kind: 'rect';
+} | {
+    kind: 'ellipse';
+} | {
+    kind: 'line';
+    a: {
+        x: number;
+        y: number;
+    };
+    b: {
+        x: number;
+        y: number;
+    };
+} | {
+    kind: 'polygon';
+    sides: number;
+    rotation: number;
+    center?: {
+        x: number;
+        y: number;
+    };
+    radius?: number;
+} | {
+    kind: 'star';
+    points: number;
+    innerRadiusRatio: number;
+    rotation: number;
+    center?: {
+        x: number;
+        y: number;
+    };
+    outerRadius?: number;
+} | {
+    kind: 'pencil';
+    samples: ReadonlyArray<DragSample>;
+} | {
+    kind: 'text';
+    text?: string;
+}
+/** A sticky note: a text node with a background, in the look its tool names. */
+ | ({
+    kind: 'sticky';
+    text?: string;
+} & StickyStyle)
+/** A finished path in world coords, as the pen tool commits one. `bounds`
+ *  is its AABB. An open path takes no fill. `data` is laid under the path
+ *  and paint on the node's data: the form the path was drawn from
+ *  (`data.representation`), say. */
+ | {
+    kind: 'path';
+    path: _weasel_js_geom.PolygonPath;
+    closed: boolean;
+    data?: Readonly<Record<string, unknown>>;
+} | {
+    kind: 'image';
+    src?: string;
+    opacity?: number;
+    /** Chrome-only: what the in-flight drag paints. Read by the overlay
+     *  layer, ignored by the insert dep. */
+    preview?: 'bitmap' | 'outline';
+} | {
+    kind: string;
+    [extra: string]: unknown;
+};
+
+/**
+ * Adapter dep for `resizeAction`: bounds-frame behaviors (e.g.
+ * `clampMinSize`) and group-expansion (`expandIds`). Snapping is the `snap`
+ * dep's.
+ *
+ * The generic is erased to `unknown` at the schema entry; consumers cast at
+ * the call site.
+ */
+interface ResizePolicy<TPose> extends GestureLifecycleOptions {
+    /** Bounds-frame constraints. Constrained to `TPose extends Bounds` since
+     *  constraints read/write `{x,y,width,height}`. For non-rect TPose pass `[]`. */
+    constraints: TPose extends FramedBox ? BoundsConstraint<TPose>[] : never[];
+    /** Group-expansion at gesture start. Identity (`ids => ids`) when group
+     *  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.
+ *
+ * This is the whole vocabulary of things an action can reach — selection,
+ * scene, view, history, and the rest. The interface is declared in
+ * `@weasel-js/routing`, which knows that an action names its dependencies but
+ * owns only `activeTool` among them; these entries are the kit's, merged in from
+ * outside exactly the way a consumer merges its own
+ * (`declare module '@weasel-js/core'`).
+ */
+declare module '@weasel-js/routing' {
+    interface DepSchema {
+        /** Kit selection state — ids of currently selected nodes. */
+        selection: SelectionApi;
+        /** Current viewport — camera position + scale. */
+        view: ViewApi;
+        /**
+         * Scene tree — structural reads + undoable mutations.
+         *
+         * The entry uses the fully-erased form `Scene<unknown, string, unknown>`
+         * because `DepSchema` must be concrete; any `Scene<MyData, MyLayer,
+         * MyPose>` is assignable to it. Actions that need a typed scene back
+         * should cast: `deps.scene as Scene<MyData, MyLayer, MyPose>`.
+         */
+        scene: Scene<unknown, string, unknown>;
+        /** Undo/redo history bound to the current scene. */
+        history: History;
+        /** Area-select dep — AABB hit-test + selection read/write. Override
+         *  per-consumer for custom hit-testing (e.g. contain-mode). */
+        areaSelect: AreaSelectDep;
+        /** Topmost node at a world-space point. Optional: actions that read this
+         *  (e.g. `moveAction` reparent-on-drop) fall back to a no-op when the dep
+         *  isn't registered. */
+        nodeAtPoint?: NodeAtPointDep;
+        /** Insert dep — node factory for drag-to-insert. Override per-consumer to
+         *  provide a typed node factory (e.g. with custom data payloads). */
+        insert: InsertDep;
+        /** Where `insertAction` keeps its gesture in flight, so
+         *  `insert.adjustRotation` reaches the one in its own input scope.
+         *  Sourced by `<SceneCanvas>`; without it the rotation does nothing. */
+        insertLive?: InsertLive;
+        /** The params an action starts with in this scope when its binding
+         *  passes `given`, `<SceneCanvas tune>` included: what a tool's chrome
+         *  reads to draw what the action it binds will make. Sourced by
+         *  `<SceneCanvas>`. */
+        actionParams?: (id: string, given?: Record<string, unknown>) => Record<string, unknown>;
+        /** The container the `insert` dep puts new nodes into — every shape a
+         *  tool draws and every dropped image or text. Absent, or answering
+         *  `null`: the top of the tree. */
+        insertInto?: InsertIntoDep;
+        /** Snap dep: the sessions a gesture snaps through, over `<SceneCanvas
+         *  snap>`'s sources. Absent means no snapping. */
+        snap?: SnapDep;
+        /** The store the snap readout layer draws, for an action's own marks. Sourced by `<SceneCanvas>`. */
+        snapReadout?: SnapReadoutDep;
+        /**
+         * The canvas's debug sink.
+         * Sourced by `<SceneCanvas>`; absent while its `debug` overlay is off.
+         * Actions report what they did here, and the overlay draws it.
+         */
+        debug?: DebugSink;
+        /** Where an action's `preview` draws what it would make, over the canvas.
+         *  Sourced by `<SceneCanvas>`. */
+        previewPaths?: PreviewPathsDep;
+        /** Viewport point of a world point on this canvas, or null before it mounts.
+         *  Sourced by `<SceneCanvas>`. */
+        worldToClient?: (x: number, y: number) => {
+            x: number;
+            y: number;
+        } | null;
+        /** Lasso-select dep — polygon hit-test + selection read/write. */
+        lassoSelect: LassoSelectDep;
+        /** Edit-anchors dep — narrow read/write of one polygon's path. If
+         *  absent, `editAnchorsAction`'s `start` returns an empty handle (no-op). */
+        editAnchors: EditAnchorsDep;
+        /** The transforms a path being edited should stay its own image under.
+         *  Absent: an anchor drag moves only what is dragged. */
+        pathSymmetry?: PathSymmetryDep;
+        /**
+         * Text-edit dep — activates the in-place text editing overlay. Sourced
+         * from consumer via `useTextEdit` / `useSceneTextEdit`.
+         *
+         * The optional `isTextNode` predicate guards against entering edit mode on
+         * non-text nodes. A binding can pre-filter instead with a
+         * `target: 'kind:text:selected'` spec; the guard remains for consumers who
+         * bind the broader `'selected-body'` target or opted out of routing.
+         */
+        textEdit: TextEditDep;
+        /**
+         * Resize-policy dep — bounds constraints, point-snap behaviors and
+         * group expansion for `resizeAction`. Optional: when omitted,
+         * `resizeAction` falls back to identity defaults. Consumers wire via
+         * `useDepSource('resizePolicy', ...)` or the `useResizePolicy` helper.
+         */
+        resizePolicy?: ResizePolicy<unknown>;
+        /**
+         * How to read and rewrite a pose — bounds, translate, remap, rotation. Every
+         * built-in action that touches a pose reads it. Sourced by `<SceneCanvas>`
+         * from its `poseDescriptor` prop; `AUTO_POSE_DESCRIPTOR` when absent.
+         */
+        poseDescriptor?: PoseDescriptor<unknown>;
+        /** Whether the box resize, rotate, flip, align, and distribute work against
+         *  includes the stroke. From `<SceneCanvas geometry.boundsIncludeStroke>`;
+         *  absent means `true`. */
+        boundsIncludeStroke?: boolean;
+        /**
+         * Booleans adapter — read selection ids, fetch world-space `Path`s,
+         * compare z-order, and mint result nodes for Pathfinder ops.
+         *
+         * Consumers wire via `useBooleansAdapter(adapter)`.
+         */
+        booleansAdapter?: BooleansAdapter;
+        /**
+         * Create Outlines adapter — read selection ids, resolve text nodes, and
+         * mint the path nodes that replace them. Consumers wire it with
+         * `useCreateOutlinesAdapter(adapter)`; the `createOutlines` action reads it
+         * in both its `enabled` predicate and its invoker.
+         */
+        createOutlinesAdapter?: CreateOutlinesAdapter;
+        /** Gesture dispatcher control surface, so an action can abort an
+         *  in-flight handle (Escape cancels a drag, etc.). */
+        dispatcher?: {
+            cancelAll(reason: 'commit' | 'cancel'): void;
+        };
+        /**
+         * Layout-strategy lookup. Sourced by `<SceneCanvas>` from the scene.
+         * Optional: absent (or all-null) → `moveAction` skips reflow.
+         */
+        layout?: LayoutDep;
+        /**
+         * Slice dep — the commit for the Slice action. `<SceneCanvas>` publishes
+         * `useSliceDepSource`; a consumer overrides it with `useSliceDep`.
+         *
+         * Optional: when absent, `sliceAction` is a no-op.
+         */
+        slice?: SliceDep;
+        /** Clipboard dep; see {@link ClipboardDep}. `clipboard.copy` and
+         *  `clipboard.cut` both no-op when it is absent. */
+        clipboard?: ClipboardDep;
+        /**
+         * Optional consumer commit hook. When present, `moveAction` (and other
+         * default actions) submit their committed ops through it instead of
+         * `scene.applyBatch`, so apps with their own history integration
+         * (checkpoint + push entry) capture the gesture as one undo entry.
+         * When absent, commits fall back to `scene.applyBatch`.
+         */
+        applyOps?: (ops: Op[], label: string) => void;
+        /**
+         * Ingestion dep — canvas viewport rect + consumer file→src resolver.
+         * Optional: when absent, the `ingest` action no-ops (there is no
+         * placement geometry to work with).
+         */
+        ingestion?: IngestionDep;
+        /**
+         * Optional consumer seam for the eager-sync layer: lets pose-transform
+         * actions (resize/move/nudge/flip — NOT rotate) ALSO rewrite a node's
+         * data-held geometry. Given a node and the affine `m` applied to its pose,
+         * `transform(node, m)` returns updated `data` (geometry mapped by `m`) or
+         * `null` for nodes with no data-held geometry.
+         *
+         * Strictly opt-in: when absent (or when `transform` returns null), the kit
+         * emits only the pose op and leaves `data` untouched. Rotate intentionally
+         * never consults this seam (rotation lives on the pose, baked at render).
+         */
+        geometryProjection?: GeometryProjection;
+        /**
+         * The surface's own camera. Inside a `<CanvasView>`, `view` answers that
+         * view's camera and this one does not change: an action bound in a view
+         * that must move the main camera — a minimap's pan — reads this.
+         */
+        rootView: ViewApi;
+        /**
+         * The pointer store in scope: where the pointer is, in which view. Shared
+         * by every surface under one `<PointerContextProvider>`.
+         */
+        pointer?: _weasel_js_routing_react.PointerContextValue;
+        /**
+         * The touch or pen long-press being held, if any: where, since when, how
+         * far through, and whether any binding would fire on it. Sourced by
+         * `<SceneCanvas>` from its gesture dispatcher; press feedback reads it.
+         */
+        longPress?: LongPressState;
+    }
+}
+
+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 };