@weasel-js/core 1.9.3 → 1.9.4

package/dist/builtins-C-VgUlWI.d.ts

@@ -1,4514 +0,0 @@
-import { G as GlMat3, a as ShaderProgramHandle, b as ShaderUniform, c as ShaderProgram } from './registerProgram-BMZRDgrh.js';
-import { Mesh } from '@weasel-js/geom/tessellate';
-import { GradStop, ColorSpace, FillStyle, Stroke, ScreenLength } from '@weasel-js/paint';
-import { NodeId, Bounds, View, ModifierState, SelectionApi, ActionDeps, IngestItem, DragSample, DebugSink, Point2, LongPressState, AnyToolOf, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, Tool as Tool$1, ToolDef as ToolDef$1 } from '@weasel-js/routing';
-import { Path, EasingSpec, SpringPresetName, PolygonPath, Rect, Mat3 } from '@weasel-js/geom';
-import { ReactNode } from 'react';
-import * as _weasel_js_history from '@weasel-js/history';
-import { Op, History, SerializedHistory } from '@weasel-js/history';
-import { L as LayoutStrategy, a as ParallaxOpts, C as ContainerBounds, b as SceneAdapter, P as PlaneMap, R as RegionPickView, c as LayoutDropTargetMode, d as ReflowTransition, I as InsertAdapter } from './types-A37hYkeR.js';
-import { FontStyle } from '@weasel-js/font';
-import { ResolvedRun, TextStyle, TextVerticalAlign, StyledRun } from '@weasel-js/text';
-import { P as PoseDescriptor } from './poseDescriptor-D-OH-tu5.js';
-import { ActiveToolContextValue, ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1 } from '@weasel-js/routing/react';
-import { B as BoundsConstraint, P as PointSnapBehavior } from './types-B_9g6hMM.js';
-import { CursorSpec } from '@weasel-js/cursor';
-import { ClaimableGesture } from '@weasel-js/gestures';
-
-/**
- * Folding a node's pose up its parent chain to world, and back down. Lives
- * under `core/` so the scene can lay out in world without reaching up into
- * `features/`; `features/groups/composePose` re-exports all of it.
- */
-/** 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;
-}
-/**
- * The transforms a `compose` represents **exactly**. A parent transform wider
- * than its strategy's closure is rounded to the nearest pose — for `'rigid'`
- * that means an anisotropically scaled parent turns a rotated child into a
- * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the
- * shear is dropped.
- *
- * Measured over 50,000 random parent/child pairs: rotation and translation
- * compose to within 5.7e-13, anisotropic scale to a right-angle error of 0.99.
- * See `docs/superpowers/specs/2026-09-10-group-as-frame-design.md`.
- */
-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. Both `compose` and
- *  `decompose` return the child/world pose unchanged, modeling an
- *  absolute-pose scene where every node stores world coords and parents are
- *  grouping-only (no transform). With this strategy `composeWorldPose`
- *  returns a node's own raw pose and `rebaseLocalPose` is a no-op. */
-declare const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown>;
-/**
- * Walk `id`'s parent chain (root first to id last) and fold local poses into
- * a world pose via `compose`. Returns the world pose for `id`. Cycle-safe:
- * a visited-set guard breaks if the chain ever loops back to itself.
- *
- * `compose(parent, child)` interprets `child` as expressed *in `parent`'s
- * local frame* and returns the equivalent pose in the next frame up. For a
- * standard translation-only rect: `world = { x: p.x + c.x, y: p.y + c.y,
- * width: c.width, height: c.height }`.
- */
-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. Used when reparenting so the child's visual world position is
- * preserved despite the change of frame. Inverse of one `compose` step.
- *
- * `decompose(parent, world)` returns the local pose `child` such that
- * `compose(parent, child) === world`. For axis-aligned rects:
- * `child = { ...world, x: world.x - parent.x, y: world.y - parent.y }`.
- *
- * 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;
-
-/**
- * Axis-aligned rectangle pose with optional rotation. The canonical pose
- * shape used by `composeRectPose` and the `unionBounds` helper. Rotation is
- * in radians, pivoted on the unrotated AABB center; absent === 0. Kit-side
- * code that consumes rotation already reads `pose.rotation ?? 0`
- * (`wrapNodeOutput`, `rotate/handle.ts`, `pathInWorld.ts`), so
- * the slot exists on every default scene whether or not the consumer
- * populates it.
- */
-interface RectPose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Rotation in radians around the unrotated AABB center. Absent === 0. */
-    rotation?: number;
-}
-
-/** Brand a string as a NodeId. */
-declare const asNodeId: (s: string) => NodeId;
-/**
- * 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`. The scene already
- * invalidates dependents on `kit:setData` and `kit:setLayer` for exactly that,
- * so handing over only the pose made the invalidation pay for a read nothing
- * could perform.
- */
-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 it derives, or `null` when it derives none. Read it to place
-     *  something *along* a dependency rather than beside it — a label on a
-     *  routed edge, a tick on a curve.
-     *
-     *  Resolved on first read and memoized on the dependency, so a route costs
-     *  the same whether one node reads it or five, and a dependency nobody asks
-     *  about costs nothing. */
-    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>;
-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. Without it the innermost hit
-     *  wins, and dragging a labeled box moves the label out of the box. 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;
-    /** 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. Absolute-pose `Scene`
-     *  makes that the dependency's own pose, and an ancestor's move reaches it as
-     *  a `setPose` of its own from the container cascade. */
-    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 —
-     *  that is what lets a drag preview a node the document says is elsewhere.
-     *
-     *  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). When set, the
-     *  renderer rasterizes the returned path into the stencil buffer and
-     *  paints descendants only where it covers. */
-    clipFromPose?: ClipFromPoseFn<TPose>;
-    /** 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>;
-}
-/** A pose a container's layout wrote — reported by {@link Scene.onReflow} —
- *  in the node's stored frame. */
-interface LayoutMove<TPose> {
-    id: NodeId;
-    from: TPose;
-    to: TPose;
-}
-/** How a scene reads a laid-out container's bounds and folds poses to the
- *  world frame a {@link LayoutStrategy} works in. */
-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;
-    /** Omit for the absolute-pose model. A scene whose canvas composes poses
-     *  (`<SceneCanvas poseComposition>`) passes the same strategy here. */
-    composition?: PoseComposition<TPose>;
-}
-/** 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>;
-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 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>;
-/** 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;
-    /** Only meaningful when `kind === 'container'`. Attach a clip-path function
-     *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */
-    clipFromPose?: ClipFromPoseFn<TPose>;
-    /** 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>;
-}
-/** 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;
-}
-/** 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;
-}
-/** 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;
-    /** Render-stack position. Default: top of stack (highest render index). */
-    index?: number;
-}
-/** 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;
-    /** 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;
-    /** 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;
-}
-/** 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 `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;
-/** Options for `useScene` — the layers the scene has, what it starts out
- *  holding, and how its history behaves. */
-interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
-    systemLayers: readonly SystemLayerSpec<TLayer>[];
-    initial?: readonly AddNodeSpec<TData, TLayer, TPose>[];
-    ops?: Readonly<Record<string, RegisteredOp<unknown>>>;
-    historyLimit?: number;
-    /** Window (ms) within which consecutive same-shaped mutations merge into
-     *  the previous undo entry (matching per-op coalesce keys — e.g. repeated
-     *  `setPose` on the same node, or repeated `applyBatch` calls whose ops
-     *  carry matching `coalesceKey` multisets). `0` (default) disables
-     *  coalescing: every mutation is a discrete undo entry. Undo of a
-     *  coalesced entry returns to the state before the first merged mutation;
-     *  redo restores the latest. `scene.batch` entries never coalesce. */
-    coalesceWindowMs?: number;
-    generateId?: () => NodeId;
-    /** Per-scene registry for non-serializable function fields (clipFromPose, etc.).
-     *  Required only when serializing/deserializing scenes that use function fields. */
-    registry?: SceneRegistry<TPose, TData, TLayer>;
-    /** How laid-out containers are measured. See {@link LayoutFrame}. */
-    layoutFrame?: LayoutFrame<TPose>;
-    /** When supplied, `scene.applyOps(ops, label)` consults this on every call.
-     *  If it returns a non-null `Journal`, ops are routed to the journal's
-     *  `applyBatch` instead of recording a new parent-history entry. The journal
-     *  drives adapter mutation internally (via `op.apply(adapter)`), so the
-     *  scene state changes as normal; only the history tracking differs.
-     *
-     *  The accessor is called on every `applyOps` invocation so the caller can
-     *  swap the active journal in and out by updating the closure's reference
-     *  (e.g., an app's mode machine holds `let activeJournal: Journal | null`
-     *  and the accessor reads that variable).
-     *
-     *  When the accessor isn't known at scene-construction time (typical for
-     *  mode machines that depend on `scene.history`), pass nothing here and
-     *  wire it after construction via `scene.setActiveJournalAccessor(fn)`. */
-    getActiveJournal?: () => _weasel_js_history.Journal | null;
-    /** Re-render the host on every scene mutation. Default `true`. Set `false`
-     *  when the scene is read by a frame loop rather than by a render — a game
-     *  loop, a simulation — and nothing in the host's DOM derives from it.
-     *  Read by `useScene`; `createScene` ignores it. */
-    subscribe?: boolean;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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> {
-    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>;
-    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: the traversal already holds them, and re-looking each one
-     *  up was ~40% of the area hit-test's per-node cost. 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, so a caller that
-     *  only cares about one layer pays the tree walk once rather than once per
-     *  call. 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>[];
-    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. The authoritative answer — the cascade relations live here, and
-     *  a caller reconstructing them from `dependsOn` and `children` drifts the
-     *  moment a third one is added. 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;
-    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` sits on a locked layer or under a container that does.
-     *  A container's 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;
-    /** 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) the active-journal accessor after scene construction.
-     *  Useful when the journal source (typically a mode machine) is built
-     *  with `scene.history` as a dependency — a chicken-and-egg situation
-     *  where the accessor can't be passed in via `UseSceneOptions`.
-     *
-     *  Pass `null` to detach. 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 with journal-aware routing.
-     *
-     *  - **Without active journal** (or no `getActiveJournal` in options):
-     *    the ops themselves are recorded as one undo entry on the scene's own
-     *    history, rebound to `adapter` — undo replays each op's `invert()`
-     *    against that same adapter. Consecutive `applyBatch` entries can
-     *    coalesce via matching op `coalesceKey`s when the scene opts into
-     *    `coalesceWindowMs`.
-     *  - **With active journal**: routes ops to `journal.applyBatch(ops, label)`.
-     *    The scene's history recording is suppressed for the duration so the
-     *    journal's inner history — not the scene's undo stack — tracks the batch.
-     *    Mutations still happen on `adapter` / scene state.
-     *
-     *  `adapter` must be the same adapter the ops expect (typically a
-     *  `SceneCanvasAdapter`). Pass `this` from `sceneToAdapter` or a compatible
-     *  adapter. */
-    applyBatch(ops: Op[], label: string, adapter: unknown): void;
-    /** 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. */
-    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 —
-     *  what the kit's `undo` / `redo` actions resolve their `history` dep to, and
-     *  what a mode machine opens journals against. 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;
-    /** 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;
-    /** 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 by calling undo/redo repeatedly.
-     *  Clamps 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`). Entries containing any nameless op are
-     *  dropped (hand-rolled anonymous ops passed to `applyBatch`); kit and
-     *  consumer-registered ops always carry names. 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(): SerializedHistory;
-    /** 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. 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 (recorded via `applyBatch`, rebuilt from a
-     *  `restoreHistory` snapshot) apply against on undo/redo. 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.
-     *
-     *  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;
-    /**
-     * Override the kit's system max scale. Defaults to the kit-wide max zoom
-     * used by `computeWheelAction` (`DEFAULT_MAX_ZOOM`).
-     */
-    maxScale?: number;
-    /**
-     * Override the kit's system min scale. Defaults to the kit-wide min zoom
-     * used by `computeWheelAction` (`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.
- *
- * View semantics: `view.x` / `view.y` is the world point currently drawn at
- * the canvas top-left, and `view.scale.{x,y}` is pixels per world unit on
- * each axis (see `view.ts`). So:
- *   screenX = (worldX - view.x) * view.scale.x
- *   screenY = (worldY - view.y) * view.scale.y
- *
- * Empty / zero-sized bounds or viewports cannot be fit — in that case this
- * returns `currentView` unchanged and logs a `console.warn`. Callers that
- * want to no-op silently can detect zero area themselves before calling.
- */
-declare function fitViewToBounds(bounds: Bounds, viewportDims: ViewportDims, currentView: View, opts?: FitViewToBoundsOptions): View;
-
-interface GLMeshHandle {
-    readonly vao: WebGLVertexArrayObject;
-    readonly indexCount: number;
-    readonly requiresStencil: boolean;
-    readonly anchorA?: Uint32Array;
-    readonly anchorB?: Uint32Array;
-    readonly anchorT?: Float32Array;
-}
-/** Resources to release when a Mesh is reclaimed by GC. */
-interface MeshResources {
-    vao: WebGLVertexArrayObject;
-    vbo: WebGLBuffer;
-    ibo: WebGLBuffer;
-}
-/**
- * Caches GL-side buffers + VAO per `Mesh` identity. Upload happens lazily
- * on first `handleFor(mesh)` call.
- *
- * **GC-aware cleanup (deferred-delete queue):** when a Mesh becomes
- * unreachable, the WeakMap entry is dropped automatically — but the
- * underlying GL resources (VAO, VBO, IBO) would leak forever without an
- * explicit `gl.delete*` call. We register each Mesh with a
- * `FinalizationRegistry`; when the Mesh is reclaimed, the finalizer pushes
- * the resources onto an internal queue. The renderer drains this queue at
- * the start of each `render()` call (via `drainPendingDeletes()`), when GL
- * is in a known state — no VAO bound, no draw mid-flight. Deleting from the
- * finalizer directly was racy (it could fire between two `gl.bindVertexArray`
- * calls inside `dispatch()`, sometimes corrupting the next draw); deferring
- * the actual delete to a known-safe point keeps the use-after-free risk to
- * zero.
- *
- * Caveats:
- *   - Finalizer timing is non-deterministic; resources may live for a frame
- *     or two beyond their Mesh, but they will be reclaimed.
- *   - If the GL context is lost between finalizer and drain, the drain
- *     no-ops safely (`gl.isContextLost()` makes deletes no-ops, and
- *     `gl.deleteBuffer(null)` is allowed).
- *
- * The cache is GL-context-bound; if the context is lost and re-created, the
- * renderer should construct a new GLMeshCache. (Context loss handling lives
- * in `WeaselRenderer`.)
- */
-declare class GLMeshCache {
-    private readonly gl;
-    private readonly aPositionLoc;
-    private readonly map;
-    /** Meshes this context has drawn at least once; see `uploadRecurring`. */
-    private readonly seen;
-    private readonly finalizer;
-    /** Every persistent upload not yet freed, so `dispose` can reach them. */
-    private readonly persistent;
-    private readonly pendingDeletes;
-    private disposed;
-    /** Transient resources allocated this frame; freed at end of render(). */
-    private readonly transientThisFrame;
-    constructor(gl: WebGL2RenderingContext, aPositionLoc: number);
-    handleFor(mesh: Mesh): GLMeshHandle;
-    /**
-     * Upload a Mesh that the caller knows is single-use (e.g. the per-frame
-     * stroke ribbon from `tessellateStroke`). Returns a handle backed by fresh
-     * GL resources that the renderer will free deterministically at the end
-     * of the current frame via `freeTransient()`. Bypasses the WeakMap cache
-     * and the FinalizationRegistry, so transient meshes never wait on GC.
-     */
-    uploadTransient(mesh: Mesh): GLMeshHandle;
-    /**
-     * Upload a Mesh that may or may not recur across frames. Its first sight in
-     * *this* context takes `uploadTransient`; every later one takes the
-     * persistent handle. One transient upload to find out is cheaper than
-     * stranding a persistent VAO on a mesh that never returns, whose release
-     * would wait on GC. The transient upload does not populate the persistent
-     * map, so steady-state reuse begins on the third frame.
-     */
-    uploadRecurring(mesh: Mesh): GLMeshHandle;
-    /**
-     * Free all transient resources allocated since the last call. Called by
-     * the renderer at the end of each `render()`. Safe under context loss.
-     */
-    freeTransient(): void;
-    /** @internal — for tests asserting the transient-list size. */
-    _transientCount(): number;
-    /**
-     * Free GL resources whose Mesh has been GC'd since the last drain.
-     * Called by the renderer at the top of each `render()`, before any draws.
-     */
-    drainPendingDeletes(): void;
-    /**
-     * Free every GL resource this cache holds — persistent, pending and
-     * transient — and ignore finalizers from here on. Idempotent. Unlike the
-     * other paths this does not wait on GC, which is what lets a renderer on a
-     * context it does not own give back everything it uploaded.
-     */
-    dispose(): void;
-    /** @internal — for tests asserting the queue size. */
-    _pendingDeleteCount(): number;
-    /** @internal — for tests that need to simulate the finalizer firing. */
-    _enqueueDeleteForTest(resources: MeshResources): void;
-    private upload;
-}
-
-/**
- * GL texture upload + cache for MSDF font atlases (and future images).
- *
- * Textures are keyed by a string id (the font family name or image id).
- * Pixels are uploaded once per id; a later upload of the same id reuses the
- * texture and only re-applies its wrap mode when that changed.
- * The cache is GL-context-bound; discard and create a new one on context loss.
- *
- * Atlas format: RGBA UNSIGNED_BYTE, linear filtering, no mipmaps.
- * Mipmap generation is deliberately skipped — MSDF works correctly with
- * linear filtering, and mipmap resampling corrupts the multi-channel SDF signal.
- */
-type TexSource$1 = HTMLImageElement | ImageBitmap | ImageData | HTMLCanvasElement;
-/** How a texture samples outside `0..1`. Pattern tiles need `'repeat'`;
- *  everything else clamps. WebGL2 allows `REPEAT` on NPOT textures, so a
- *  tile of any size tiles correctly. */
-type TextureWrap = 'clamp' | 'repeat';
-declare class GLTextureCache {
-    private readonly gl;
-    private readonly map;
-    private readonly wraps;
-    constructor(gl: WebGL2RenderingContext);
-    has(id: string): boolean;
-    /** Uploads the pixels once per id. `wrap` is re-applied whenever it differs
-     *  from what the id was last uploaded under: the same registered image can
-     *  be a clamped shader texture in one draw and a repeating pattern tile in
-     *  the next, and first-upload-wins gave the second one the first one's mode. */
-    upload(id: string, source: TexSource$1, wrap?: TextureWrap): string;
-    private applyWrap;
-    /** Create a single-channel R8 texture from raw bytes (full upload).
-     *  No-op if `id` already exists. Same LINEAR/CLAMP params as `upload`;
-     *  UNPACK_ALIGNMENT dropped to 1 for non-4-aligned row widths. */
-    uploadR8(id: string, width: number, height: number, data: Uint8Array): void;
-    /** Patch a rect of an existing R8 texture with tightly-packed w×h bytes. */
-    subImageR8(id: string, x: number, y: number, w: number, h: number, data: Uint8Array): void;
-    bind(id: string, unit: number): void;
-    /**
-     * Delete every uploaded GL texture and clear the map. Called by
-     * `WeaselRenderer.dispose()`. The cache is unusable but refillable
-     * afterward — a subsequent `upload()` for a previously-seen id re-creates
-     * the texture rather than restoring the deleted one.
-     */
-    free(): void;
-}
-
-/**
- * GL texture upload cache for ImageBitmap objects.
- *
- * Key: ImageBitmap (or pattern source object) identity (WeakMap) — lets GC
- * reclaim unreferenced bitmaps. The GL textures are NOT freed when the source
- * is gc'd; a source's owner that knows it will never be drawn again frees them
- * with {@link releaseImageSource}, and `dispose` frees them all.
- *
- * Wrapping is set once at upload time per the `repetition` parameter:
- *   - undefined / 'no-repeat' → CLAMP_TO_EDGE
- *   - 'repeat'   → REPEAT (both axes)
- *   - 'repeat-x' → REPEAT on S, CLAMP on T
- *   - 'repeat-y' → CLAMP on S, REPEAT on T
- *
- * Convention §2: texels stored straight; shader premultiplies.
- */
-type PatternRepetition = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
-/** MIN_FILTER strategy for uploaded textures. */
-type ImageMinification = 'linear' | 'mipmap';
-type TexSource = ImageBitmap | ImageData | HTMLCanvasElement | HTMLImageElement;
-declare class GLImageCache {
-    private readonly gl;
-    private readonly minification;
-    /** This context's `MAX_TEXTURE_SIZE`. */
-    readonly maxTextureSide: number;
-    private readonly map;
-    /** Every texture `map` holds, so `dispose` can reach them — a WeakMap
-     *  cannot be enumerated. */
-    private readonly textures;
-    /**
-     * MAG_FILTER each texture currently carries, so a redundant write can be
-     * skipped.
-     *
-     * The batch sets this per flush — the same bitmap can be drawn at both
-     * filters in one frame, and the value has to be right at the draw rather than
-     * at upload. Filtering is state on the *texture object*, though, not on the
-     * unit, so re-asserting a value it already has is a write to a live texture
-     * for no reason. On a large sheet that is not free: a consumer's wall samples
-     * a 5652px-square atlas, 122MB resident, and measured `sampling: 'nearest'`
-     * costing up to 8x `'linear'` there — where the linear pass re-asserts the
-     * upload default and the nearest pass changes state on every draw.
-     *
-     * Whether that is the cause is unproven (see `docs/TODO.md`), but the write
-     * was redundant either way.
-     */
-    private readonly magFilters;
-    /** `minification` selects the MIN_FILTER strategy for uploaded textures.
-     *  `'linear'` (default) is the screen path's existing behavior. `'mipmap'`
-     *  generates mipmaps and filters LINEAR_MIPMAP_LINEAR — required for
-     *  quality minification when a large source bitmap is drawn small (the
-     *  headless print/export path); bilinear-only minification undersamples
-     *  and produces moiré. */
-    constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
-    /** Delete `key`'s texture, if it has one. */
-    release(key: object): void;
-    /** Delete every texture this cache uploaded and stop answering
-     *  {@link releaseImageSource} and {@link maxImageTextureSide}. Idempotent. */
-    dispose(): void;
-    /** {@link dispose} without the deletes, for a cache whose context was lost:
-     *  its textures died with it. */
-    abandon(): void;
-    upload(key: object, source: TexSource, repetition?: PatternRepetition): WebGLTexture;
-    bind(key: object, unit: number): void;
-    /** Set `key`'s MAG_FILTER, skipping the call when it already holds that
-     *  value. Its texture must be bound to the active unit — callers pair this
-     *  with `bind`. */
-    setMagFilter(key: object, filter: number): void;
-}
-
-/**
- * CPU gradient-ramp builder + the GL texture every baked ramp lives in.
- *
- * Each unique stop list is baked once into a 256-texel strip and written to its
- * own **row** of one RGBA texture, keyed by `JSON.stringify(stops)`. One
- * texture rather than one per ramp is what lets a gradient take a batch texture
- * slot the way a bitmap or a font atlas does: every gradient in a frame samples
- * the same unit, so a run does not break per gradient. The atlas is
- * GL-context-bound; discard and recreate on context loss.
- *
- * Output convention §2: texels are stored as straight RGBA. The fragment
- * shader applies premultiplication before writing outColor.
- */
-
-/** Bake gradient stops into a 256-entry RGBA lookup strip, which the shader
- *  samples instead of evaluating stops per fragment. `space` is the gradient's
- *  `interpolate` — the ramp is where a non-sRGB blend is paid for, once. */
-declare function buildGradientRamp(stops: GradStop[], space?: ColorSpace): Uint8ClampedArray;
-declare class GradientRampAtlas {
-    private readonly gl;
-    /** Row per stop list, in least-recently-used order: a hit re-inserts, so the
-     *  first entry is the row a full atlas recycles. */
-    private readonly rowByKey;
-    private texture;
-    private rows;
-    /** Mirror of the texture, so growth can respecify it without re-baking every
-     *  ramp it already holds. */
-    private pixels;
-    private totalQueries;
-    private cacheHits;
-    constructor(gl: WebGL2RenderingContext);
-    /** Rows the atlas currently holds — its texture height. */
-    get height(): number;
-    /**
-     * Bake `stops` into a row and return it, reusing the row an identical stop
-     * list already holds.
-     *
-     * **A returned row outlives the frame only while the atlas has room.** Past
-     * `RAMP_ATLAS_MAX_ROWS` an upload recycles the least recently used row, which
-     * rewrites texels a row handed out earlier still names. Nothing that defers
-     * its draw past this call may hold a row across another `upload` without
-     * arranging to be flushed first.
-     */
-    upload(stops: GradStop[], space?: ColorSpace): number;
-    /**
-     * Whether uploading `stops` would move where existing rows sit — by growing
-     * the atlas, which changes every row's `v`, or by recycling one, which
-     * rewrites its texels.
-     *
-     * Anything holding a row past this call asks first and gets itself out of
-     * the way, because neither can be undone once it has happened.
-     */
-    wouldReshape(stops: GradStop[], space?: ColorSpace): boolean;
-    /**
-     * The `v` a row is sampled at — its center.
-     *
-     * The center is load-bearing: the atlas filters LINEAR, so a `v` anywhere
-     * else blends the ramp beside it into this one. At the center the neighbor's
-     * weight is exactly zero.
-     */
-    rowV(row: number): number;
-    bind(unit: number): void;
-    hitRate(): number;
-    resetStats(): void;
-    /**
-     * Delete the atlas texture and forget every row in it. Called by
-     * `WeaselRenderer.dispose()`. The CPU mirror goes with it, so the atlas is
-     * unusable but refillable afterward (stats are left as-is; call
-     * `resetStats()` separately if desired).
-     */
-    free(): void;
-    /** The row the next ramp is written to: a free one, a taller atlas, or the
-     *  least recently used row of a full one. */
-    private claimRow;
-    /** Grow to `rows`, keeping every row at the index it already had — a row
-     *  index is a stable name, and callers hold them. */
-    private resize;
-    private writeRow;
-}
-
-/** Row-major 4×5 color matrix identity. */
-declare const IDENTITY_COLOR_MATRIX: Float32Array<ArrayBuffer>;
-interface GroupFrame {
-    transform?: GlMat3;
-    alpha?: number;
-    /** Row-major 4×5 color matrix (20 floats). Absent leaves the stack unchanged. */
-    colorMatrix?: Float32Array | number[];
-}
-declare class GroupState {
-    private transformStack;
-    private alphaStack;
-    private colorMatrixStack;
-    get transform(): GlMat3;
-    get alpha(): number;
-    get colorMatrix(): Float32Array;
-    push(frame: GroupFrame): void;
-    /**
-     * Push a frame whose children paint into a surface of their own.
-     *
-     * The transform still accumulates — the children draw where they would have
-     * drawn. Alpha and colour do not: they describe how the finished surface
-     * joins the frame, and applying them on the way in as well would fade the
-     * pixels an effect is about to read, then fade them again on the way out.
-     *
-     * Returns the pair the caller must apply at composite time — what `push`
-     * would have left on the stack — so the composition rules live here and not
-     * in the dispatcher.
-     */
-    pushIsolated(frame: GroupFrame): {
-        alpha: number;
-        colorMatrix: Float32Array;
-    };
-    /** Drop every pushed frame, leaving the root. A frame that throws part-way
-     *  down the tree never pops, and the next frame would draw under leftovers. */
-    reset(): void;
-    pop(): void;
-}
-
-/**
- * One full-screen pass over what a group has already drawn.
- *
- * The renderer runs a group's effects in order, each reading the previous
- * one's output through `u_source` and writing a whole new buffer — so an
- * effect is free to read neighbouring pixels, which is the entire point and
- * the one thing `colorMatrix` can never do.
- *
- * `uniforms` are the effect's own; `u_source`, `u_resolution` and `u_texel`
- * come from the renderer and must not be passed here.
- */
-interface Effect {
-    program: ShaderProgramHandle;
-    uniforms?: Record<string, ShaderUniform>;
-}
-/**
- * Register a fragment shader as an effect. Sugar over `registerProgram` with
- * the effect vertex shader, and the reason a consumer never imports the
- * prelude: an effect that registers with the *custom-shader* vertex shader
- * compiles, runs, and samples its source upside down.
- *
- * The fragment shader reads `v_uv` and `u_source`, and may declare
- * `u_resolution` / `u_texel`. See `effectPrelude.ts` for the full contract,
- * including the premultiplied-alpha requirement.
- *
- * @experimental
- */
-declare function registerEffect(id: string, frag: string): ShaderProgramHandle;
-
-/**
- * Solid-fill paint variant (subset of the full `FillStyle` union from
- * `@weasel-js/core`). Kept for back-compat with step-1/2 consumers and
- * because some code reads `fill.color` directly. Through step 4, fills can
- * be any `FillStyle` variant — solid, pattern, or gradient.
- */
-interface SolidPaint {
-    fill?: 'solid';
-    /** Any CSS color string accepted by `parseColor`: hex, `rgb()`/`rgba()`, `hsl()`/`hsla()`, named, or `transparent`. */
-    color: string;
-    opacity?: number;
-}
-/** DrawCommand variants implemented through step 6. */
-type DrawCommand = PathDrawCommand | GroupDrawCommand | TextDrawCommand | ImageDrawCommand | SpritesDrawCommand | ShaderDrawCommand;
-/** Draw a path, filled and/or stroked. The workhorse command: every shape the
- *  kit draws that is not text, an image, or a custom shader is one of these. */
-interface PathDrawCommand {
-    kind: 'path';
-    path: Path;
-    /** Any `FillStyle` variant: solid, pattern, or gradient (linear/radial/conic). */
-    fill?: FillStyle;
-    /** Stroke spec. Only solid `paint` supported through step 4. */
-    stroke?: Stroke;
-    /**
-     * Optional flat RGBA-per-path-anchor color array (length =
-     * `4 × countPathAnchors(path)`, floats in 0..1). The renderer
-     * arc-length-interpolates these per-anchor colors across the
-     * flattened/triangulated mesh between consecutive anchors using the
-     * mesh's `anchorA` / `anchorB` / `anchorT` parameterization.
-     *
-     * **`fill` must also be set when using `vertexColors`.** The renderer
-     * only enters the per-vertex shader path when the command has a fill
-     * (the fill provides the opacity uniform; the vertex colors override
-     * the fill's color). Pass any solid `fill` (e.g. `{ color: '#fff' }`)
-     * as the placeholder; the per-vertex colors win in the shader.
-     */
-    vertexColors?: number[];
-}
-/** Draw a list of commands under a shared transform, opacity, color matrix
- *  and clip. Groups nest, and their effects accumulate down the stack — this
- *  is how a container node's transform reaches its descendants. */
-interface GroupDrawCommand {
-    kind: 'group';
-    transform?: GlMat3;
-    alpha?: number;
-    /**
-     * Optional 4×5 color matrix (row-major, 20 numbers) — `out = M₄ₓ₄ * in + bias`.
-     * Accumulated multiplicatively down the group stack. Defaults to identity.
-     */
-    colorMatrix?: number[];
-    /** Optional clip path. When set, the renderer rasterizes this path into
-     *  the stencil buffer before drawing `children`; the children paint only
-     *  where the clip covers. Nested groups with clips intersect — a child
-     *  cannot escape an ancestor's clip. Max 7 nesting levels; the renderer
-     *  throws if exceeded. */
-    clip?: Path;
-    /**
-     * Full-screen passes run over this group's own pixels, in order, before it
-     * is composited into its parent.
-     *
-     * Unlike every other field here, this does not accumulate down the group
-     * stack — it is a render-target boundary. The children draw into a buffer of
-     * their own, each effect reads the previous one's output, and the result is
-     * composited back under this group's `transform`, `alpha`, `colorMatrix` and
-     * whatever clip encloses it. So a blur here blurs this group and nothing
-     * around it, which is what a CSS `filter` on the canvas cannot do.
-     *
-     * An empty or absent list costs nothing: no buffer is allocated until a
-     * group asks for one.
-     */
-    effects?: readonly Effect[];
-    children: DrawCommand[];
-}
-/**
- * Text draw command. Renders one or more runs at (`x`, `y`) in screen
- * space, optionally word-wrapping at `maxWidth`. The renderer resolves
- * each run's `(fontFamily, fontWeight, fontStyle)` to an MSDF atlas via
- * `resolveFontVariant` and bucket-draws by atlas + color group.
- *
- * `style` carries node-level defaults (`lineHeight`, anti-alias width)
- * that don't belong on individual runs.
- */
-interface TextDrawCommand {
-    kind: 'text';
-    x: number;
-    y: number;
-    runs: ResolvedRun[];
-    /** Wrap width. Absent never wraps. */
-    maxWidth?: number;
-    align?: 'left' | 'center' | 'right';
-    /** Spread each wrapped line across `width` — see `LayoutRunsOpts.justify`.
-     *  `align` then sets only the lines it does not spread. Default `false`. */
-    justify?: boolean;
-    /** Box width `align` resolves within, from `x`. Default `maxWidth`; with
-     *  neither, `x` is the line's left edge, midpoint or right edge. */
-    width?: number;
-    style: TextStyle;
-    /** Box height for vertical alignment. When set with `verticalAlign`,
-     *  the laid-out block shifts within `[y, y+height]`. */
-    height?: number;
-    /** Default 'top' — the legacy top-anchored behavior. */
-    verticalAlign?: TextVerticalAlign;
-}
-/**
- * Image draw command — renders `image` at screen-space rect (x, y, w, h).
- * The image is stretched to fit; no tiling. Use a pattern FillStyle on a path
- * for tiling.
- */
-interface ImageDrawCommand {
-    kind: 'image';
-    image: ImageBitmap;
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    opacity?: number;
-    /** Magnification filter. `'linear'` (default) smooths; `'nearest'` shows
-     *  device pixels as hard squares — required by anything magnifying a
-     *  framebuffer readback, where blur destroys the point of the readback. */
-    sampling?: 'linear' | 'nearest';
-    /** Sub-rectangle of `image` to draw, in bitmap pixels from the top-left.
-     *  Omitted draws the whole bitmap. Not range-checked: a rect past the edge
-     *  samples outside [0..1], which CLAMP_TO_EDGE smears. With
-     *  `sampling: 'linear'` the filter reaches half a texel beyond `source`, so
-     *  atlas frames need a gutter (see `SpriteSheet.spacing`) or `'nearest'`. */
-    source?: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-    /** Mirror the sampled region within the destination rect. The quad does not
-     *  move — a flipped draw covers exactly the pixels an unflipped one does. */
-    flipX?: boolean;
-    flipY?: boolean;
-}
-/** Floats per sprite in `SpritesDrawCommand.sprites`. */
-declare const SPRITE_STRIDE = 9;
-/**
- * Draw many quads sampling one bitmap — an atlas, a sprite sheet, a wall of
- * thumbnails. The same picture as a run of `ImageDrawCommand`s the renderer
- * would coalesce anyway, handed over already packed so it never walks a
- * command object per quad.
- *
- * Reach for it past a few thousand sprites. Below that a plain run of image
- * commands merges into the same single draw and reads better; the packed form
- * exists because at 20,000 the object walk is about half the frame.
- *
- * The sprites are one run: they share a texture, a filter, and whatever group
- * transform, alpha, color matrix and clip are live, exactly as a merged run of
- * image commands would. Anything varying per sprite is in the array.
- */
-interface SpritesDrawCommand {
-    kind: 'sprites';
-    image: ImageBitmap;
-    /** Magnification filter for the whole run, as `ImageDrawCommand.sampling`. */
-    sampling?: 'linear' | 'nearest';
-    /**
-     * `SPRITE_STRIDE` floats per sprite:
-     * `dx, dy, dw, dh, sx, sy, sw, sh, opacity`.
-     *
-     * Destination is in the group's coordinates; source is in bitmap pixels,
-     * like `ImageDrawCommand.source`. A negative `sw` or `sh` mirrors that axis
-     * within the source rect, which is what `flipX` / `flipY` do. A trailing
-     * partial sprite is ignored.
-     */
-    sprites: Float32Array;
-}
-/**
- * Custom shader draw command. The renderer generates a quad over `bounds`
- * and dispatches the consumer's fragment shader with the kit's vertex prelude.
- *
- * `uniforms` keys must match names declared in the consumer's fragment shader.
- * The kit automatically sets `u_bounds`, `u_view`, and `u_proj` — do not
- * declare those in `uniforms`.
- *
- * @experimental API may change before v2.
- */
-interface ShaderDrawCommand {
-    kind: 'shader';
-    program: ShaderProgramHandle;
-    uniforms: Record<string, ShaderUniform>;
-    /** Screen-space bounding rect in CSS pixels. */
-    bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-}
-
-/**
- * Clipping staged geometry to an axis-aligned rect on the CPU, so a rect clip
- * needs no stencil and does not break the run.
- *
- * A stencil clip is GL state, so content inside one cannot share a draw with
- * content outside it, and every clipped group paid a flush on the way in and
- * another on the way out. A rect under a transform that keeps it axis-aligned
- * is the common clip, and for that one the clip can ride the geometry instead:
- * cut each staged polygon to the rect before it joins the run.
- *
- * Exact, not approximate: every attribute a batch vertex carries is affine
- * across the polygon it belongs to, so interpolating along a cut edge gives
- * the value the rasterizer would have produced there, and the cut polygon
- * covers the same pixel centers the stencil would have passed.
- */
-
-/** In the space batch vertices are staged in: after the model transform,
- *  before the projection. */
-interface ClipRect {
-    x0: number;
-    y0: number;
-    x1: number;
-    y1: number;
-}
-
-/**
- * Growable vertex staging for a run of solid-fill geometry, image quads and
- * glyphs.
- *
- * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the
- * uniforms the flush draws under.
- *
- * **One batch for all three, because a page interleaves them.** A grid of
- * thumbnails is a ground rect under an atlas quad under a caption, per cell,
- * and while each kind staged separately every one had to drain the others
- * before it could stage — so a shape that batches perfectly in any one half
- * alone paid a flush per command. Everything a vertex needs to say which it is
- * fits in the same vertex: solids carry the UV of a 1x1 white texel and are
- * their own color, quads carry their atlas UV and a white color, glyphs carry
- * a font atlas UV, their text color, and a paint mode saying the texel is a
- * distance field rather than a color. Gradients join as a fourth off the ramp
- * atlas — a linear one without a mode of its own, since (ramp position, row) is
- * what the plain mode already samples, and a radial or conic one with a mode
- * that says its UV is a gradient-space coordinate to take a `length` or an
- * `atan` of. See `shaders/batchFill.ts`.
- *
- * Colors ride the vertices because shapes in a run differ in color and a merged
- * draw has one set of uniforms — and so does the model transform, applied here
- * rather than uploaded, so shapes under different transforms still share a
- * draw. The texture rides them too, as a slot index into the units the flush
- * binds: slot 0 is the white texel every solid samples, and `draw.ts` hands out
- * the rest per bitmap. A run holds as many bitmaps as there are slots, so an
- * atlas is what makes a wall of one sheet coalesce and a handful of loose
- * bitmaps no longer breaks a run per command.
- */
-
-/**
- * A gradient vertex's `a_uv`, each channel affine in the coordinates the
- * geometry arrives in: `u = ux*x + uy*y + u0`, and the same for `v`.
- *
- * One shape for all three gradients. A linear one's `v` row is the constant
- * atlas row and its `u` row is the ramp position; a radial or conic one's two
- * rows are the gradient-space coordinate, and the row rides `a_post` instead.
- */
-interface GradientUV {
-    ux: number;
-    uy: number;
-    u0: number;
-    vx: number;
-    vy: number;
-    v0: number;
-}
-declare class DrawBatch {
-    private readonly gl;
-    private readonly aPos;
-    private readonly aColor;
-    private readonly aUv;
-    private readonly aPost;
-    private readonly aSlot;
-    /** One ring per tier, cycled per flush. Slots are created on first use, so a
-     *  renderer that flushes rarely allocates as few as it flushes. */
-    private readonly rings;
-    private readonly nextInRing;
-    /** The same, for flushes past the largest tier; these sets grow to fit. */
-    private readonly largeRing;
-    private nextLarge;
-    private verts;
-    private idx;
-    private nVerts;
-    private nIdx;
-    /** Whether the staged run is quads alone, so its indices are the canonical
-     *  pattern and a slot already holding that pattern needs no upload. */
-    private pureRects;
-    /** The rect every push is cut to, or `null`. `draw.ts` sets it as rect
-     *  clips enter and leave — see `batchClip.ts`. A push returns `false`, having
-     *  staged nothing, for geometry it cannot cut exactly; see `clipQuad`. */
-    clip: ClipRect | null;
-    /** Polygon scratch for `clip`: a quad cut by four edges has at most eight
-     *  corners. */
-    private readonly polyIn;
-    private readonly polyOut;
-    private readonly polyTmp;
-    constructor(gl: WebGL2RenderingContext, prog: ShaderProgram);
-    get length(): number;
-    /** Whether staging `vertices` more would put the run past the per-flush cap. */
-    wouldOverflow(vertices: number): boolean;
-    /**
-     * Append one rect's four corners through `m`, all carrying `rgba` (straight
-     * alpha). An affine maps a rect to a parallelogram, so two triangles still
-     * cover it and the batch draws at `u_model` identity.
-     */
-    pushRect(x: number, y: number, w: number, h: number, m: GlMat3, r: number, g: number, b: number, a: number): boolean;
-    /**
-     * Append one image quad: the destination rect `(x, y, w, h)` mapped through
-     * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `post` as the
-     * after-the-color-matrix alpha factor.
-     *
-     * Corners wind top-left, top-right, bottom-right, bottom-left with UVs
-     * following — the same winding `pushRect` uses, which is what lets a run of
-     * mixed rects and quads keep the canonical index pattern. The flips a command
-     * asks for are already in the `u` / `v` the caller passes.
-     *
-     * `slot` is the texture unit the corners sample, which `draw.ts` assigns per
-     * bitmap within the run.
-     */
-    pushQuad(x: number, y: number, w: number, h: number, m: GlMat3, u0: number, v0: number, u1: number, v1: number, post: number, slot: number): boolean;
-    /**
-     * Append one glyph quad: the box `(x0, y0)`-`(x1, y1)` mapped through `m`,
-     * sampling `(u0, v0)`-`(u1, v1)` of the font atlas at `slot`, painted in
-     * `rgba`.
-     *
-     * `mode` says which channels of that atlas carry the distance field, and
-     * rides the vertices packed into the slot — so a run off a baked MSDF atlas
-     * and one off the runtime canvas bake still share a draw. The synthetic-bold
-     * threshold does not: it is `u_synthBold`, and `draw.ts` breaks the run when
-     * it changes.
-     *
-     * **A synthetic oblique is sheared here rather than in the shader.** The old
-     * text program carried the baseline per vertex and skewed against
-     * `u_synthItalic`; the batch places its own corners, so the shear is one
-     * multiply while they are being placed, and `tanItalic` is 0 for an upright
-     * face. It has to happen before `m`, which is where the shader had it too.
-     *
-     * Corners wind top-left, top-right, bottom-right, bottom-left — `pushQuad`'s
-     * winding, which is what lets a run of mixed rects, image quads and glyphs
-     * keep the canonical index pattern.
-     */
-    pushGlyph(x0: number, y0: number, x1: number, y1: number, baselineY: number, tanItalic: number, m: GlMat3, u0: number, v0: number, u1: number, v1: number, r: number, g: number, b: number, a: number, slot: number, mode: number): boolean;
-    /**
-     * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped
-     * through `m`, sampling the ramp atlas at `slot`.
-     *
-     * `uv` gives each channel of `a_uv` as an affine function of the coordinates
-     * the corners arrive in, which is what lets a gradient ride the vertices at
-     * all: a linear one's ramp position is affine in position outright, and a
-     * radial or conic one's gradient-space *coordinate* is, even though the ramp
-     * position it yields is not. Either way the rasterizer's interpolation across
-     * a triangle is exact. `mode` says which of the two the fragment shader is
-     * looking at, and `post` carries the atlas row for the modes that read it —
-     * see `shaders/batchFill.ts`.
-     *
-     * Values outside 0..1 are the sampler's business; the atlas clamps to the
-     * edge texel, which is what the gradient shader's own `clamp` did.
-     */
-    pushGradientRect(x: number, y: number, w: number, h: number, m: GlMat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): boolean;
-    /** `pushMesh` for a mesh filled by a gradient — see `pushGradientRect` for
-     *  what `uv`, `post` and `mode` carry. */
-    pushGradientMesh(mesh: Mesh, m: GlMat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): boolean;
-    /**
-     * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The
-     * mesh's own indices are rebased onto the staged vertices, which is why the
-     * index buffer is uploaded per flush rather than written once.
-     */
-    pushMesh(mesh: Mesh, m: GlMat3, r: number, g: number, b: number, a: number): boolean;
-    /** Upload the staged geometry into the next set of buffers and bind its VAO.
-     *  Returns the index count for the caller's `drawElements`. */
-    uploadAndBind(): number;
-    reset(): void;
-    dispose(): void;
-    private writeVertex;
-    /**
-     * Fit the quad just written at `v0` to `rect`: keep it if it lies inside,
-     * drop it if it misses, and cut it if it crosses — but only if its edges
-     * run along the axes. Cutting a slanted edge moves its endpoint off the
-     * subpixel grid the rasterizer snaps to, and the shortened edge then covers
-     * different samples than the whole one did; along an axis the cut edge is
-     * the same line exactly. So a slanted quad that crosses is rolled back and
-     * refused, for `draw.ts` to clip through the stencil instead.
-     *
-     * A cut axis-aligned quad is still four corners, so the run stays pure.
-     */
-    private clipQuad;
-    /** `clipQuad` for a mesh staged from `v0`. A mesh's edges are slanted in
-     *  general, so one that crosses is refused rather than cut. */
-    private clipMesh;
-    /** Append the `n`-corner convex polygon in `poly` as a triangle fan. */
-    private appendFan;
-    /** Two triangles over the four corners just written. */
-    private pushQuadIndices;
-    /** Grow the CPU arrays so `vertices` / `indices` more fit. */
-    private reserve;
-    private nextRingSlot;
-    private nextLargeSlot;
-    private createSet;
-    private deleteSet;
-}
-
-/** How to construct a `WeaselRenderer`: the GL context or canvas to draw
- *  into, the output size, and the quality knobs that separate screen
- *  rendering from print. */
-/** A run of top-level commands, `[start, end)` by index, that
- *  {@link WeaselRenderer.lastFrameStats} accounts for separately — one render
- *  layer's commands, say. Spans are in order and do not overlap. */
-interface RenderSpan {
-    id: string;
-    start: number;
-    end: number;
-}
-/** Per-frame options for {@link WeaselRenderer.render}. */
-interface RenderOptions {
-    spans?: readonly RenderSpan[];
-}
-/** What one span cost. A batched run is drawn when something closes it, so
- *  its draw call counts toward the span that closed it. */
-interface RenderSpanStats {
-    id: string;
-    drawCalls: number;
-    ms: number;
-}
-/** What one `render()` cost. See {@link WeaselRenderer.lastFrameStats}. */
-interface RenderStats {
-    drawCalls: number;
-    ms: number;
-    spans: RenderSpanStats[];
-}
-/** Construction options for {@link WeaselRenderer}. Pass `gl` or `canvas`;
- *  a context passed in must have a stencil buffer. */
-interface WeaselRendererOptions {
-    /** A WebGL2 context to draw with. Wins over `canvas`. */
-    gl?: WebGL2RenderingContext;
-    /** A canvas to open a stencil-backed WebGL2 context on, when `gl` is absent. */
-    canvas?: HTMLCanvasElement;
-    /** Drawing size in CSS pixels. */
-    width: number;
-    /** Drawing size in CSS pixels. */
-    height: number;
-    /** Device pixels per CSS pixel. */
-    dpr: number;
-    /** MIN_FILTER strategy for image/pattern textures (`GLImageCache`).
-     *  Default `'linear'` — the existing screen behavior. The headless
-     *  `renderSceneToPixels` path passes `'mipmap'` for print-quality
-     *  minification. Explicitly passing `'linear'` is always valid. */
-    imageMinification?: ImageMinification;
-    /** Flatness tolerance for curve tessellation, in WORLD units (see
-     *  `TessellateOptions.flattenTolerance`). When set, path fills are
-     *  tessellated fresh at this tolerance per frame (transient pool) instead
-     *  of served from the Path-identity mesh cache — the cache key does not
-     *  include tolerance. Default: unset — the existing cached behavior at
-     *  `DEFAULT_FLATTEN_TOLERANCE`. The headless path derives this from the
-     *  requested output scale; screen callers normally leave it unset. */
-    flattenTolerance?: number;
-    /** Per-render synchronous bake budget for dynamic canvas-SDF glyphs.
-     *  Default DEFAULT_BAKE_BUDGET (16). The headless renderSceneToPixels
-     *  path passes Infinity so print never defers a glyph. */
-    bakeBudget?: number;
-    /** On-screen glyph size, in CSS pixels, at or above which text renders from
-     *  tessellated font outlines instead of a distance field — see
-     *  `OUTLINE_MIN_SCREEN_PX`. Only faces registered with
-     *  `registerFontOutlines` are affected; everything else keeps its SDF tier
-     *  whatever this says. Pass `Infinity` to disable the tier outright, or 0
-     *  to use outlines wherever they exist (what the headless path does, since
-     *  print has no reason to sample a field it could evaluate exactly). */
-    textOutlineMinScreenSize?: number;
-}
-/** Where a renderer draws inside a buffer it does not own.
- *
- *  The rect's SIZE is the renderer's own `width`/`height` — `resize()` owns
- *  that, and a second copy here could disagree with the one `DrawContext`
- *  reports to screen-space layers. */
-interface RenderTarget {
-    /** Top-left of this renderer's output within the drawing buffer, in CSS
-     *  pixels, with the origin at the buffer's top-left. GL's bottom-left origin
-     *  is handled internally. */
-    origin: {
-        x: number;
-        y: number;
-    };
-    /** Clear colour and stencil within the rect before drawing. Default true.
-     *  Pass false only when the caller clears the whole buffer itself on behalf
-     *  of every co-tenant — a frame that clears neither inherits its neighbour's
-     *  stencil bits, and even-odd fills then fill their holes. */
-    clear?: boolean;
-}
-/**
- * The WebGL2 renderer: takes a list of draw commands and paints them.
- *
- * It knows nothing about the scene — commands are the whole interface, which
- * is what lets layers, HUD widgets and overlays all draw through the same
- * pipeline. GPU resources (meshes, textures, gradient ramps) are cached across
- * frames and keyed by identity, so re-issuing the same command is cheap.
- */
-declare class WeaselRenderer {
-    private readonly gl;
-    private stats;
-    private pathFill;
-    private pathFillVColor;
-    private imageFill;
-    private batchFill;
-    private gradFill;
-    private patternFill;
-    /** Compiled on first use: only atlas text under a texture paint needs one. */
-    private glyphPaintPrograms;
-    private meshCache;
-    private textureCache;
-    private imageCache;
-    private gradRamps;
-    private programRegistry;
-    /** The source each compiled custom program was built from — or, after a
-     *  failed recompile, the source that failed, so it is not retried every frame. */
-    private programSources;
-    private quadVbo;
-    private quadIbo;
-    private drawBatch;
-    /** 1x1 white, so a batch flush sampling no image still samples something —
-     *  see `shaders/batchFill.ts`. */
-    private whiteTexture;
-    private readonly groupState;
-    private widthCss;
-    private heightCss;
-    private dpr;
-    private canvas;
-    private target;
-    /** Offscreen buffers for group effects. Allocates nothing until a group
-     *  with effects asks, so a canvas without them pays no memory. */
-    private readonly effectTargets;
-    private readonly paintScratch;
-    private readonly imageMinification;
-    private flattenTolerance?;
-    private readonly bakeBudget;
-    private readonly textOutlineMinScreenSize;
-    private contextLost;
-    private boundOnLost;
-    private boundOnRestored;
-    /** True after `dispose()`. A disposed renderer ignores further `render()`
-     *  calls and `registerProgram()` calls. */
-    private disposed;
-    /** What registered paint kinds hang their GPU state on. One per context
-     *  generation: a restore releases it and opens the next. */
-    private paintResources;
-    constructor(opts: WeaselRendererOptions);
-    private uploadQuadGeometry;
-    /**
-     * Compile a consumer-registered shader program against this renderer's GL context.
-     *
-     * Call once per renderer after the module-level `registerProgram()`.
-     * Throws `ShaderCompileError` if compilation fails.
-     *
-     * In dev mode, calling again with the same handle replaces the compiled program.
-     *
-     * @experimental
-     */
-    registerProgram(handle: ShaderProgramHandle): void;
-    private installProgram;
-    /** Recompile every program whose module-level source was re-registered
-     *  since it was compiled. A source that fails keeps the old program drawing. */
-    private refreshPrograms;
-    /**
-     * The compiled program for `id`, compiling it against this context on first
-     * use. Unlike {@link registerProgram} this neither throws on a missing
-     * source nor on a compile failure: a paint kind asking for a program it
-     * never registered must decline the paint, not take down the frame.
-     */
-    private ensureProgram;
-    private glyphPaintProgram;
-    /** The GL state every frame assumes. Applied per `render()` rather than once
-     *  at construction because a co-tenant sharing this context moves all of it
-     *  between our frames. */
-    private applyGlState;
-    /** Viewport and scissor for this frame. Re-applied inside `render()` because
-     *  a co-tenant on the same context moves both between our frames. */
-    private applyTarget;
-    /** Confine this renderer to a rect of its drawing buffer, or pass null to
-     *  give it the whole buffer back. Takes effect from the next `render()`. */
-    setTarget(target: RenderTarget | null): void;
-    getTarget(): RenderTarget | null;
-    isContextLost(): boolean;
-    private onContextLost;
-    private onContextRestored;
-    /** Free every GL resource this renderer created and detach context-loss
-     *  listeners when a canvas was supplied. Idempotent.
-     *
-     *  That covers the built-in and consumer-registered programs (their shaders
-     *  go with them), the shared quad geometry, the batch, the effect targets,
-     *  and every cache: atlas and gradient-ramp textures, bitmap and pattern
-     *  textures, and meshes — transient, persistent, and those whose Path was
-     *  already collected. The context itself is left alone, so a caller-owned
-     *  context can host renderer after renderer without accumulating anything.
-     *
-     *  A disposed renderer ignores further `render()` and `registerProgram()`
-     *  calls. */
-    dispose(): void;
-    /**
-     * Draw one frame.
-     *
-     * `viewMatrix` is the frame's world→screen transform. It is only consulted
-     * by `units: 'world'` gradients, which fall back to screen space without
-     * it — every other command carries its own transform in the stream, so
-     * callers with no view concept can keep calling `render(commands)`.
-     */
-    render(commands: DrawCommand[], viewMatrix?: GlMat3, opts?: RenderOptions): void;
-    /** What the last `render()` cost: GL draw calls issued and CPU milliseconds
-     *  spent issuing them, in total and per requested span. GPU time is not
-     *  measured; the GPU runs asynchronously. */
-    lastFrameStats(): RenderStats;
-    /** Change the curve-flattening tolerance after construction. `undefined`
-     *  restores the cached `DEFAULT_FLATTEN_TOLERANCE` route. */
-    setFlattenTolerance(tolerance: number | undefined): void;
-    resize(dims: {
-        width: number;
-        height: number;
-        dpr: number;
-    }): void;
-    /** @internal */ _gl(): WebGL2RenderingContext;
-    /** @internal */ _pathFill(): ShaderProgram;
-    /** @internal */ _pathFillVColor(): ShaderProgram;
-    /** @internal */ _drawBatch(): DrawBatch;
-    /** @internal */ _imageFill(): ShaderProgram;
-    /** @internal */ _batchFill(): ShaderProgram;
-    /** @internal */ _gradFill(): ShaderProgram;
-    /** @internal */ _patternFill(): ShaderProgram;
-    /** @internal */ _meshCache(): GLMeshCache;
-    /** @internal */ _textureCache(): GLTextureCache;
-    /** @internal */ _imageCache(): GLImageCache;
-    /** @internal */ _gradRamps(): GradientRampAtlas;
-    /** @internal */ _groupState(): GroupState;
-    /** @internal */ _widthCss(): number;
-    /** @internal */ _heightCss(): number;
-    /** @internal */ _dpr(): number;
-}
-
-/**
- * Uniform-grid sprite sheet layout — frame index to the source rect an
- * `ImageDrawCommand` samples. Pure arithmetic over the grid description; it
- * never touches the bitmap.
- */
-/** A sprite sheet's grid. `margin` and `spacing` follow the Tiled / Aseprite
- *  tileset convention, so a sheet exported from either describes itself here. */
-interface SpriteSheet {
-    frameWidth: number;
-    frameHeight: number;
-    columns: number;
-    /** Empty pixels around the whole grid. Default 0. */
-    margin?: number;
-    /** Empty pixels between adjacent cells — the gutter that keeps linear
-     *  sampling off the neighboring frame. Default 0. */
-    spacing?: number;
-}
-/**
- * Row-major source rect for frame `index`, counting from 0 at the top-left.
- *
- * `index` is not range-checked and does not wrap: past the last cell this
- * returns a rect below the sheet, which draws as an edge smear. Wrapping is
- * the animation's business (`frameRect(sheet, tick % count)`) — a sheet does
- * not know how many of its cells are filled.
- */
-declare function frameRect(sheet: SpriteSheet, index: number): {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-};
-
-/**
- * View → GlMat3 helper for layer `draw` implementations on world-space layers.
- *
- * `View` is `@weasel-js/routing`'s, the one every viewport action is typed
- * in. A type-only import emits no runtime edge, so there is no reason for the
- * renderer to hold a second structurally-identical declaration and put it in
- * the emitted `.d.ts` anonymously.
- */
-
-/**
- * Build the world→screen transform matrix for a `View`.
- * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap
- * world-space content emitted from a layer `draw` implementation.
- *
- * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.
- *
- * Column-major layout (matches `mat3.identity()`):
- * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.
- */
-declare function viewToMat3(view: View): GlMat3;
-
-/** A screen-space rectangle, CSS pixels. */
-interface CullRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * `cmds` without the commands that cannot put a pixel inside `rect`, where
- * `transform` maps the commands' space to screen space — `viewToMat3(view)`
- * for a world-space layer.
- *
- * Conservative by construction: a command is dropped only when a bound that
- * encloses everything it can paint misses `rect`. Paths are bounded by their
- * control hull plus the farthest a stroke can reach (miter spikes and square
- * caps included), images and sprites by their quads, and every bound is taken
- * through the accumulated transform as the AABB of its corners, so rotation
- * only enlarges it. Text and shader commands are always kept, and so is a
- * group with `effects` — an effect may move pixels. Clips are ignored, which
- * can only keep more. A group whose children all go is dropped.
- *
- * Returns `cmds` itself when nothing was dropped.
- */
-declare function cullDrawCommands(cmds: DrawCommand[], transform: GlMat3, rect: CullRect): DrawCommand[];
-
-/**
- * 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. */
-    readonly selection: readonly NodeId[];
-    /** True when the canvas is in multi-mode AND >= 2 ids are selected. */
-    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): Bounds | 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: Bounds | 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;
-}
-
-/**
- * @experimental
- * A single interactive piece of chrome. Pure functions; the kit composes
- * multiple affordances into a single RenderLayer per tool via
- * `composeAffordanceLayer`.
- *
- * Affordances declare interactive regions in a target's *local* frame.
- * The framework (`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;
-    /** Enumerate this affordance's interactive regions. Each region lives in
-     *  some target id's local frame (or in the world frame when `targetId`
-     *  is `null`). Returning `[]` means "no chrome for this state" (no
-     *  selection, multi-mode disabled, etc.). */
-    regions(state: ChromeState): readonly AffordanceRegion[];
-    /** Optional non-interactive decoration (e.g., a leader line drawn from
-     *  a bounds edge to a handle — visual only, not draggable). Receives
-     *  raw state + view because the decoration may live outside any single
-     *  target's local frame. Most affordances leave this undefined. */
-    decorate?(state: ChromeState, view: View): DrawCommand[];
-}
-/**
- * @experimental
- * 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;
-    /** Target id whose `state.boundsOf(targetId)` defines this region's
-     *  local frame. `bounds.rotation` (if present) is the only transform
-     *  applied — translation is the AABB origin; scale is identity. 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. Used for
-     *    invisible zones that sit *around* the AABB (e.g. rotate-on-
-     *    hover band). The outer ellipse is defined by world-space
-     *    semi-axes `rx` / `ry` around `(cx, cy)`; the inner rect is the
-     *    same target-local rect that defines the AABB. Hit-test:
-     *    inside outer ellipse AND outside inner rect. */
-    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;
-    } | {
-        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.
-         *
-         *  This exists because the clamp has to know the view and the
-         *  affordance doesn't: `ChromeState` carries no scale. Expressing the
-         *  floor in world units instead (which is what the rotate ring used
-         *  to do) makes the band shrink on screen as you zoom in, until the
-         *  ring around a small shape is too thin to hover. */
-        minBandPx?: 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). Uses even-odd fill rule to punch the inner-rect
-     *    cutout.
-     *  - `custom` — emit arbitrary draw commands; receives a {@link CustomPaintContext}. */
-    paint?: {
-        kind: 'square';
-        sizePx: number;
-        fill?: FillStyle;
-        stroke?: Stroke;
-    } | {
-        kind: 'annulus';
-        fill?: FillStyle;
-        stroke?: Stroke;
-        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. Read by the hover-cursor
-     *  pump in `useGestureDispatcher` via `AffordanceHit.cursor`, which
-     *  `buildAffordanceAt` fills in from the region the walk landed on. */
-    cursor?: 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. Lazily called so
-     *  affordances don't pay binding-construction cost on every paint frame —
-     *  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.
- *  Provides both the world-space anchor (already transformed) and the
- *  original local shape, for affordances that want to do additional
- *  geometry themselves. */
-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;
-}
-/**
- * @experimental
- * Result of an affordance hit — what the region computed about itself.
- *
- * `initialScratch` is the payload: what the region already knows (which
- * corner, which target id) so the action that picks up the drag doesn't
- * re-derive it. `<SceneCanvas>` reads it out of the layer hit-test and packs
- * it into `AffordanceHit`, which flows to the matching action through
- * `InvocationCtx.drag.affordance`.
- *
- * This used to also carry a `drag: DragChannel` naming the handlers the
- * tool-routing dispatcher should wire up. Every implementation supplied a
- * no-op stub that claimed, because the real routing had already moved to
- * bindings; the field went with that dispatcher.
- */
-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 — whatever the affordance wants to hand the
- * action that picks up the drag. These few names are the exception: they mean
- * the same thing to every affordance, and the actions that consume them
- * (`resizeAction`, `rotateAction`) read them off `AffordanceHit` rather than
- * out of scratch. An affordance that doesn't set them simply 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. Extends `AffordanceBinding`
- * so existing implementations keep typechecking; 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'` — today's behavior. Same name and
-     *  meaning as `AffordanceHit.strength`, which it becomes. */
-    strength?: 'exclusive' | 'shared';
-    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
-    claimedKinds?: readonly ClaimableGesture[];
-}
-
-/**
- * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
- * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend
- * supplies it explicitly 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 `draw` runs on the frame loop, so a throw that escapes it surfaces as an
- * uncaught `requestAnimationFrame` error on the window and takes the whole
- * frame with it — every other layer included. One broken layer painting
- * nothing, named in the console, is the lesser wrong.
- */
-interface LayerDrawFailure {
-    layerId: string;
-    error: unknown;
-}
-/**
- * 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)`, and it costs a buffer and a pass chain per layer. 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, because anything drawn between
- * two members has to land between them. A group whose members are separated in
- * the render order is drawn as one bracket per run, with a warning: the
- * picture is right, the declaration almost certainly is not.
- *
- * This is a render-stack bracket, not a scene `ContainerNode` — it holds no
- * ids, survives no reload, and nothing in the scene knows about it.
- */
-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 same set `before`/`after: 'scene'` anchors against. The
-     * separator is required: `'scene'` does not reach `scenery`. A name matching
-     * no layer being drawn is warned about rather than ignored.
-     */
-    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; an array is
-     * read once per frame either way.
-     */
-    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[];
-}
-/** 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[];
-}>;
-/**
- * A single named render sub-layer within a canvas renderer.
- *
- * @template TData - The data object passed to each draw call.
- */
-/** 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. Every layer
- *  that draws other layers declares this, so wrapping never silences what
- *  repaints a source. */
-declare function subscribeToSources(sources: readonly {
-    subscribe?: RedrawSource['subscribe'];
-}[] | (() => readonly {
-    subscribe?: RedrawSource['subscribe'];
-}[])): RedrawSource['subscribe'];
-/** 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. */
-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 for the GL backend to dispatch.
-     *
-     * For world-space layers (the default), emit commands in WORLD COORDS —
-     * `drawLayers` automatically wraps them in `{ kind: 'group', transform:
-     * viewToMat3(view), ... }` before handing them to the renderer. Do NOT
-     * apply the view transform yourself.
-     *
-     * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel
-     * coords directly; `drawLayers` passes them through unchanged. If part
-     * of a screen-space layer's output needs to track the view, wrap that
-     * subset manually with `viewToMat3(view)`.
-     */
-    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.
-     * Useful for layers that must never be hidden (e.g. base grid).
-     */
-    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, so a layer reading a mode
-     * registry needs no consumer code to follow a mode switch.
-     */
-    subscribe?: RedrawSource['subscribe'];
-    /**
-     * Full-screen passes run over this layer's own pixels before it joins the
-     * frame — a blur here blurs the world and leaves the HUD drawn above it
-     * sharp, which is the thing a CSS `filter` on the `<canvas>` cannot do.
-     *
-     * Costs nothing while empty: the renderer allocates no offscreen buffer
-     * until a layer actually declares one. See `GroupDrawCommand.effects` for
-     * what a pass may read, and {@link LayerGroup} to run one chain over
-     * several layers at once instead of one chain each.
-     */
-    effects?: readonly Effect[];
-    /**
-     * Optional hit-test for **consumer-attached** layers.
-     *
-     * Only layers registered through `CanvasExtensionApi.registerLayer` are
-     * hit-tested: `hitTestExtras` walks them last-registered-first on
-     * pointerdown, and `<SceneCanvas>` folds the result into its `affordanceAt`
-     * thunk 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. (The kit's own chrome doesn't need it: it
-     * goes through `buildAffordanceAt`.)
-     *
-     * Coordinates are world-space. The `data` arg is the layer's
-     * configured data slot (same as `draw`); `view` and `dims` mirror
-     * `draw`'s arguments.
-     */
-    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.
-     * Lets layers (e.g. HUD widgets) track hover state without participating
-     * in the drag pipeline. Coords are world-space; the layer is responsible
-     * for any further conversion (e.g. world→screen for screen-space layers)
-     * and for its own throttling.
-     */
-    onUncapturedMove?: (worldX: number, worldY: number, evt: PointerEvent, view: View, dims: Dims) => void;
-    /**
-     * Called when the cursor leaves the canvas element. Lets layers clear
-     * any hover state they're holding.
-     */
-    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)`.
- *
- * Visibility resolution order:
- *   1. `alwaysOn` — always drawn, ignores visibility map.
- *   2. Explicit entry in `visibility` map — overrides default.
- *   3. `layer.defaultVisible` — falls back to `true` when absent.
- *
- * Transform composition: world-space layers (the default; `space` unset or
- * `'world'`) have their commands wrapped in a `kind: 'group'` with
- * `viewToMat3(view)` before they reach the renderer. Screen-space layers
- * (`space: 'screen'`) pass through unchanged.
- *
- * 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`. A layer named by no group is emitted exactly as it was before
- * groups existed, and a frame that declares none allocates nothing.
- *
- * `spans`, when passed, receives one {@link LayerDrawSpan} per layer drawn.
- */
-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[]): 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 — both gates, in the order
- * `drawLayers` applies them.
- *
- * **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`: a layer that is not painted
- * but still claims pointer events is a pointer landing on nothing the user
- * can see.
- */
-declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>, order: string[] | undefined): boolean;
-/**
- * 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 — the canvas itself, a viewport
- * node's inner pass — goes through here. A second copy of this rule that
- * forgets the wrap draws world content at raw world coords, which looks
- * plausible at the identity view and wrong everywhere else.
- *
- * 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 rather than a stale tree served under fresh deps.
- */
-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;
-
-/** 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;
-};
-
-/** Which of a node's two per-anchor color arrays an override applies to. */
-type VertexColorChannel = 'fill' | 'stroke';
-/** Function-form override: receives the consumer-supplied base color
- *  array and the current animation timestamp (ms, from the animator's
- *  clock). Returns a flat RGBA float array (values in 0..1, matching
- *  the renderer's `stroke.vertexColors` / `PathDrawCommand.vertexColors`
- *  color space) of the same length as `base`. */
-type ColorOverrideFn = (base: readonly number[], tMs: number) => number[];
-/** Either a static per-anchor RGBA float array (0..1) or a function-form
- *  override (see {@link ColorOverrideFn}). */
-type ColorOverride = readonly number[] | ColorOverrideFn;
-/** Per-node, per-channel store of color overrides. Attached to `useAnimator` as
- *  `animator.colorOverrides`; painted onto scene nodes by `<SceneCanvas animator>`
- *  and onto a `createPathLayer`'s nodes by its `colorOverrides` option. */
-declare class ColorOverrideRegistry {
-    private readonly map;
-    private _version;
-    set(id: string, channel: VertexColorChannel, override: ColorOverride): void;
-    clear(id: string, channel: VertexColorChannel): void;
-    clearAll(): void;
-    get(id: string, channel: VertexColorChannel): ColorOverride | undefined;
-    /** Whether anything overrides `id`, on either channel. */
-    has(id: string): boolean;
-    /**
-     * The colors to paint on `id`'s `channel`, given the colors the painter would
-     * otherwise paint and the frame's timestamp. A function override needs that
-     * `base` and must return an array of its length; failing either, `base`
-     * stands.
-     */
-    resolve(id: string, channel: VertexColorChannel, base: readonly number[] | undefined, tMs: number): readonly number[] | undefined;
-    version(): number;
-}
-
-/** One keyframe. `easing` shapes the approach INTO this key from the previous
- *  one, so the first key's easing is never consulted. */
-interface Keyframe<T> {
-    /** Time within the track's timeline, in ms. */
-    t: number;
-    value: T;
-    /** A function, the name of a built-in, or cubic-bezier control points. */
-    easing?: EasingSpec;
-}
-/** A track sampled as a pure function of the playhead. Scrubbing one is free
- *  and order-independent. */
-interface SampledTrack<T> {
-    kind: 'sampled';
-    label?: string;
-    /** Sorted ascending by `t`. Of keys sharing a time, the last in the array is
-     *  the value at exactly that time. */
-    keys: Keyframe<T>[];
-    /** Required unless every key's value is a number, a number array or a plain
-     *  object of numbers, all of one shape; those are lerped field by field. */
-    interpolate?: Interpolate<T>;
-    /** Built once per segment and cached. Takes precedence over `interpolate`. */
-    interpolator?: InterpolatorFactory<T>;
-    onTick: (value: T) => void;
-}
-/** A clock that events are booked against, reading in ms. An `AudioEngine`
- *  from `@weasel-js/audio` is one. */
-interface TimelineClock {
-    now(): number;
-}
-/** What `book` hands back so the booking can be retracted. A `VoiceHandle` from
- *  `@weasel-js/audio` is one. */
-interface EventBookingHandle {
-    stop(): void;
-}
-/** One entry on an `EventTrack`. Give it `fire`, `book`, or both. */
-interface TimelineEvent {
-    /** Time within the track's timeline, in ms. */
-    t: number;
-    /** Runs on the frame that crosses the edge, told how far behind the frame it
-     *  was crossed, in ms — never negative, and measured against `duration` on
-     *  the loop seam, where the outgoing lap's tail fires after the wrap. */
-    fire?: (lateBy: number) => void;
-    /** Runs up to `booking.lookahead` before the edge on a timeline with a
-     *  `booking`, once per crossing, with the `booking.clock` time the edge lands
-     *  at — never earlier than that clock's `now()`. A returned handle is stopped
-     *  if a pause, seek, rate change, loop change, edit or cancel invalidates the
-     *  booking before the clock reaches `when`; the event is then booked again
-     *  wherever playback next reaches it. A booking with no handle stands. */
-    book?: (when: number) => EventBookingHandle | void;
-}
-/** A track of edge crossings, in forward playback only — a `seek` neither
- *  fires nor books the span it skips. */
-interface EventTrack {
-    kind: 'event';
-    label?: string;
-    /** Sorted ascending by `t`. */
-    events: TimelineEvent[];
-}
-/** How a timeline books its events against an outside clock. */
-interface EventBooking {
-    clock: TimelineClock;
-    /** How far ahead of the playhead to book, in clock ms. Default 100. An event
-     *  first reached later than this — after a frame longer than it — books late. */
-    lookahead?: number;
-    /** An event first reached more than this many clock ms after its edge is
-     *  skipped instead of booked late. Default `Infinity`. */
-    maxLate?: number;
-}
-/** A nested timeline, evaluated at `playhead - at`. Children are NOT registered
- *  with the animator separately; the parent evaluates them. */
-interface TimelineTrack {
-    kind: 'timeline';
-    label?: string;
-    at: number;
-    timeline: NestedTimeline;
-}
-/** Any track a timeline can hold. */
-type Track = SampledTrack<any> | EventTrack | TimelineTrack;
-/** What a child timeline may declare. The parent owns playback, so `loop`,
- *  `autoplay`, `onDone` and `cancelKey` have no meaning below the root. */
-interface NestedTimeline {
-    tracks: Track[];
-    /** Defaults to the largest end time across `tracks`. */
-    duration?: number;
-}
-/** What `animator.timeline` takes: a root timeline, which owns playback. */
-interface TimelineOptions extends NestedTimeline {
-    /** `true` loops forever, `n` loops n additional times. Default false. */
-    loop?: boolean | number;
-    /** Default true. When false the timeline registers but holds at t=0 until resumed. */
-    autoplay?: boolean;
-    /** Called when playback reaches the end of its last lap. */
-    onDone?: () => void;
-    /** Any new animation passed the same `cancelKey` cancels this one. */
-    cancelKey?: string;
-    /** Names this timeline in `animator.watch` events and `animator.live()`. */
-    label?: string;
-    /** Books each event's `book` against a clock the timeline does not own, so a
-     *  consumer on that clock lands it at its true sub-frame time. The frame
-     *  clock's mapping onto it is smoothed each frame and resynced on a jump. */
-    booking?: EventBooking;
-}
-/** What `animator.timeline` returns: playback control plus live editing. */
-interface TimelineHandle extends AnimationHandle {
-    /** Move the playhead. Never fires event tracks, at any depth. */
-    seek(t: number): void;
-    /** Change the loop policy. `true` loops forever, `n` allows n more laps,
-     *  `false` stops at `duration`. Sets policy only — a timeline already parked
-     *  at `duration` does not restart, because `rearm` declines to revive one.
-     *  Rewind it with `seek(0)` and `resume()` to play it again. */
-    setLoop(loop: boolean | number): void;
-    /** The loop policy as it now stands: `true` endless, `false` stopping at
-     *  `duration`, `n` for n laps still allowed. A finite count falls as laps
-     *  are consumed, matching what `setLoop` takes. */
-    loop(): boolean | number;
-    /** Current playhead in ms. */
-    time(): number;
-    duration(): number;
-    tracks(): readonly Track[];
-    /** Run `fn`, then recompute duration, drop cached interpolators, and notify.
-     *  Every mutation must go through this — an edited keyframe otherwise keeps
-     *  interpolating toward its old value with no visible error. */
-    edit(fn: () => void): void;
-    /** Notified after each `edit`. Returns an unsubscribe. */
-    subscribe(cb: () => void): () => void;
-}
-
-/** Blends two `T` values at eased progress `t`. Called once per frame; see
- *  {@link InterpolatorFactory} when the blend has setup worth hoisting. */
-type Interpolate<T> = (from: T, to: T, t: number) => T;
-/** Factory interpolator: built ONCE at tween start with (from, to), the returned
- *  function is called with `t ∈ [0, 1]` each frame. Use for interpolators with
- *  expensive setup (color-space conversion, path-string parsing) — d3-interpolate's
- *  shape exactly. For cheap interpolations the per-tick `Interpolate<T>` form is
- *  fine; this is the escape hatch when setup-per-tick is wasteful. */
-type InterpolatorFactory<T> = (from: T, to: T) => (t: number) => T;
-/** A running animation. Cancel it, or bend its time — pausing and time-scaling
- *  act on this animation's own virtual clock, independent of the animator's. */
-interface AnimationHandle {
-    /** Monotonic id assigned by the animator. */
-    id: number;
-    /** Cancel this animation. Idempotent — no-op once already finished/canceled. */
-    cancel(): void;
-    /** Freeze this animation's virtual clock. Idempotent. */
-    pause(): void;
-    /** Resume this animation's virtual clock. Idempotent. */
-    resume(): void;
-    /** Multiply this animation's virtual-clock rate by `scale`. 1 = normal. */
-    setTimeScale(scale: number): void;
-    /** This animation's own time scale. 1 once it has finished, since the
-     *  animator no longer holds an entry to read. */
-    timeScale(): number;
-    /** True iff this handle is currently paused. */
-    isPaused(): boolean;
-}
-/** A duration-based animation from `from` to `to` over `ms`, shaped by an
- *  easing curve. Reach for a spring instead when the motion should respond to
- *  where the value already is rather than restart from a fixed duration. */
-interface TweenOptions<T> {
-    from: T;
-    to: T;
-    ms: number;
-    easing?: EasingSpec;
-    /** Required when T is not `number`. For T = number, defaults to linear numeric lerp.
-     *  Called per-tick with `(from, to, t)`. For interpolators with expensive setup,
-     *  prefer `interpolator` which is built once at tween start. */
-    interpolate?: Interpolate<T>;
-    /** Factory interpolator built once at tween start. Takes precedence over
-     *  `interpolate` when both are provided. Use this for d3-interpolate or any
-     *  `(from, to) => (t) => v` shape. */
-    interpolator?: InterpolatorFactory<T>;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    /** Any new animation passed the same cancelKey cancels the prior one in flight. */
-    cancelKey?: string;
-    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-/** A spring animation: runs until the value settles on `to` rather than for a
- *  set duration, so it absorbs an initial velocity naturally. Non-numeric `T`
- *  needs the four vector helpers. */
-interface SpringOptions<T> {
-    from: T;
-    to: T;
-    /** Initial velocity in T-units per second. Default: zero (T-shape-aware). */
-    velocity?: T;
-    preset?: SpringPresetName;
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-    interpolate?: Interpolate<T>;
-    /** Vector helpers — required for non-numeric T. When `from`, `to` and `velocity` are numbers, number
-     *  arrays or plain objects of numeric fields of one shape, and stiffness, damping and mass are
-     *  positive, the motion is solved in closed form and these only decide when it has come to rest —
-     *  a `subtract` that wraps an angle won't change the path. */
-    add?: (a: T, b: T) => T;
-    subtract?: (a: T, b: T) => T;
-    scale?: (v: T, k: number) => T;
-    magnitude?: (v: T) => number;
-    /** Velocity magnitude below which the spring is considered settled. Default 0.01. */
-    restThreshold?: number;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-/** Spring and decay as one animation. With a `to`, a spring pulls toward it;
- *  with `to: null`, the value coasts on its velocity. Either can become the
- *  other mid-flight through the handle. */
-interface PhysicsOptions<T> {
-    from: T;
-    /** Target. `null` ⇒ no spring force (decay-mode). */
-    to?: T | null;
-    /** Initial velocity in T-units per second. */
-    velocity?: T;
-    preset?: SpringPresetName;
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-    restThreshold?: number;
-    /** Vector helpers — required for non-numeric T. When `from`, `to` and `velocity` are numbers, number
-     *  arrays or plain objects of numeric fields of one shape, and stiffness, damping and mass are
-     *  positive, the motion is solved in closed form and these only decide when it has come to rest —
-     *  a `subtract` that wraps an angle won't change the path. */
-    add?: (a: T, b: T) => T;
-    subtract?: (a: T, b: T) => T;
-    scale?: (v: T, k: number) => T;
-    magnitude?: (v: T) => number;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-/** An `AnimationHandle` that can also be steered while it runs — the point of
- *  the physics primitive. */
-interface PhysicsHandle<T = unknown> extends AnimationHandle {
-    /** Retarget mid-flight. `null` ⇒ switch to decay-mode (no spring force). */
-    setTarget(to: T | null): void;
-    /** Replace the current velocity in T-units per second. */
-    setVelocity(v: T): void;
-}
-/** Momentum: coast from `from` at `velocity`, slowing by `friction` each
- *  second until below `threshold`. What a flick-to-pan leaves behind. */
-interface DecayOptions<T> {
-    from: T;
-    velocity: T;
-    /** Per-second velocity multiplier in (0, 1). Default 0.95. */
-    friction?: number;
-    /** Velocity magnitude below which decay stops. Default 0.5. */
-    threshold?: number;
-    /** When `from` and `velocity` are numbers, number arrays or plain objects of numeric fields of one
-     *  shape and `friction` is below 1, the motion is solved in closed form: `add` and `scale` go
-     *  unused and `magnitude` only decides when it has come to rest. */
-    add: (a: T, b: T) => T;
-    scale: (v: T, k: number) => T;
-    magnitude: (v: T) => number;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-/** Options for `useAnimator`. Everything here is an injection seam for tests;
- *  the defaults are the real clock, rAF, and `setTimeout`. */
-interface UseAnimatorOptions {
-    /** Optional clock injection for tests. Returns ms since some epoch. */
-    now?: () => number;
-    /** Optional rAF / cAF injection for tests. Defaults to window.requestAnimationFrame. */
-    requestFrame?: (cb: (t: number) => void) => number;
-    cancelFrame?: (handle: number) => void;
-    /** Optional `setTimeout` injection used by `stagger` for per-item delays.
-     *  Defaults to the global `setTimeout`. Tests inject a virtual scheduler. */
-    setTimer?: (cb: () => void, ms: number) => unknown;
-    /** Companion to `setTimer`. Defaults to global `clearTimeout`. */
-    clearTimer?: (handle: unknown) => void;
-}
-/**
- * Owns every running animation on a canvas and drives them from one rAF loop.
- * Beyond the primitives (`tween`, `spring`, `decay`, `physics`) it offers
- * composition — `loop`, `stagger` — and bulk control by handle, by cancel-key,
- * or over everything at once.
- *
- * An animator does not know about the scene: animations report values through
- * `onTick` and the caller decides what to do with them.
- */
-interface Animator {
-    tween<T>(opts: TweenOptions<T>): AnimationHandle;
-    spring<T>(opts: SpringOptions<T>): AnimationHandle;
-    decay<T>(opts: DecayOptions<T>): AnimationHandle;
-    /** Unified spring/decay primitive. With `to` set, behaves as a spring;
-     *  with `to: null`, behaves as a velocity-driven decay. Supports
-     *  mid-flight retargeting via the returned handle's `setTarget`. */
-    physics<T>(opts: PhysicsOptions<T>): PhysicsHandle<T>;
-    /** Cancel a specific animation by handle. Pose stays at current value (no jump). */
-    cancel(handle: AnimationHandle): void;
-    /** Cancel every animation currently active under `key`. */
-    cancelKey(key: string): void;
-    /** Cancel everything. Useful from a destructor or "reset scene" path. */
-    cancelAll(): void;
-    /** True iff at least one animation is active. With `key`, scoped to that cancelKey. */
-    isActive(key?: string): boolean;
-    /**
-     * True while the animator is currently executing an animation tick. Useful
-     * for adapter wrappers (e.g. `animateOnSetPose`) that need to detect
-     * "this `setPose` was called from inside another animation's onTick"
-     * (momentum decay, in-flight tween, spring) and avoid recursively
-     * scheduling a new wrap-animation that would fight the caller.
-     */
-    isTicking(): boolean;
-    /** Freeze every animation managed by this animator. */
-    pause(): void;
-    /** Resume every animation managed by this animator. */
-    resume(): void;
-    /** True iff the animator is currently globally paused. */
-    isPaused(): boolean;
-    /** Multiply every animation's virtual-clock rate by `scale`. 1 = normal. */
-    setTimeScale(scale: number): void;
-    /** The global time scale. Per-animation scales multiply on top of it. */
-    timeScale(): number;
-    /** Freeze every animation whose `cancelKey` matches. */
-    pauseKey(key: string): void;
-    /** Resume every animation whose `cancelKey` matches. */
-    resumeKey(key: string): void;
-    /** Set per-animation timeScale for every animation whose `cancelKey` matches. */
-    setTimeScaleByKey(key: string, scale: number): void;
-    /**
-     * Loop primitive: repeatedly invoke `factory` to produce a child animation.
-     * The factory must wire its returned handle's `onDone` to call `next` so
-     * the loop advances. Returns a handle whose pause/resume/setTimeScale/cancel
-     * delegate to the current in-flight child (and prevent future iterations
-     * on cancel).
-     *
-     * The loop is registered with the animator under a supervisor entry so
-     * `animator.cancel(handle)`, `animator.cancelKey(opts.cancelKey)`, and
-     * `animator.isActive(opts.cancelKey)` all work for it.
-     */
-    loop(factory: LoopFactory, opts?: LoopOptions): AnimationHandle;
-    /** Sugar over `loop` for the common case of looping a tween between two
-     *  values with optional direction handling (`restart` | `reverse` |
-     *  `alternate`). Registered with the animator like `loop`. */
-    tweenLoop<T>(opts: TweenLoopOptions<T>): AnimationHandle;
-    /**
-     * Stagger primitive: schedule a per-item animation, offset by `delay` ms
-     * per index (or a custom function of the index). Two forms:
-     *   - Factory form: pass `factory` directly, returns a composite
-     *     `AnimationHandle`.
-     *   - Builder form: omit `factory`, get a `StaggerBuilder` for fluent
-     *     `.each` / `.tween` / `.springPose` calls.
-     *
-     * The composite handle's `cancel` cancels pending timers AND in-flight
-     * children. `pause` / `resume` / `setTimeScale` propagate to in-flight
-     * children; `pause`/`resume` also freeze and thaw pending per-item timers
-     * (the remaining time before each pending fire is preserved across the
-     * pause).
-     *
-     * The stagger is registered with the animator under a supervisor entry so
-     * `animator.cancel(handle)`, `animator.cancelKey(opts.cancelKey)`, and
-     * `animator.isActive(opts.cancelKey)` all work for it.
-     */
-    stagger<TItem>(items: readonly TItem[], delay: StaggerDelay): StaggerBuilder<TItem>;
-    stagger<TItem>(items: readonly TItem[], delay: StaggerDelay, factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
-    /**
-     * Keyframe timeline. Registered like any other animation, so its playhead
-     * responds to `pause`, `setTimeScale` and `cancelKey`. Sampled tracks are a
-     * pure function of the playhead; event tracks fire only on forward playback.
-     */
-    timeline(opts: TimelineOptions): TimelineHandle;
-    /** Per-node, per-channel color override registry, painted onto scene nodes
-     *  by `<SceneCanvas animator>` and read by `createPathLayer`. Used by `tweenVertexColors`,
-     *  `springVertexColors`, `cycleVertexColors`, `staggerVertexColors`. Cleared
-     *  automatically on animator unmount. */
-    colorOverrides: ColorOverrideRegistry;
-    /**
-     * Subscribe to a callback fired once per RAF frame while any animation is
-     * active. Returns an unsubscribe function. Used by consumers (typically
-     * `<SceneCanvas>`) that need to repaint when an animation's side-effect
-     * is read from a non-scene channel (e.g. `colorOverrides` consulted from
-     * a custom `drawOne`) — scene mutations naturally trigger a repaint, but
-     * `colorOverrides` writes do not.
-     *
-     * The callback fires AFTER the per-frame tick of each registered
-     * animation, so by the time it runs `colorOverrides.get(...)` returns
-     * the latest values. If no animations are active, no tick fires.
-     */
-    onTick(cb: () => void): () => void;
-    /**
-     * Keep the animator's RAF loop running until the returned cancel
-     * function is called. Use for animations whose effect is read on every
-     * frame but which don't have a natural progress state (e.g.
-     * `cycleVertexColors`, which expresses its current value as a function
-     * of `performance.now()` rather than as a tween from `from` to `to`).
-     * Without a keep-alive entry the loop would idle and `onTick` would
-     * stop firing even though the override is still installed.
-     */
-    keepAlive(): () => void;
-    /**
-     * Subscribe to the lifecycle of every animation this animator runs, the
-     * composites and timelines included. Returns an unsubscribe. Events arrive
-     * synchronously, as each thing happens — see {@link AnimatorEvent} for the
-     * order. With no listener attached nothing is built or delivered, so an
-     * unwatched animator pays nothing for this.
-     */
-    watch(listener: AnimatorListener): () => void;
-    /** What is running right now, in registration order: a fresh snapshot per
-     *  call, for a debug overlay to draw. */
-    live(): LiveAnimation[];
-}
-/** Which animator call started an animation. A loop, tween loop or stagger is
- *  an entry of its own beside the children it runs; `keepAlive` holds the
- *  frame loop open and animates nothing. */
-type AnimationKind = 'tween' | 'spring' | 'decay' | 'physics' | 'timeline' | 'loop' | 'tweenLoop' | 'stagger' | 'keepAlive';
-/** Who an {@link AnimatorEvent} is about. One object per registration, so the
- *  same animation's events share it by identity. */
-interface AnimationInfo {
-    /** The id on the animation's handle. */
-    readonly id: number;
-    readonly kind: AnimationKind;
-    /** The animation's `cancelKey`. Pose helpers key by node, as `pose:<id>`. */
-    readonly key?: string;
-    /** The animation's `label` option. */
-    readonly label?: string;
-}
-/** One row of `animator.live()`. */
-interface LiveAnimation extends AnimationInfo {
-    /** Paused on its own handle. The animator-wide pause is `animator.isPaused()`. */
-    readonly paused: boolean;
-    /** Its own time scale; the animator's multiplies on top. */
-    readonly timeScale: number;
-    /** Virtual ms its clock has advanced since it started. */
-    readonly elapsed: number;
-    /** 0 to 1, for a tween or a timeline (the playhead over its duration).
-     *  Absent where there is no end to measure against: physics, composites. */
-    readonly progress?: number;
-}
-/**
- * One thing happening to an animation, as `animator.watch` delivers it.
- *
- * - `start` — registered. A finished timeline that `seek` or `edit` revives
- *   starts again, under the same id.
- * - `end` — finished on its own. Delivered once every animation has ticked
- *   that frame, in registration order.
- * - `cancel` — stopped by its handle, `cancel`, `cancelKey` or `cancelAll`.
- * - `interrupt` — stopped because `by` claimed its `cancelKey`. Delivered
- *   before `by`'s `start`.
- * - `error` — its tick threw (an `onTick`, `onDone` or interpolator), so it was
- *   taken off the table, after the frame's other animations ticked. In place of
- *   `cancel`, or after `end` when `onDone` threw. The error is also logged.
- * - `lap` — a looping timeline wrapped; `lap` counts wraps since it started.
- * - `fire` — an event on a timeline's event track was crossed, at any depth.
- *   `path` indexes from the root timeline's `tracks()` down through each
- *   nested timeline to the event track. Delivered after the event's own `fire`.
- */
-type AnimatorEvent = {
-    readonly type: 'start' | 'end' | 'cancel';
-    readonly animation: AnimationInfo;
-} | {
-    readonly type: 'interrupt';
-    readonly animation: AnimationInfo;
-    readonly by: AnimationInfo;
-} | {
-    readonly type: 'error';
-    readonly animation: AnimationInfo;
-    readonly error: unknown;
-} | {
-    readonly type: 'lap';
-    readonly animation: AnimationInfo;
-    readonly lap: number;
-} | {
-    readonly type: 'fire';
-    readonly animation: AnimationInfo;
-    readonly track: EventTrack;
-    readonly path: readonly number[];
-    readonly event: TimelineEvent;
-    /** As the event's own `fire` is told: ms behind the frame it was crossed. */
-    readonly lateBy: number;
-};
-/** Receives what `animator.watch` delivers. */
-type AnimatorListener = (event: AnimatorEvent) => void;
-/** Options for `Animator.loop`. */
-interface LoopOptions {
-    /** Maximum number of iterations. Default Infinity. */
-    count?: number;
-    /** Invoked when the loop reaches `count` iterations naturally (not on cancel). */
-    onDone?: () => void;
-    /** Any new animation passed the same cancelKey cancels the prior one in flight.
-     *  Also enables `animator.cancelKey` / `animator.isActive(key)` for this loop. */
-    cancelKey?: string;
-    /** Names this loop in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-/** A stagger run's own options: the factory form's fourth argument, and part
- *  of every fluent builder method's options. */
-interface StaggerOptions {
-    /** Cancel-key for the supervising registration. `animator.cancelKey(key)`
-     *  cancels the whole stagger; `animator.isActive(key)` returns true while
-     *  any timer or child is alive. */
-    cancelKey?: string;
-    /** Names this stagger in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-/** Produces one iteration of a loop. Must arrange for `next` to be called when
- *  the animation it returns finishes, or the loop stalls after one pass. */
-type LoopFactory = (iteration: number, next: () => void) => AnimationHandle;
-/** Per-index delay schedule. Number ⇒ `index * delay` ms. Function ⇒ caller
- *  decides the absolute delay for each index (e.g. `i => i * i * 30`). */
-type StaggerDelay = number | ((index: number) => number);
-/** Produces the animation for one staggered item. */
-type StaggerFactory<TItem> = (item: TItem, index: number) => AnimationHandle;
-/** A `T` value or a function that derives one from the per-item context. Used
- *  by the fluent builder methods (`.tween`, `.springPose`) so each item can
- *  vary an option (e.g. `to: (_item, i) => (i + 1) * 10`). */
-type StaggerPerItem<T, TItem> = T | ((item: TItem, index: number) => T);
-/** Options for the stagger builder's `.tween`: a tween per item, where
- *  `from`, `to` and `ms` may each vary by item. `cancelKey` and `label` belong
- *  to the stagger as a whole, as in {@link StaggerOptions}. */
-interface StaggerTweenOptions<T, TItem> extends StaggerOptions {
-    from: StaggerPerItem<T, TItem>;
-    to: StaggerPerItem<T, TItem>;
-    ms: StaggerPerItem<number, TItem>;
-    easing?: EasingSpec;
-    interpolate?: Interpolate<T>;
-    onTick: (value: T, item: TItem, index: number) => void;
-    onDone?: (item: TItem, index: number) => void;
-}
-/** Options for the stagger builder's `.springPose`: the spring tuning, and
- *  whether each item's settle is recorded as an undoable op. `cancelKey` and
- *  `label` belong to the stagger as a whole, as in {@link StaggerOptions};
- *  each item's spring keeps its own per-node key. */
-interface StaggerSpringPoseOptions<TPose> extends StaggerOptions {
-    preset?: SpringPresetName;
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-    geometry?: PoseDescriptor<TPose>;
-    recordOp?: boolean;
-    opLabel?: string;
-}
-/** Fluent form of `Animator.stagger`: pick what to run per item after the
- *  items and the delay schedule are already fixed. */
-interface StaggerBuilder<TItem> {
-    /** Run an arbitrary per-item factory. */
-    each(factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
-    /** Sugar: per-item `animator.tween` with per-item-varying options. */
-    tween<T>(opts: StaggerTweenOptions<T, TItem>): AnimationHandle;
-    /** Sugar: per-item `springPose` against an adapter. `poseFn` returns the
-     *  target pose for each item. Each item must either be a primitive
-     *  (string/number) or expose a string `id` field — otherwise pose ids
-     *  would collide on `"[object Object]"` and successive tweens would
-     *  cancel each other. Throws on items that satisfy neither. */
-    springPose<TPose>(adapter: SceneAdapter<{
-        id: string;
-    }, TPose>, poseFn: (item: TItem, index: number) => TPose, opts?: StaggerSpringPoseOptions<TPose>): AnimationHandle;
-}
-/** Options for `Animator.tweenLoop` — a tween's options plus how each
- *  iteration relates to the last. */
-interface TweenLoopOptions<T> {
-    from: T;
-    to: T;
-    ms: number;
-    easing?: EasingSpec;
-    /** `restart` (default): from→to every iteration.
-     *  `reverse`: to→from every iteration.
-     *  `alternate`: even iterations from→to, odd iterations to→from. */
-    direction?: 'restart' | 'reverse' | 'alternate';
-    count?: number;
-    interpolate?: Interpolate<T>;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
-    label?: string;
-}
-
-/** 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 250. */
-    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. One animation 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: Bounds, 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;
-}
-/**
- * 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 the
- * *live* view rather than a captured value — an interrupted camera never jumps.
- * Two instances on one animator are independent.
- */
-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;
-
-/**
- * @experimental
- * PointerContext — the world-space position of the canvas pointer, and the
- * view it is over, refreshed on every `pointermove` and cleared on
- * `pointerleave`.
- *
- * It is an external store rather than React state: cursor moves fire dozens of
- * times per second, and a consumer that only reads on demand (paste at the
- * pointer) must not re-render for each one. Readers that do need to follow it
- * — a linked cursor — subscribe, or use `usePointerPosition()`.
- *
- * `<SceneCanvas>` publishes automatically, and defers to a provider already in
- * scope, so several surfaces under one provider share one pointer: a detached
- * minimap and its main canvas each see where the other's pointer is.
- */
-
-/** @experimental World-space pointer position and the view it is over — a
- *  view id, or `null` for a surface's own camera. `null` as a whole when the
- *  pointer is over no publishing surface. */
-type PointerWorldPos = {
-    worldX: number;
-    worldY: number;
-    viewId: string | null;
-} | null;
-/** @experimental */
-interface PointerContextValue {
-    /** The latest position. */
-    get(): PointerWorldPos;
-    /** Publish a position. Subscribers hear only a changed value. */
-    set(next: PointerWorldPos): void;
-    /** Called after every change; returns the unsubscribe. */
-    subscribe(fn: () => void): () => void;
-    /** Bumps on every change. */
-    getVersion(): number;
-    /** `get()` as a stable thunk, for hooks taking a drop-point option. */
-    readonly getDropPoint: () => PointerWorldPos;
-}
-/** @experimental A pointer store with no provider around it. */
-declare function createPointerStore(): PointerContextValue;
-/**
- * @experimental
- * Wrap the part of the React tree that should share one pointer. Usually at
- * the app root, alongside `<ActionsProvider>` and `<SelectionContextProvider>`.
- *
- * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts
- * one when none is in scope. Mount it yourself when two surfaces should share
- * a pointer. Pass `store` to publish into one you hold elsewhere
- * (`createPointerStore()`).
- */
-declare function PointerContextProvider({ children, store }: {
-    children: ReactNode;
-    store?: PointerContextValue;
-}): ReactNode;
-/** @experimental The surrounding pointer store, or `null` when no provider is
- *  in scope. */
-declare function usePointerContext(): PointerContextValue | null;
-/** @experimental The pointer, re-rendering the caller whenever it changes.
- *  `null` outside a provider. */
-declare function usePointerPosition(): PointerWorldPos;
-
-/**
- * Project a leaf path from its source frame into world coordinates given a
- * `{x, y, width, height, rotation?}` pose. Two transforms compose, in this
- * order:
- *
- *   1. Translate so the path's source AABB origin lands at `pose.x, pose.y`.
- *   2. If `pose.rotation` is nonzero, rotate every coord about the unrotated
- *      AABB center — i.e. `(pose.x + pose.width/2, pose.y + pose.height/2)`,
- *      matching `SceneCanvas.rotateAroundAABBCenter` so the baked geometry
- *      lines up with what the renderer draws.
- *
- * RectPaths can't carry rotation as-is (they're axis-aligned by definition);
- * a non-zero `pose.rotation` on a rect promotes the result to a polygon so
- * the four corners are baked into world coords. Callers that need to keep
- * the rect fast-path can pre-check `pose.rotation` themselves.
- *
- * Used by adapters that need true world geometry — most notably boolean ops,
- * where operating on the unrotated source path produces wrong shapes.
- */
-
-/** Subset of pose fields this helper consumes. Matches the kit's auto-rotate
- *  convention (`SceneCanvas.defaultDrawOne`): `x/y/width/height` define an
- *  AABB whose unrotated center is the rotation pivot. */
-interface PathInWorldPose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation?: number;
-}
-/**
- * Project a stored path into the pose's **local frame** — translate (and, for
- * rects, rebase to the pose's `width`/`height`) so the path's AABB origin sits
- * at the pose origin. This is translate-only: it does NOT apply
- * `pose.rotation`. Callers that want the fully world-positioned (rotated) path
- * should use `pathInWorld`, which composes this with the rotation wrap.
- *
- * Rects rebase onto the pose's `width`/`height` because resize updates the pose,
- * not the stored `RectPath` — so the live size lives on the pose. Honoring it
- * here keeps this in lockstep with the renderer (`SceneCanvas` paints the rect
- * at `pose.width/height`); otherwise world-space consumers (slice, booleans,
- * release-compound) would operate on the stale pre-resize dimensions.
- *
- * Used by the local seams: the default painter (paint + silhouette), and as the
- * building block `pathInWorld`/`findShapeSilhouette` rotate on top of.
- */
-declare function pathInPoseFrame(path: Path, pose: PathInWorldPose): Path;
-/**
- * Bake `pose` into `path`'s coordinates so the returned path is positioned
- * in world space. Returns a fresh `Path` instance; never mutates inputs.
- */
-declare function pathInWorld(path: Path, pose: PathInWorldPose): Path;
-/**
- * Inverse of `pathInWorld` for a path in **world** space: the unrotated
- * stored path plus the pose that draws it there. Inverse-rotates about the
- * pose's AABB center, so the stored path is unrotated and the pose's
- * `rotation` is preserved, then fits the pose's AABB fields to the result.
- * The new box's center is placed where the old rotation carries it, since
- * the pivot moves with the box: `pathInWorld(result.path, result.pose)`
- * reproduces `worldPath` whether or not its bounds changed.
- *
- * Generic in the pose type so consumer-defined pose fields (including
- * `rotation`) survive the round-trip. Used by the anchor-edit commit, its
- * live preview, and the default slice dep.
- */
-declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: PolygonPath): {
-    pose: P;
-    path: PolygonPath;
-};
-declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: Path): {
-    pose: P;
-    path: Path;
-};
-
-/**
- * Text as path geometry: the glyph outlines a text node draws, placed in
- * world space and composed into one `Path`. What "Create Outlines" replaces a
- * text node with, and what a Boolean op reads when a text node is an operand.
- *
- * The walk is `layoutRuns`', so the glyphs land exactly where the renderer's
- * outline tier puts them — same pen positions, same baselines, same synthetic
- * italic shear — but with the tier forced on for every glyph whatever its
- * size, and with paint set aside: unfilled text has outlines too.
- * `textToPathsByPaint` is the same walk, split by the paint each glyph wears.
- */
-
-/** The fields of a text node's data that decide its glyph geometry, and the
- *  paint `textToPathsByPaint` splits it by. Paint never changes the geometry. */
-interface TextOutlineSource {
-    text: string;
-    runs?: readonly StyledRun[];
-    style?: TextStyle;
-    verticalAlign?: TextVerticalAlign;
-    /** The node's `data.fill`: `null` is no fill, absent the default black. */
-    fill?: FillStyle | null;
-    /** The node's `data.stroke`: absent or `null` is no stroke. */
-    stroke?: Stroke | null;
-}
-/** One paint's share of a text node's outlines — see {@link textToPathsByPaint}. */
-interface TextPaintPath {
-    /** The resolved fill these glyphs wear: the run's own, else the node's.
-     *  `null` for unfilled text, painted by its stroke alone. */
-    fill: FillStyle | null;
-    /** The resolved stroke — the run's own, else the node's — or absent. */
-    stroke?: Stroke;
-    /** World-space outlines, as {@link textToPath} builds them. */
-    path: PolygonPath;
-}
-/** A text node as {@link textToPath} reads it: its data and its pose. */
-interface TextNodeSource {
-    data: TextOutlineSource;
-    pose: PathInWorldPose;
-}
-/** Options for {@link textToPath}. */
-interface TextToPathOptions {
-    /** The view scale a `{ px }` `fontSize` or `letterSpacing` resolves
-     *  against, as for `textCommandFromPose`. Default 1. */
-    scale?: number;
-}
-/**
- * Why a text node has no outline geometry to give:
- *
- * - `'no-outlines'` — the face that serves it has no outlines registered
- *   (`registerFontOutlines`), so there is no geometry to read.
- * - `'outlines-loading'` — registered but not parsed yet. `loadTextOutlines`
- *   waits for it; the call has already started the load.
- * - `'outlines-failed'` — registered, and the bytes did not load or parse.
- * - `'synthetic-bold'` — the requested weight is faked from a lighter face.
- *   The renderer thickens the distance field for that, and a path has no
- *   field to thicken; emboldening geometry needs outline offsetting, which
- *   the kit does not have. Converting would silently lighten the text.
- */
-type TextOutlinesFailure = 'no-outlines' | 'outlines-loading' | 'outlines-failed' | 'synthetic-bold';
-/** Thrown by {@link textToPath} when some run of the text has no outline
- *  geometry. Names the run's requested face. */
-declare class TextOutlinesError extends Error {
-    readonly reason: TextOutlinesFailure;
-    readonly family: string;
-    readonly weight: number;
-    readonly style: FontStyle;
-    constructor(reason: TextOutlinesFailure, family: string, weight: number, style: FontStyle, detail: string);
-}
-/**
- * The outline geometry of a text node, in world space: every glyph and every
- * underline, strikethrough and overline rule it draws, as one `'nonzero'`
- * compound path whose filled region is their union. Glyphs keep the font's
- * curves; overlapping contours are not merged — run the result through
- * `pathUnion` for that, at the cost of flattening the curves.
- *
- * `pose` is the node's box and rotation. Synthetic italic is sheared exactly
- * as the renderer shears it. Throws {@link TextOutlinesError} when any run's
- * face cannot supply outlines — never returns a partial or empty path for
- * that. Text with no ink (empty, or only spaces) returns an empty path.
- */
-declare function textToPath(data: TextOutlineSource, pose: PathInWorldPose, opts?: TextToPathOptions): PolygonPath;
-/**
- * {@link textToPath}, split by paint: one path per distinct resolved fill and
- * stroke, each gathering the glyphs and decoration rules that wear it — a
- * rule takes the fill of the run it underlines. Groups come in the order
- * their paint first appears in the text; a paint whose runs put down no ink
- * has none. Together the paths cover exactly what `textToPath` covers.
- *
- * Paint resolves as the renderer resolves it: a run's `fill` / `stroke`, else
- * the node's `data.fill` / `data.stroke` from `data`, else the default black
- * fill and no stroke. Throws as `textToPath` does.
- */
-declare function textToPathsByPaint(data: TextOutlineSource, pose: PathInWorldPose, opts?: TextToPathOptions): TextPaintPath[];
-/**
- * Load the outlines of every face `data` is set in — the requested faces and
- * the ones they resolve to — so a following {@link textToPath} does not fail
- * with `'outlines-loading'`. Resolves once each has loaded or failed.
- */
-declare function loadTextOutlines(data: TextOutlineSource, opts?: TextToPathOptions): Promise<void>;
-
-/**
- * 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 Create Outlines must carry — see
- *  {@link CreateOutlinesAdapter.createPathNode}. */
-interface OutlinePathSpec {
-    /** The fill these glyphs wear, resolved: their run's, else the node's,
-     *  else the default text fill. `null` is no fill. */
-    fill: FillStyle | null;
-    /** The stroke they wear, resolved the same way; absent for none. */
-    stroke?: Stroke;
-    /** The parent the path goes under: the text's own, or the container
-     *  minted to hold a multi-paint text's paths. */
-    parent: string | null;
-}
-/** What `applyCreateOutlines` reads and writes through. */
-interface CreateOutlinesAdapter {
-    getSelection(): readonly NodeId[] | readonly string[];
-    /** The text node behind `id`, or `undefined` for anything else. */
-    getTextSource(id: NodeId): TextNodeSource | undefined;
-    /**
-     * Mint one path node of text 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 sit under `spec.parent`.
-     * The kit places it; only the consumer knows its data shape.
-     */
-    createPathNode(path: PolygonPath, sourceId: NodeId, spec: OutlinePathSpec): {
-        id: string;
-    };
-    /**
-     * Mint the container that holds a multi-paint text's paths, under `parent`.
-     * `bounds` is the world envelope of the paths. The kit puts the container in
-     * the text's slot and the paths inside it, in the text's order. 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. Without it the
-     *  delete captures an `{ id }` stub. */
-    getNode?(id: string): {
-        id: string;
-    } | undefined | null;
-    /** Parent and sibling order — the reorder contract. With both, each path is
-     *  inserted at its text node's index; without, where `insertNode` defaults. */
-    getParent?(id: string): string | null;
-    getChildren?(parentId: string | null): readonly 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;
-
-/** Boolean op identifiers — five Pathfinder primaries plus Crop. */
-type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop';
-/**
- * z-position descriptor for a path node. `parentId` is the direct parent
- * (or `null` for a top-level node); `index` is the position within that
- * parent's child order — never a global render index.
- */
-/** @internal */
-interface BooleanZOrder {
-    parentId: string | null;
-    index: number;
-}
-/** 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;
-    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
-     * topmost source, whose slot the result takes: give the node that source's
-     * parent, or the kit's reorder cannot find it there.
-     */
-    createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId): {
-        id: string;
-    };
-    /**
-     * Optional: return the full object for an id, used by the delete ops so
-     * their `invert` (an insert) can restore the complete object on undo.
-     * If omitted, a `{ id }` stub is captured — undo will reinstate the id
-     * but consumers reading other fields (path, fill, etc.) will see them as
-     * undefined. Mirrors `DeleteAdapter.getNode`; should be provided whenever
-     * undo over boolean ops is expected to be lossless.
-     */
-    getNode?(id: NodeId): {
-        id: string;
-    } | undefined | null;
-    /**
-     * Optional: the reorder contract. With `getChildren` (and `getParent`, or
-     * every node reads as top-level) the kit reads each source's slot among its
-     * siblings, and with `setChildOrder` as well it moves the result into the
-     * topmost source's slot. Without them the result lands wherever
-     * `insertNode` defaults to. `defaultCommitAdapter` supplies all three.
-     */
-    getParent?(id: string): string | null;
-    getChildren?(parentId: string | null): readonly string[];
-    setChildOrder?(parentId: string | null, ids: string[]): void;
-    /**
-     * Optional override for the slot the kit otherwise reads through
-     * `getParent` / `getChildren`: `id`'s parent and its index in that
-     * parent's child order.
-     *
-     * @deprecated Supply `getParent` and `getChildren` instead, and the kit
-     * derives this.
-     */
-    getZOrder?(id: NodeId): BooleanZOrder | undefined;
-    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;
-};
-/**
- * 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.
- */
-declare function applyBooleanOp(adapter: BooleansAdapter, op: BooleanOp): BooleanOpResult;
-
-/** 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. The `ctx` object is shared across all
-     *  handlers in one `runIngest` call, and higher-priority handlers' `handle`
-     *  bodies run (synchronously) before lower ones — so `kit:svg`'s
-     *  `text/plain` SVG fallback reads this to decline the SVG flavor of a copy
-     *  whose canonical 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);
-    /** 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;
-
-/**
- * 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: Mat3): unknown | null;
-}
-
-/** 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 — letting
-     *  consumers re-fit the page (or other reference bounds) into the workspace.
-     *  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;
-/**
- * Adapter dep for `areaSelectAction`.
- *
- * Provided by `<SceneCanvas>` / `<StandardActionsRegistrar>` via AABB
- * overlap over scene nodes. Consumers with custom hit-testing override this
- * dep entry in their own registrar.
- */
-/**
- * Topmost-node-at-world-point dep, consumed by `moveAction` for
- * reparent-on-drop and available to any action that needs a single-best
- * pick. Mirrors the same hit-test plumbing `<SceneCanvas>` feeds to the
- * tool dispatcher; consumers with custom hit-testing override here.
- *
- * `exclude` is iterated once per call and treated as a set membership
- * test — the dep walks hits front-to-back and returns the first id not
- * in the exclude set. 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 `editAnchorsAction`.
- *
- * Provides narrow read/write access to the editable polygon for a single
- * node. Consumers register this dep so anchor-edit actions can read/write
- * the polygon WITHOUT knowing whether it lives directly on the node's
- * pose (`pose.kind === 'polygon'`) or on `node.data.path` (the kit's
- * built-in pen-tool default, also WeaselDraw's shape).
- *
- * Note on live previews: in-flight edit state is surfaced through the
- * dispatcher's standard `OngoingHandle.previewIds/previewPose/previewData`
- * triple (not this dep), so chrome and preview-ghost stay in lock-step
- * via one source of truth.
- */
-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. `enterPathEditAction` and `exitPathEditAction` call
-     *  this; consumers can call it directly to drive edit mode programmatically. */
-    setEditingId(id: string | null): void;
-    /** Returns the COMMITTED editable polygon in world coordinates, or
-     *  null if this node has no editable polygon. Does NOT consult in-
-     *  flight previews — callers that need live state read the dispatcher's
-     *  in-flight handles. */
-    getEditablePath(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. The
-     *  action uses this to know which preview-ghost axis to populate
-     *  (`previewPose` only / `previewData` + `previewPose` for data.path). */
-    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`. Used by
-     *  `editAnchorsAction` for the data.path branch (rect pose + data
-     *  carrying extra fields like fill / stroke that must be preserved
-     *  through the preview). Returns null when the node is gone. */
-    getNodeShape(id: string): {
-        pose: unknown;
-        data: unknown;
-    } | null;
-    /** Commit `worldPath` as the new value for `id`. Implementation routes
-     *  to setPose (when pose IS the polygon) or batched setPose+update
-     *  (when the polygon lives on data.path). Records one history entry
-     *  labelled `label`. */
-    applyEdit(id: string, worldPath: unknown, label: string): 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. */
-    editOps?(id: string, worldPath: unknown, label: string): 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, matching
-     * Illustrator.
-     */
-    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. Written by `marqueeAnchorsAction` and read by
-     * the path-editing overlay — the same "ongoing action owns the preview,
-     * chrome just draws it" split the move/resize ghosts use.
-     */
-    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;
-}
-/**
- * Adapter dep for `lassoSelectAction`.
- *
- * Provides polygon-lasso hit-testing + selection read/write.
- * Consumers that don't implement `hitTestLasso` can omit it; the action
- * falls back to a bounding-box AABB test via `hitTestArea`.
- */
-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;
-}
-/**
- * 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 — core importing
-     *  it back would make the two mutually dependent and unpublishable
-     *  separately. Passing the function keeps the parser out of core's bundle
-     *  for consumers who never unpack. */
-    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;
-}
-/**
- * Dep for the `ingest` action (external-content ingestion).
- * Sourced from `<SceneCanvas>` / `<StandardActionsRegistrar>` via
- * `useIngestionDepSource` — canvas rect + current view.
- */
-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;
-}
-/**
- * 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.
- */
-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;
-} | {
-    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;
-};
-/**
- * World-space point snapping — grid, guides, or any consumer rule.
- *
- * Sourced by `<SceneCanvas>` from its `toolOptions.snapPoint`. Actions apply
- * it to the coords they ingest so the live preview and the committed
- * geometry agree; `insertAction` snaps the drag's start and current point.
- *
- * Optional: when the dep is absent, actions treat it as identity.
- */
-interface SnapDep {
-    /** Snap a world-space point. Return `p` unchanged to opt out. */
-    point(p: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-}
-/**
- * Adapter dep for `insertAction`.
- *
- * Provided by `<SceneCanvas>` / `<StandardActionsRegistrar>`. The `extras`
- * carry the active tool's kind + per-kind geometry. Callers
- * that need typed data must supply a richer `insert` dep.
- */
-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): NodeId | 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;
-}
-/**
- * Adapter dep for `resizeAction`.
- *
- * Carries the behavior-shaping options the legacy `useResize` hook
- * exposed through `UseResizeOptions`: bounds-frame behaviors (e.g.
- * `lockAspectWithModifier`), world-space anchor-point snap behaviors (e.g.
- * `@weasel-js/guides`' `pointSnapToGrid`), and group-expansion (`expandIds`).
- *
- * Optional in `DepSchema`: when absent, `resizeAction` falls back to
- * identity defaults (no behaviors, identity expandIds). Consumers wire the
- * dep via `useDepSource('resizePolicy', ...)` from any descendant of
- * `<DepRegistryProvider>` / `<SceneCanvas>`.
- *
- * The generic is erased to `unknown` at the schema entry; consumers cast at
- * the call site (mirrors the `scene` entry's convention).
- */
-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 Bounds ? BoundsConstraint<TPose>[] : never[];
-    /** World-space anchor-point snap behaviors. Same TPose constraint as
-     *  `constraints`. */
-    pointSnap: TPose extends Bounds ? PointSnapBehavior<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 its `layouts`
- * prop. Optional: `getLayout` returns null for any container when no layout
- * is configured, 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;
-}
-/**
- * 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: (id) => scene.get(id as NodeId)?.data?.kind === 'text',
- * }));
- * ```
- */
-interface TextEditDep {
-    /**
-     * Begin editing the node with `id`. Activates the contenteditable overlay
-     * managed by `useTextEdit` / `useSceneTextEdit`.
-     */
-    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(): 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;
-}
-/**
- * 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 itself is declared empty
- * in `@weasel-js/routing`, which knows that an action names its dependencies
- * but not what any of them are; 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;
-        /** Currently active tool id + hotkey-hold stack. */
-        activeTool: ActiveToolContextValue;
-        /**
-         * Area-select dep — AABB hit-test + selection read/write.
-         *
-         * Sourced from `<SceneCanvas>` via AABB overlap over all scene
-         * nodes. Override per-consumer for custom hit-testing (e.g. contain-mode,
-         * lock-aware filtering).
-         */
-        areaSelect: AreaSelectDep;
-        /**
-         * Topmost node at a world-space point. Sourced by `<SceneCanvas>` from
-         * the same picker that feeds the tool dispatcher's `getNodeAtPoint`.
-         * 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.
-         *
-         * Sourced from `<SceneCanvas>`. The `kind` param comes from
-         * the active binding's `opts.params.kind`. Override per-consumer to
-         * provide a typed node factory (e.g. with custom data payloads).
-         */
-        insert: InsertDep;
-        /**
-         * Snap dep — world-space point snapping (grid / guides).
-         *
-         * Sourced by `<SceneCanvas>` from `toolOptions.snapPoint`. Optional:
-         * absent means no snapping (identity).
-         */
-        snap?: SnapDep;
-        /**
-         * The canvas's debug sink — the one tools reach as `ToolCtx.debug`.
-         * Sourced by `<SceneCanvas>`; absent while its `debug` overlay is off.
-         * Actions report what they did here, and the overlay draws it.
-         */
-        debug?: DebugSink;
-        /**
-         * Lasso-select dep — polygon hit-test + selection read/write.
-         *
-         * Sourced from `<SceneCanvas>` / `<StandardActionsRegistrar>`.
-         * Falls back to AABB hit-test when `hitTestLasso` is absent.
-         */
-        lassoSelect: LassoSelectDep;
-        /**
-         * Edit-anchors dep — narrow read/write of one polygon's path pose.
-         *
-         * Sourced from consumer. Wraps `getPose`/`setPose`/`applyOps`
-         * for the currently-being-edited polygon node.
-         *
-         * The `editAnchorsAction` requires this dep to be registered when anchor
-         * editing is active. If absent, `start` returns an empty handle (no-op).
-         */
-        editAnchors: EditAnchorsDep;
-        /**
-         * Text-edit dep — activates the in-place text editing overlay.
-         *
-         * Sourced from consumer via `useTextEdit` / `useSceneTextEdit`.
-         * The `enterTextEditAction` requires this dep to be registered by the text
-         * tool when text editing is available.
-         *
-         * 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
-         * (no constraints, no snap, identity expandIds).
-         * 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>;
-        /**
-         * 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)` (a thin wrapper
-         * around `useDepSource('booleansAdapter', ...)`). The descriptor's
-         * `enabled` predicate reads `deps.selection` for the count check; the
-         * invoker reads `deps.booleansAdapter` to execute the op.
-         */
-        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 — exposes `cancelAll(reason)` so
-         * actions that need to abort an in-flight handle (Escape cancels a
-         * drag, etc.) can do so. Sourced by `<SceneCanvas>` from the
-         * dispatcher instance it already owns.
-         */
-        dispatcher?: {
-            cancelAll(reason: 'commit' | 'cancel'): void;
-        };
-        /**
-         * Layout-strategy lookup. Sourced by `<SceneCanvas>` from `layouts`.
-         * 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 — the imperative surface `useClipboardOps` returns.
-         *
-         * Published by the consumer (`useDepSource('clipboard', …)` from under
-         * `<SceneCanvas>`), because `useClipboardOps` needs an adapter and a
-         * selection reader only the consumer has. Feeds `clipboard.copy` /
-         * `clipboard.cut`; both no-op when the dep 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;
-        /** Optional pose-composition strategy for hierarchical (local-pose) scenes.
-         *  When absent, defaults to IDENTITY (absolute-pose: nodes store world
-         *  coords). Local-pose consumers supply { compose: composeRectPose,
-         *  decompose: decomposeRectPose } (or their pose shape's equivalent). */
-        poseComposition?: PoseComposition<unknown>;
-        /**
-         * Ingestion dep — canvas viewport rect + consumer file→src resolver.
-         *
-         * Sourced from `<SceneCanvas>` / `<StandardActionsRegistrar>` via
-         * `useIngestionDepSource`. Feeds `ingestAction` with the world-space
-         * viewport rect for paste-placement and image fit-clamping, and forwards
-         * the consumer's optional `resolveSrc` seam.
-         *
-         * 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. apps/draw wires this
-         * to mirror `data.path` through `transformPath`. 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?: 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;
-    }
-}
-
-/**
- * The routing types that carry an overlay, bound to the kit's `RenderLayer`.
- *
- * `@weasel-js/routing` never reads an overlay — it collects the live ones and
- * hands them back in scope order — so it leaves the element type open. What a
- * weasel canvas draws is a `RenderLayer`, and every kit call site should see
- * that rather than `unknown`, so core binds the parameter once, here, and
- * re-exports these names under the ones they have always had.
- */
-
-/** What a canvas overlay is, at this layer. */
-type Overlay = RenderLayer<unknown>;
-declare module '@weasel-js/routing' {
-    interface OverlaySchema {
-        overlay: RenderLayer<unknown>;
-    }
-}
-/** Routing's `Contribution`, with overlays typed as `RenderLayer`. */
-type Contribution = Contribution$1<Overlay>;
-/** Routing's `ContributionChrome`, with overlays typed as `RenderLayer`. */
-type ContributionChrome = ContributionChrome$1<Overlay>;
-/** Routing's `Tool`, with overlays typed as `RenderLayer`. */
-type Tool<TScratch = unknown> = Tool$1<TScratch, Overlay>;
-/** A `Tool` of any scratch type: the element type for a list of mixed tools. */
-type AnyTool = AnyToolOf<Overlay>;
-/** Routing's `ToolDef` (what `defineTool` takes), with overlays typed as `RenderLayer`. */
-type ToolDef<TScratch = void> = ToolDef$1<TScratch, Overlay>;
-/** Routing's `ToolsApi`, with overlays typed as `RenderLayer`. */
-type ToolsApi = ToolsApi$1<Overlay>;
-/** Routing's `UseToolsOptions`, with overlays typed as `RenderLayer`. */
-type UseToolsOptions = UseToolsOptions$1<Overlay>;
-/** Routing's `useTools`, typed for `RenderLayer` overlays. */
-declare const useTools: (opts: UseToolsOptions) => ToolsApi;
-
-/**
- * The space a screen-pixel stroke is built in.
- *
- * A `{ px }` stroke is exact on screen only when its ribbon is offset in a
- * space that measures lengths the way the screen does. The transform's linear
- * part is `scale · R · P`: a uniform scale, a rotation (or reflection) that
- * moves no lengths, and `P`, the symmetric unit-determinant stretch left over.
- * Offsetting the ribbon after `P` and mapping it back through `P⁻¹` gives a
- * world-space mesh that the full transform turns into a ribbon of exactly
- * `width · scale` pixels in every direction — and keeps the mesh drawable by
- * every path that draws a world-space ribbon.
- *
- * `P` depends only on the lengths the transform induces (`LᵀL`), not on any
- * rotation applied after it, so a view that only pans or zooms uniformly keeps
- * the same metric and the ribbon cache keeps hitting.
- */
-
-/** `P` = [[p, q], [q, r]], with `pr − q² = 1`. */
-interface StrokeMetric {
-    readonly p: number;
-    readonly q: number;
-    readonly r: number;
-}
-
-/**
- * Trimming a stroke's ends where each inset is measured.
- *
- * A head stops the line by a length in the head's own space, which need not be
- * the ribbon's: a world-sized head on a `{ px }` stroke stops it a world
- * distance short, a `{ px }` head on a world-width stroke a screen distance.
- * Under a stretching view one length means different distances in the two
- * spaces depending on which way the line runs, so each end is trimmed in its
- * own space rather than converted.
- */
-
-/** A length along the line measured in `metric`'s space, or in world where
- *  `metric` is `null`. */
-interface MeasuredLength {
-    readonly length: number;
-    readonly metric: StrokeMetric | null;
-}
-/** A plain number is a length in the ribbon's own space. */
-type InsetLength = number | MeasuredLength;
-
-/** Options for stroke tessellation. */
-interface StrokeOptions {
-    flattenTolerance?: number;
-    /**
-     * Shorten each open subpath by this much at its start / end: a length in
-     * the ribbon's space, or one measured in a space of its own. Stroke markers
-     * use this so a filled head is not speared by its own line; the caller
-     * resolves the distance, because this layer knows nothing about the marker
-     * registry.
-     */
-    startInset?: InsetLength;
-    endInset?: InsetLength;
-    /**
-     * Build the ribbon in this metric's space and map it back out, so the
-     * transform it was derived from draws it at an exact screen width — see
-     * `./metric`. Width and dash are then lengths in that space; `vertexWidths`
-     * stay world widths. The path is flattened in world first, so the ribbon
-     * follows the same vertices its fill does.
-     */
-    metric?: StrokeMetric;
-}
-/** Resolve a stroke width to world units. A number is already world units;
- *  `{ px }` is screen pixels divided by the accumulated scale, so it holds its
- *  on-screen thickness as the view zooms. */
-declare function resolveStrokeWidth(width: ScreenLength, scale: number): number;
-/**
- * Build a triangle-mesh ribbon from a stroked Path.
- *
- * Supports:
- *   - cap: 'butt' | 'round' | 'square'
- *   - join: 'miter' | 'round' | 'bevel'
- *   - center alignment directly; RectPath inner/outer alignment via a
- *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the
- *     renderer level
- *   - dash splitting
- */
-declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
-
-/**
- * Effects that ship with the kit.
- *
- * Each is a function returning `Effect[]`, not a single `Effect`, because a
- * separable kernel is genuinely two passes and hiding that behind one entry
- * would make the cost invisible at the callsite:
- *
- *   effects={[...blur({ radius: 4 }), ...vignette({ amount: 0.6 })]}
- */
-
-/**
- * Gaussian blur, as a horizontal pass followed by a vertical one.
- *
- * `radius` is in device pixels and is the distance of the outermost tap, not a
- * standard deviation — 0 is a copy, and the falloff is the same nine-tap
- * kernel at every radius, so a large one is a wide blur rather than a better
- * one. Two passes at O(9) beat one at O(81) and look the same.
- */
-declare function blur({ radius }: {
-    radius: number;
-}): Effect[];
-/**
- * Darken toward the corners. `amount` is how dark the corner gets (0..1) and
- * `feather` how much of the radius the falloff occupies.
- */
-declare function vignette({ amount, feather }: {
-    amount: number;
-    feather?: number;
-}): Effect[];
-
-export { type SvgIngestOptions as $, type PoseComposition as A, type PoseAdapter as B, type CullRect as C, type DrawCommand as D, type Effect as E, type GestureLifecycleOptions as F, type GroupDrawCommand as G, type SliceDep as H, IDENTITY_COLOR_MATRIX as I, type ToolsApi as J, type Tool as K, type Contribution as L, type LayerHit as M, type Node as N, type ChromeState as O, type PathDrawCommand as P, type VertexColorChannel as Q, type RenderOptions as R, SPRITE_STRIDE as S, type TextDrawCommand as T, type LayerGroup as U, type ViewAnimationOptions as V, WeaselRenderer as W, type InsertExtras as X, type SerializedScene as Y, type GeometryProjection as Z, type ContentHandlerEntry as _, type ImageDrawCommand as a, type LayoutFrame as a$, type AnyTool as a0, type PanBounds as a1, type Animator as a2, ColorOverrideRegistry as a3, type UseSceneOptions as a4, type SceneRegistry as a5, type RegisteredOp as a6, type PoseOverrides as a7, type AddNodeSpec as a8, type DerivePoseFn as a9, type ColorOverride as aA, type ColorOverrideFn as aB, type ContainerNode as aC, type ContributionChrome as aD, type CreateOutlinesResult as aE, type CustomPaintContext as aF, type DecayLoopConfig as aG, type DecayOptions as aH, type EditAnchorsDep as aI, type EventBooking as aJ, type EventBookingHandle as aK, type EventTrack as aL, type FitViewToBoundsOptions as aM, type HitTestView as aN, IDENTITY_POSE_COMPOSITION as aO, type IngestCtx as aP, type IngestionDep as aQ, type InsertDep as aR, type Interpolate as aS, type InterpolatorFactory as aT, type Keyframe as aU, type LassoSelectDep as aV, type LayerCommandCache as aW, type LayerDrawFailure as aX, type LayerDrawSpan as aY, type LayerRecord as aZ, type LayoutDep as a_, type DerivePathFn as aa, type DerivedDep as ab, type ViewportDims as ac, type ViewApi as ad, type Affordance as ae, type AffordanceRegion as af, type AffordanceBinding as ag, type CommonAffordanceScratch as ah, type BooleansAdapter as ai, type CreateOutlinesAdapter as aj, type UseAnimatorOptions as ak, type AnimationHandle as al, type SampledTrack as am, type SceneArrivalHandler as an, type AddLayerSpec as ao, type AnimateToBoundsOptions as ap, type AnimationInfo as aq, type AnimationKind as ar, type AnimatorEvent as as, type AnimatorListener as at, type AreaSelectDep as au, type BooleanOp as av, type BooleanOpResult as aw, type ClipFromPoseFn as ax, type ClipboardDep as ay, type ClipboardIngestCtx as az, type ImageMinification as b, isLayerVisible as b$, type LayoutMove as b0, type LeafNode as b1, type LiveAnimation as b2, type LoopFactory as b3, type LoopOptions as b4, type NestedTimeline as b5, type NodeAtPointDep as b6, type OutlinePathSpec as b7, type Overlay as b8, type PathInWorldPose as b9, type TextOutlinesFailure as bA, type TextPaintPath as bB, type TextToPathOptions as bC, type TimelineClock as bD, type TimelineEvent as bE, type TimelineHandle as bF, type TimelineOptions as bG, type TimelineTrack as bH, type ToolDef as bI, type Track as bJ, type TweenLoopOptions as bK, type TweenOptions as bL, type UseToolsOptions as bM, type UserLayerRecord as bN, VIEW_ANIMATION_KEY as bO, type ViewAnimationApi as bP, type ViewChannel as bQ, applyBooleanOp as bR, applyCreateOutlines as bS, asNodeId as bT, composeWorldPose as bU, createPointerStore as bV, depsUnchanged as bW, drawLayers as bX, drawOneLayer as bY, fitViewToBounds as bZ, isLayerPainted as b_, type PhysicsHandle as ba, type PhysicsOptions as bb, PointerContextProvider as bc, type PointerContextValue as bd, type PointerWorldPos as be, type PoseClosure as bf, type PoseOverride as bg, type ResizePolicy as bh, type SerializedLayer as bi, type SerializedNode as bj, type SnapDep as bk, type SpringOptions as bl, type StaggerBuilder as bm, type StaggerDelay as bn, type StaggerFactory as bo, type StaggerOptions as bp, type StaggerPerItem as bq, type StaggerSpringPoseOptions as br, type StaggerTweenOptions as bs, type SvgUnpacker as bt, type SystemLayerRecord as bu, type SystemLayerSpec as bv, type TextEditDep as bw, type TextNodeSource as bx, type TextOutlineSource as by, TextOutlinesError as bz, type RenderSpan as c, loadTextOutlines as c0, pathInPoseFrame as c1, pathInWorld as c2, rebaseLocalPose as c3, registerContentHandler as c4, resolveStrokeWidth as c5, subscribeToSources as c6, textToPath as c7, textToPathsByPaint as c8, useDecayLoop as c9, usePointerContext as ca, usePointerPosition as cb, useTools as cc, useViewAnimation as cd, useViewAnimationOn as ce, worldEditToStorage as cf, type RenderSpanStats as d, type RenderStats as e, type RenderTarget as f, type ShaderDrawCommand as g, type SolidPaint as h, type SpriteSheet as i, type SpritesDrawCommand as j, type StrokeOptions as k, type WeaselRendererOptions as l, blur as m, buildGradientRamp as n, cullDrawCommands as o, frameRect as p, vignette as q, registerEffect as r, type RenderLayer as s, tessellateStroke as t, type Dims as u, viewToMat3 as v, type RedrawSource as w, type Scene as x, type RectPose as y, type InertiaConfig as z };