@weasel-js/core 1.10.1 → 1.11.1

package/dist/depSchema-BpZNOv7q.d.ts

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